#include <map>
#include <iostream>
#include <Rtypes.h>
#include "QwUnits.h"

Include dependency graph for QwTypes.h:

This graph shows which files directly or indirectly include this file:

Data Structures
class	QwDetectorID

class	QwElectronicsID

class	QwDelayLineID

Typedefs
typedef std::map< char, EQwRegionID >	QwRegionMap

typedef std::map< char, EQwDirectionID >	QwDirectionMap

typedef std::map< char, EQwDetectorPackage >	QwPackageMap

typedef std::map< char, EQwDetectorType >	QwTypeMap

typedef std::map< EQwHelicity, int >	QwHelicityMap

typedef class QwVQWK_Channel	QwBeamCharge

typedef class QwVQWK_Channel	QwBeamPosition

typedef class QwVQWK_Channel	QwBeamAngle

typedef class QwVQWK_Channel	QwBeamEnergy

Enumerations
enum	EQwRegionID { kRegionIDNull = 0, kRegionID1, kRegionID2, kRegionID3, kRegionIDTrig, kRegionIDCer, kRegionIDScanner, kNumRegions }

enum	EQwDirectionID { kDirectionNull = 0, kDirectionX, kDirectionY, kDirectionU, kDirectionV, kDirectionR, kDirectionPhi, kDirectionLeft, kDirectionRight, kNumDirections }

enum	EQwDetectorPackage { kPackageNull = 0, kPackage1, kPackage2, kNumPackages }

enum	EQwDetectorType { kTypeNull = 0, kTypeSciFiber, kTypeDriftHDC, kTypeDriftVDC, kTypeTrigscint, kTypeCerenkov, kTypeScanner, kNumTypes }

enum	EQwPMTInstrumentType { kQwUnknownPMT = 0, kQwIntegrationPMT, kQwScalerPMT, kQwCombinedPMT, kNumInstrumentTypes }

enum	EQwBeamInstrumentType { kQwUnknownDeviceType = 0, kQwBPMStripline, kQwQPD, kQwLinearArray, kQwBCM, kQwCombinedBCM, kQwCombinedBPM, kQwEnergyCalculator, kQwHaloMonitor, kQwBPMCavity, kQwClock, kBeamDevTypes }

enum	EQwModuleType { kUnknownModuleType = 0, kV775_TDC, kV792_ADC, kF1TDC, kSIS3801, kNumModuleTypes }

enum	EQwHelicity { kHelicityUndefined, kHelicityPositive, kHelicityNegative }
	Helicity enumerator (don't use this as a signed int) More...

enum	EQwWienMode { kWienIndeterminate = 0, kWienForward, kWienBackward, kWienVertTrans, kWienHorizTrans }
	Double Wien configuration. More...

Functions
std::ostream &	operator<< (std::ostream &stream, const EQwRegionID &i)

QwRegionMap	CreateRegionMap ()

std::ostream &	operator<< (std::ostream &stream, const EQwDirectionID &i)

QwDirectionMap	CreateDirectionMap ()

std::ostream &	operator<< (std::ostream &stream, const EQwDetectorPackage &i)

QwPackageMap	CreatePackageMap ()

std::ostream &	operator<< (std::ostream &stream, const EQwDetectorType &i)

QwTypeMap	CreateTypeMap ()

UInt_t	GetGlobalErrorFlag (TString evtype, Int_t evMode, Double_t stabilitycut)

EQwPMTInstrumentType	GetQwPMTInstrumentType (TString name)

TString	GetQwPMTInstrumentTypeName (EQwPMTInstrumentType type)

EQwBeamInstrumentType	GetQwBeamInstrumentType (TString name)

TString	GetQwBeamInstrumentTypeName (EQwBeamInstrumentType type)

EQwRegionID &	operator++ (EQwRegionID &region, int)

EQwDirectionID &	operator++ (EQwDirectionID &direction, int)

EQwDetectorPackage &	operator++ (EQwDetectorPackage &package, int)

EQwDetectorType &	operator++ (EQwDetectorType &type, int)

QwHelicityMap	CreateHelicityMap ()

std::string	WienModeName (EQwWienMode type)

EQwWienMode	WienModeIndex (TString name)

Variables
static const QwRegionMap	kQwRegionMap = CreateRegionMap()

static const QwDirectionMap	kQwDirectionMap = CreateDirectionMap()

static const QwPackageMap	kQwPackageMap = CreatePackageMap()

static const QwTypeMap	kQwTypeMap = CreateTypeMap()

static const UInt_t	kErrorFlag_VQWK_Sat = 0x01

static const UInt_t	kErrorFlag_sample = 0x2

static const UInt_t	kErrorFlag_SW_HW = 0x4

static const UInt_t	kErrorFlag_Sequence = 0x8

static const UInt_t	kErrorFlag_SameHW = 0x10

static const UInt_t	kErrorFlag_ZeroHW = 0x20

static const UInt_t	kErrorFlag_EventCut_L = 0x40

static const UInt_t	kErrorFlag_EventCut_U = 0x80

static const UInt_t	kBCMErrorFlag = 0x100

static const UInt_t	kErrorFlag_BlinderFail = 0x200

static const UInt_t	kBPMErrorFlag = 0x400

static const UInt_t	kPMTErrorFlag = 0x800

static const UInt_t	kBModFFBErrorFlag = 0x1000

static const UInt_t	kBModErrorFlag = 0x8000

static const UInt_t	kEventCutMode3 = 0x10000

static const UInt_t	kBeamStabilityError = 0x10000000

static const UInt_t	kBeamTripError = 0x8000000

static const UInt_t	kGlobalCut = 0x4000000

static const UInt_t	kLocalCut = 0x2000000

static const UInt_t	kStabilityCut = 0x1000000

static const UInt_t	kPreserveError = 0x2FF

static const UInt_t	kInvalidSubelementIndex = 999999

static const QwHelicityMap	kMapHelicity = CreateHelicityMap()

Typedef Documentation

typedef class QwVQWK_Channel QwBeamAngle

Definition at line 317 of file QwTypes.h.

typedef class QwVQWK_Channel QwBeamCharge

Definition at line 315 of file QwTypes.h.

typedef class QwVQWK_Channel QwBeamEnergy

Definition at line 318 of file QwTypes.h.

typedef class QwVQWK_Channel QwBeamPosition

Definition at line 316 of file QwTypes.h.

typedef std::map< char, EQwDirectionID > QwDirectionMap

Definition at line 52 of file QwTypes.h.

typedef std::map< EQwHelicity, int > QwHelicityMap

Use the static map kMapHelicity to get the helicity sign e.g.: kMapHelicity[kHelicityPositive] will return +1

Definition at line 217 of file QwTypes.h.

typedef std::map< char, EQwDetectorPackage > QwPackageMap

Definition at line 83 of file QwTypes.h.

typedef std::map< char, EQwRegionID > QwRegionMap

Definition at line 25 of file QwTypes.h.

typedef std::map< char, EQwDetectorType > QwTypeMap

Definition at line 107 of file QwTypes.h.

Enumeration Type Documentation

enum EQwBeamInstrumentType

Enumerator
kQwUnknownDeviceType
kQwBPMStripline
kQwQPD
kQwLinearArray
kQwBCM
kQwCombinedBCM
kQwCombinedBPM
kQwEnergyCalculator
kQwHaloMonitor
kQwBPMCavity
kQwClock
kBeamDevTypes

Definition at line 132 of file QwTypes.h.

                            {
   kQwUnknownDeviceType = 0,
   kQwBPMStripline,
   kQwQPD,
   kQwLinearArray,
   kQwBCM,
   kQwCombinedBCM,
   kQwCombinedBPM,
   kQwEnergyCalculator,
   kQwHaloMonitor,
   kQwBPMCavity,
   kQwClock,
   kBeamDevTypes  // This should be the last enum; it provides the number of know types.
 };

enum EQwDetectorPackage

Enumerator
kPackageNull
kPackage1
kPackage2
kNumPackages

Definition at line 70 of file QwTypes.h.

                         {
   kPackageNull = 0,
   kPackage1,
   kPackage2,
   kNumPackages
 };

enum EQwDetectorType

Enumerator
kTypeNull
kTypeSciFiber
kTypeDriftHDC
kTypeDriftVDC
kTypeTrigscint
kTypeCerenkov
kTypeScanner
kNumTypes

Definition at line 94 of file QwTypes.h.

                      {
   kTypeNull = 0,
   kTypeSciFiber,  // Scintillating Fiber detector
   kTypeDriftHDC,  // HDC Drift chamber
   kTypeDriftVDC,  // VDC Drift chamber
   kTypeTrigscint, // Trigger scintillator
   kTypeCerenkov,  // Cerenkov detector
   kTypeScanner,   // Focal plane scanner
   kNumTypes
 };

enum EQwDirectionID

Enumerator
kDirectionNull
kDirectionX
kDirectionY
kDirectionU
kDirectionV
kDirectionR
kDirectionPhi
kDirectionLeft
kDirectionRight
kNumDirections

Definition at line 41 of file QwTypes.h.

                     {
   kDirectionNull = 0,
   kDirectionX, kDirectionY,
   kDirectionU, kDirectionV,
   kDirectionR, kDirectionPhi,
   kDirectionLeft, kDirectionRight,
   kNumDirections
 };

enum EQwHelicity

Helicity enumerator (don't use this as a signed int)

Enumerator
kHelicityUndefined
kHelicityPositive
kHelicityNegative

Definition at line 210 of file QwTypes.h.

                  {
   kHelicityUndefined,
   kHelicityPositive,
   kHelicityNegative
 };

enum EQwModuleType

Enumerator
kUnknownModuleType
kV775_TDC
kV792_ADC
kF1TDC
kSIS3801
kNumModuleTypes

Definition at line 148 of file QwTypes.h.

                    {
   kUnknownModuleType = 0,
   kV775_TDC,
   kV792_ADC,
   kF1TDC,
   kSIS3801,
   kNumModuleTypes
 };

enum EQwPMTInstrumentType

Enumerator
kQwUnknownPMT
kQwIntegrationPMT
kQwScalerPMT
kQwCombinedPMT
kNumInstrumentTypes

Definition at line 124 of file QwTypes.h.

                           {
   kQwUnknownPMT = 0,  // Unknown PMT type
   kQwIntegrationPMT,  // Integration PMT
   kQwScalerPMT,         // Scaler PMT
   kQwCombinedPMT, // Combined PMT
   kNumInstrumentTypes   // This should be the last enum; it provides the number of know types.
 };

enum EQwRegionID

Enumerator
kRegionIDNull
kRegionID1
kRegionID2
kRegionID3
kRegionIDTrig
kRegionIDCer
kRegionIDScanner
kNumRegions

Definition at line 16 of file QwTypes.h.

                  {
   kRegionIDNull = 0,
   kRegionID1,    kRegionID2,   kRegionID3,
   kRegionIDTrig, kRegionIDCer, kRegionIDScanner,
   kNumRegions
 };

enum EQwWienMode

Double Wien configuration.

Enumerator
kWienIndeterminate
kWienForward
kWienBackward
kWienVertTrans
kWienHorizTrans

Definition at line 302 of file QwTypes.h.

                  {
   kWienIndeterminate = 0,
   kWienForward,
   kWienBackward, 
   kWienVertTrans,
   kWienHorizTrans
 };

Function Documentation

QwDirectionMap CreateDirectionMap ( )

inline

Definition at line 53 of file QwTypes.h.

References kDirectionLeft, kDirectionNull, kDirectionPhi, kDirectionR, kDirectionRight, kDirectionU, kDirectionV, kDirectionX, and kDirectionY.

 {
   QwDirectionMap map;
   map['?'] = kDirectionNull;
   map['x'] = kDirectionX;
   map['y'] = kDirectionY;
   map['u'] = kDirectionU;
   map['v'] = kDirectionV;
   map['r'] = kDirectionR;
   map['f'] = kDirectionPhi;
   map['L'] = kDirectionLeft;
   map['R'] = kDirectionRight;
   return map;
 }

QwHelicityMap CreateHelicityMap ( )

inline

Definition at line 218 of file QwTypes.h.

References kHelicityNegative, kHelicityPositive, and kHelicityUndefined.

 {
   QwHelicityMap map;
   map[kHelicityUndefined] = 0;
   map[kHelicityPositive] = +1;
   map[kHelicityNegative] = -1;
   return map;
 }

QwPackageMap CreatePackageMap ( )

inline

Definition at line 84 of file QwTypes.h.

References kPackage1, kPackage2, and kPackageNull.

 {
   QwPackageMap map;
   map['?'] = kPackageNull;
   map['1'] = kPackage1;
   map['2'] = kPackage2;
   return map;
 }

QwRegionMap CreateRegionMap ( )

inline

Definition at line 26 of file QwTypes.h.

References kRegionID1, kRegionID2, kRegionID3, kRegionIDCer, kRegionIDNull, kRegionIDScanner, and kRegionIDTrig.

 {
   QwRegionMap map;
   map['?'] = kRegionIDNull;
   map['1'] = kRegionID1;
   map['2'] = kRegionID2;
   map['3'] = kRegionID3;
   map['T'] = kRegionIDTrig;
   map['C'] = kRegionIDCer;
   map['S'] = kRegionIDScanner;
   return map;
 }

QwTypeMap CreateTypeMap ( )

inline

Definition at line 108 of file QwTypes.h.

References kTypeCerenkov, kTypeDriftHDC, kTypeDriftVDC, kTypeNull, kTypeScanner, kTypeSciFiber, and kTypeTrigscint.

 {
   QwTypeMap map;
   map['?'] = kTypeNull;
   map['f'] = kTypeSciFiber;
   map['h'] = kTypeDriftHDC;
   map['v'] = kTypeDriftVDC;
   map['t'] = kTypeTrigscint;
   map['c'] = kTypeCerenkov;
   map['s'] = kTypeScanner;
   return map;
 }

UInt_t GetGlobalErrorFlag	(	TString	evtype,
		Int_t	evMode,
		Double_t	stabilitycut
	)

Definition at line 127 of file QwTypes.cc.

References kEventCutMode3, kGlobalCut, kLocalCut, and kStabilityCut.

Referenced by QwBeamLine::LoadEventCuts(), QwMainCerenkovDetector::LoadEventCuts(), QwBeamMod::LoadEventCuts(), QwIntegratedRaster::LoadEventCuts(), and QwLumi::LoadEventCuts().

                                                                             {
   UInt_t evntMode;
   if (evMode==3)
     evntMode=kEventCutMode3;
   else
     evntMode=0;
   if (evtype=="g" && stabilitycut>0)
     return (kGlobalCut|kStabilityCut|evntMode);
   else if (evtype=="g" && stabilitycut<=0)
     return (kGlobalCut|evntMode);  
   else if (evtype=="l" && stabilitycut>0)
     return (kLocalCut|evntMode|kStabilityCut);
   else if (evtype=="l" && stabilitycut<=0)
     return (kLocalCut|evntMode); 
   
   return 0;
 }

Here is the caller graph for this function:

EQwBeamInstrumentType GetQwBeamInstrumentType ( TString name )

Definition at line 29 of file QwTypes.cc.

References kQwBCM, kQwBPMCavity, kQwBPMStripline, kQwClock, kQwCombinedBCM, kQwCombinedBPM, kQwEnergyCalculator, kQwHaloMonitor, kQwLinearArray, kQwQPD, and kQwUnknownDeviceType.

Referenced by QwBeamLine::LoadChannelMap(), QwBeamLine::LoadEventCuts(), QwBeamLine::LoadGeometryDefinition(), QwBeamLine::PublishInternalValues(), and QwBeamDetectorID::QwBeamDetectorID().

                                                            {
   //  The name is passed by value because we will
   //  change it to lower case.
   name.ToLower();
   EQwBeamInstrumentType result;
   result = kQwUnknownDeviceType;
   if (name=="bpmstripline"){
     result = kQwBPMStripline;
   } 
   else if (name=="bcm"){
     result = kQwBCM;
   }
   else if (name=="combinedbcm"){
     result = kQwCombinedBCM;
   }
   else if (name=="combinedbpm"){
     result = kQwCombinedBPM;
   }
   else if (name=="energycalculator"){
     result = kQwEnergyCalculator;
   }
   else if (name=="halomonitor"){
     result = kQwHaloMonitor;
   }
   else if (name=="bpmcavity"){
     result = kQwBPMCavity;
   }
   else if (name=="qpd"){
     result = kQwQPD;
   }
   else if (name=="lineararray"){
     result = kQwLinearArray;
   }
   else if (name=="clock") {
     result = kQwClock;
   }
   return result;
 }

Here is the caller graph for this function:

TString GetQwBeamInstrumentTypeName ( EQwBeamInstrumentType type )

Definition at line 95 of file QwTypes.cc.

References kQwBCM, kQwBPMCavity, kQwBPMStripline, kQwCombinedBCM, kQwCombinedBPM, kQwEnergyCalculator, kQwHaloMonitor, kQwLinearArray, and kQwQPD.

Referenced by QwBeamLine::GetChannel(), QwBeamLine::GetElement(), QwBeamLine::LoadEventCuts(), and QwBeamLine::PublishByRequest().

                                                                {
   TString result;
   result = "kQwUnknownDeviceType";
   if (type==kQwBPMStripline){
     result = "bpmstripline";
   } 
   else if (type==kQwBCM){
     result = "bcm";
   }
   else if (type==kQwQPD){
     result = "qpd";
   }
   else if (type==kQwLinearArray){
     result = "lineararray";
   }
   else if (type==kQwCombinedBCM){
     result = "combinedbcm";
   }
   else if (type==kQwCombinedBPM){
     result = "combinedbpm";
   }
   else if (type==kQwEnergyCalculator){
     result = "energycalculator";
   }
   else if (type==kQwHaloMonitor){
     result = "halomonitor";
   }
   else if (type==kQwBPMCavity)
     result = "bpmcavity";
   return result;
 }

Here is the caller graph for this function:

EQwPMTInstrumentType GetQwPMTInstrumentType ( TString name )

Determine the EQwPMTInstrumentType value corresponding to a text name of the type, as used in the channel map files. The text comparison is not case sensitive.

Parameters

name	Text name of an instrument type, such as "IntegrationPMT"

Returns: EQwPMTInstrumentType value corresponding to the name

Definition at line 11 of file QwTypes.cc.

References kQwCombinedPMT, kQwIntegrationPMT, kQwScalerPMT, and kQwUnknownPMT.

Referenced by QwLumi::GetDetectorTypeID(), and QwMainCerenkovDetector::GetDetectorTypeID().

                                                          {
   //  The name is passed by value because we will
   //  change it to lower case.
   name.ToLower();
   EQwPMTInstrumentType result;
   result = kQwUnknownPMT;
   if (name=="integrationpmt"){
     result = kQwIntegrationPMT;
   } else if (name=="scalerpmt"){
     result = kQwScalerPMT;
   }
   else if (name=="combinationpmt"){
     result = kQwCombinedPMT;
   }
   return result;
 }

Here is the caller graph for this function:

TString GetQwPMTInstrumentTypeName ( EQwPMTInstrumentType type )

Get the text name of a EQwPMTInstrumentType, as it would be used in the channel map files.

Parameters

type	EQwPMTInstrumentType value for which the name should be returned, such as kQwPMTIntegrationPMT

Returns: Text name corresponding to the type

Definition at line 76 of file QwTypes.cc.

References kQwCombinedPMT, kQwIntegrationPMT, and kQwScalerPMT.

Referenced by QwMainCerenkovDetector::LoadEventCuts(), and QwLumi::LoadEventCuts().

                                                              {
   TString result;
   result = "UnknownPMT";
   if (type==kQwIntegrationPMT){
     result = "IntegrationPMT";
     result.ToLower();
   } 
   else if (type==kQwScalerPMT){
     result = "ScalerPMT";
     result.ToLower();
   } 
   else if (type==kQwCombinedPMT){
     result = "CombinationPMT";
     result.ToLower();
   }
   return result;
 }

Here is the caller graph for this function:

EQwRegionID& operator++	(	EQwRegionID &	region,
		int
	)

inline

Definition at line 195 of file QwTypes.h.

                                                           {
   return region = EQwRegionID(region + 1);
 }

EQwDirectionID& operator++	(	EQwDirectionID &	direction,
		int
	)

inline

Definition at line 198 of file QwTypes.h.

                                                                    {
   return direction = EQwDirectionID(direction + 1);
 }

EQwDetectorPackage& operator++	(	EQwDetectorPackage &	package,
		int
	)

inline

Definition at line 201 of file QwTypes.h.

                                                                          {
   return package = EQwDetectorPackage(package + 1);
 }

EQwDetectorType& operator++	(	EQwDetectorType &	type,
		int
	)

inline

Definition at line 204 of file QwTypes.h.

                                                                 {
   return type = EQwDetectorType(type + 1);
 }

std::ostream& operator<<	(	std::ostream &	stream,
		const EQwRegionID &	i
	)

inline

Definition at line 22 of file QwTypes.h.

                                                                          {
   stream << "?123TCS#"[i]; return stream;
 }

std::ostream& operator<<	(	std::ostream &	stream,
		const EQwDirectionID &	i
	)

inline

Definition at line 49 of file QwTypes.h.

                                                                             {
   stream << "?xyuvrfLR#"[i]; return stream;
 }

std::ostream& operator<<	(	std::ostream &	stream,
		const EQwDetectorPackage &	i
	)

inline

Definition at line 80 of file QwTypes.h.

                                                                                 {
   stream << "?12#"[i]; return stream;
 }

std::ostream& operator<<	(	std::ostream &	stream,
		const EQwDetectorType &	i
	)

inline

Definition at line 104 of file QwTypes.h.

                                                                              {
   stream << "?fhvtcs#"[i]; return stream;
 }

EQwWienMode WienModeIndex ( TString name )

Definition at line 151 of file QwTypes.cc.

References kWienBackward, kWienForward, kWienHorizTrans, kWienIndeterminate, and kWienVertTrans.

Referenced by QwEPICSEvent::FillSlowControlsSettings().

                                        {
   EQwWienMode retval = kWienIndeterminate;
   if (name=="Forward"){
     retval = kWienForward;
   } else if (name=="Backward"){
     retval = kWienBackward;
   } else if (name=="Vertical"){
     retval = kWienVertTrans;
   } else if (name=="Horizontal"){
     retval = kWienHorizTrans;
   }
   return retval;
 }

Here is the caller graph for this function:

std::string WienModeName ( EQwWienMode type )

Definition at line 145 of file QwTypes.cc.

Referenced by QwEPICSEvent::ExtractEPICSValues(), and QwBlinder::SetWienState().

                                         {
   const std::string wienname[5] = {"Indeterminate", "Forward", "Backward",
              "Vertical", "Horizontal"};
   return wienname[type];
 };