Change the X and Y values stored by the VertexerZ from (0.,0.) which are the

[u/mrichter/AliRoot.git] / STEER / AliGRPObject.h

#ifndef ALIGRPOBJECT_H\r
#define ALIGRPOBJECT_H\r
\r
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
 * See cxx source for full Copyright notice                               */\r
\r
/* $Id$ */\r
\r
//\r
// AliGRPObject\r
// class to store the information\r
// coming from the GRP preprocessor\r
// \r
\r
#include <time.h>\r
#include <TString.h>\r
\r
class TMap;\r
\r
class AliDCSSensor;\r
class AliSplineFit;\r
class AliLog;\r
\r
class AliGRPObject : public TObject {\r
 public:\r
\r
	enum Stats {kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4};\r
 	\r
 	enum StatusBits {kPolConvLHC = BIT(14), kUniformBMap = BIT(15),kConvSqrtSHalfGeV = BIT(16)};\r
\r
	enum DP_HallProbes { \r
		 khpL3bsf17H1= 0 , khpL3bsf17H2, khpL3bsf17H3, khpL3bsf17Temperature, \r
		 khpL3bsf4H1, khpL3bsf4H2, khpL3bsf4H3, khpL3bsf4Temperature, \r
		 khpL3bkf17H1, khpL3bkf17H2, khpL3bkf17H3, khpL3bkf17Temperature, \r
		 khpL3bkf4H1, khpL3bkf4H2, khpL3bkf4H3, khpL3bkf4Temperature, \r
		 khpL3bsf13H1, khpL3bsf13H2, khpL3bsf13H3, khpL3bsf13Temperature,\r
		 khpL3bsf8H1, khpL3bsf8H2, khpL3bsf8H3, khpL3bsfy8Temperature,\r
		 khpL3bkf13H1, khpL3bkf13H2, khpL3bkf13H3, khpL3bkf13Temperature,\r
		 khpL3bkf8H1, khpL3bkf8H2, khpL3bkf8H3, khpL3bkf8Temperature,\r
		 khpDipoleInsideH1, khpDipoleInsideH2, khpDipoleInsideH3, khpDipoleInsideTemperature,\r
		 khpDipoleOutsideH1, khpDipoleOutsideH2, khpDipoleOutsideH3, khpDipoleOutsideTemperature};\r
\r
\r
	AliGRPObject();\r
	AliGRPObject(const AliGRPObject & obj);\r
	AliGRPObject& operator=(const AliGRPObject & obj);\r
	~AliGRPObject();\r
\r
	// getters\r
	Bool_t    IsBeamEnergyIsSqrtSHalfGeV() const {return TestBit(kConvSqrtSHalfGeV);}\r
 	Bool_t    IsPolarityConventionLHC() const {return TestBit(kPolConvLHC);}\r
 	Bool_t    IsUniformBMap() const {return TestBit(kUniformBMap);}\r
	time_t    GetTimeStart() const {return fTimeStart;}\r
	time_t    GetTimeEnd() const {return fTimeEnd;}\r
	Float_t   GetBeamEnergy() const {return IsBeamEnergyIsSqrtSHalfGeV() ? fBeamEnergy : fBeamEnergy/2;}\r
	TString   GetBeamType() const {return fBeamType;}\r
	Char_t    GetNumberOfDetectors() const {return fNumberOfDetectors;}\r
	UInt_t    GetDetectorMask() const {return fDetectorMask;}\r
	TString   GetLHCPeriod() const {return fLHCPeriod;}\r
	TString   GetRunType() const {return fRunType;}\r
	TString   GetLHCState() const {return fLHCState;}\r
	TString   GetMachineMode() const {return fMachineMode;}\r
	TObjArray*   GetLHCStateArray() const {return fLHCStateArray;}\r
	TObjArray*   GetMachineModeArray() const {return fMachineModeArray;}\r
	Char_t    GetL3Polarity() const {return fL3Polarity;}\r
	Char_t    GetDipolePolarity() const {return fDipolePolarity;}\r
	Float_t*  GetL3Current() const {return fL3Current;}\r
	Float_t   GetL3Current(Stats stat) const {return fL3Current[stat];}\r
	Float_t*  GetDipoleCurrent() const {return fDipoleCurrent;}\r
	Float_t   GetDipoleCurrent(Stats stat) const {return fDipoleCurrent[stat];}\r
	Float_t*  GetCavernTemperature() const {return fCavernTemperature;}\r
	Float_t   GetCavernTemperature(Stats stat) const {return fCavernTemperature[stat];}\r
	AliDCSSensor*   GetCavernAtmosPressure() const {return fCavernAtmosPressure;}\r
	AliDCSSensor*   GetCavernAtmosPressure2() const {return fCavernAtmosPressure2;}\r
	AliDCSSensor*   GetSurfaceAtmosPressure() const {return fSurfaceAtmosPressure;}\r
\r
	Float_t*  GetHallProbesArray(DP_HallProbes hp) const;\r
	Float_t   GetHallProbes(Int_t hp) const {return fHallProbes[hp];}\r
	Float_t   GetHallProbes(DP_HallProbes hp, Stats stat) const {return fHallProbes[hp*fPoints+stat];}\r
\r
	Int_t    GetPoints() const {return fPoints;}\r
	Int_t    GetDimension() const {return fDimension;}\r
\r
	Double_t GetMaxTimeLHCValidity() const {return fMaxTimeLHCValidity;}\r
\r
	// setters\r
 	void SetBeamEnergyIsSqrtSHalfGeV(Bool_t v=kTRUE) {SetBit(kConvSqrtSHalfGeV,v);}\r
 	void SetPolarityConventionLHC(Bool_t v=kTRUE) {return SetBit(kPolConvLHC,v);}\r
 	void SetUniformBMap(Bool_t v=kTRUE) {return SetBit(kUniformBMap,v);}\r
	void SetTimeStart(time_t timeStart)  {fTimeStart = timeStart;}\r
	void SetTimeEnd(time_t timeEnd)  {fTimeEnd = timeEnd;}\r
	void SetBeamEnergy(Float_t beamEnergy)  {fBeamEnergy = beamEnergy;}\r
	void SetBeamType(TString beamType)  {fBeamType = beamType;}\r
	void SetNumberOfDetectors(Char_t numberOfDetectors)  {fNumberOfDetectors = numberOfDetectors;}\r
	void SetDetectorMask(UInt_t detectorMask)  {fDetectorMask = detectorMask;}\r
	void SetLHCPeriod(TString lhcPeriod)  {fLHCPeriod = lhcPeriod;}\r
	void SetRunType(TString runType)  {fRunType = runType;}\r
	void SetLHCState(TString lhcState)  {fLHCState = lhcState;}\r
	void SetMachineMode(TString machineMode)  {fMachineMode = machineMode;}\r
	void SetLHCStateArray(TObjArray* lhcStateArray)  {fLHCStateArray = lhcStateArray;}\r
	void SetMachineModeArray(TObjArray* machineModeArray)  {fMachineModeArray = machineModeArray;}\r
	void SetL3Polarity(Char_t l3Polarity)  {fL3Polarity = l3Polarity;}\r
	void SetDipolePolarity(Char_t dipolePolarity)  {fDipolePolarity = dipolePolarity;}\r
	void SetL3Current(const Float_t* l3Current)  {\r
		for (Int_t i = 0;i<fPoints;i++) fL3Current[i] = l3Current[i];\r
	}\r
	void SetL3Current(Float_t l3Current, Stats stat)  {fL3Current[stat] = l3Current;}\r
	void SetDipoleCurrent(const Float_t* dipoleCurrent) {\r
  		for (Int_t i = 0;i<fPoints;i++) fDipoleCurrent[i] = dipoleCurrent[i];\r
	}\r
	void SetDipoleCurrent(Float_t dipoleCurrent, Stats stat)  {fDipoleCurrent[stat] = dipoleCurrent;}\r
	void SetCavernTemperature(const Float_t* cavernTemperature)  {\r
  		for (Int_t i = 0;i<fPoints;i++) fCavernTemperature[i] = cavernTemperature[i];\r
	}\r
	void SetCavernTemperature(Float_t cavernTemperature, Stats stat)  {fCavernTemperature[stat] = cavernTemperature;}\r
	void SetCavernAtmosPressure(AliDCSSensor* const cavernAtmosPressure)  {fCavernAtmosPressure = cavernAtmosPressure;}\r
	void SetCavernAtmosPressure2(AliDCSSensor* const cavernAtmosPressure)  {fCavernAtmosPressure2 = cavernAtmosPressure;}\r
	void SetSurfaceAtmosPressure(AliDCSSensor* const surfacePressure)  {fSurfaceAtmosPressure = surfacePressure;}\r
\r
	void SetHallProbes(DP_HallProbes hp, Float_t hall_probe, Stats stat)  {fHallProbes[hp*fPoints+stat] = hall_probe;}\r
	void SetHallProbes(const Float_t* hall_probe){\r
		for (Int_t i = 0; i< fDimension; i++) fHallProbes[i] =  hall_probe[i];}\r
\r
	void SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe);  \r
	void SetPoints(Int_t points) {fPoints = points;}\r
	void SetDimension(Int_t dimension) {fDimension = dimension;}\r
	void SetMaxTimeLHCValidity(Double_t maxTimeLHCValidity) {fMaxTimeLHCValidity = maxTimeLHCValidity;}\r
\r
	// getters for "invalid" flags\r
\r
	static Float_t GetInvalidFloat() {return fgkInvalidFloat;}\r
	static TString GetInvalidString() {return fgkInvalidString;}\r
	static Int_t GetInvalidInt() {return fgkInvalidInt;}\r
	static Int_t GetInvalidUInt() {return fgkInvalidUInt;}\r
	static Char_t GetInvalidChar() {return fgkInvalidChar;}\r
	static Int_t GetNumberOfHP() {return fgknDCSDPHallProbes;}\r
	static const char* GetHPDP(Int_t indexHP) {return fgkDCSDataPointsHallProbes[indexHP];}\r
\r
	// to read old GRP object in TMap format\r
\r
	void ReadValuesFromMap(const TMap* map);	\r
\r
 private:\r
\r
	static const Float_t fgkInvalidFloat;   // value to identify invalid data - float\r
	static const TString fgkInvalidString;  // value to identify invalid data - string\r
	static const Char_t fgkInvalidChar;     // value to identify invalid data - char\r
	static const Int_t fgkInvalidInt;       // value to identify invalid data - int\r
	static const Int_t fgkInvalidUInt;       // value to identify invalid data - uint\r
	static const Int_t   fgknDCSDPHallProbes;               //! number of dcs dps\r
	static const char*   fgkDCSDataPointsHallProbes[];      //! names of dcs dps\r
\r
	Int_t fPoints;                    // number of statistical quantities to be stored\r
	Int_t fDimension;                 // dimension of Hall Probes array\r
\r
	time_t   fTimeStart;              // DAQ_time_start entry from DAQ logbook\r
 	time_t   fTimeEnd;                // DAQ_time_end entry from DAQ logbook\r
	Float_t  fBeamEnergy;             // beamEnergy entry from DAQ logbook\r
	TString  fBeamType;               // beamType entry from DAQ logbook\r
	Char_t   fNumberOfDetectors;      // numberOfDetectors entry from DAQ logbook\r
	UInt_t   fDetectorMask;           // detectorMask entry from DAQ logbook\r
	TString  fLHCPeriod;              // LHCperiod entry from DAQ logbook \r
	TString  fRunType;                // RunType entry from DAQ logbook \r
	TString  fLHCState;               // LHCState entry from DCS DB\r
	Char_t    fL3Polarity;            // L3Polarity entry from DCS DB\r
	Char_t    fDipolePolarity;        // DipolePolarity entry from DCS DB 	                                  \r
	Float_t*  fL3Current;             // [fPoints]\r
	                                  // L3Current entry from DCS DB\r
	Float_t*  fDipoleCurrent;         // [fPoints]\r
                                          // DipoleCurrent entry from DCS DB\r
	Float_t*  fCavernTemperature;     // [fPoints]\r
                                          // CavernTemperature entry from DCS DB\r
	AliDCSSensor*  fCavernAtmosPressure;    // CavernAtmosPressure entry from DCS DB\r
	AliDCSSensor*  fCavernAtmosPressure2;    // CavernAtmosPressure2 entry from DCS DB\r
	AliDCSSensor*  fSurfaceAtmosPressure;   // SurfaceAtmosPressure entry from DCS DB\r
\r
	// Hall Probes\r
\r
	Float_t* fHallProbes;       //[fDimension] \r
	                            // array containg the values for the Hall Probes\r
\r
	TString  fMachineMode;      // Machine Mode from LHC\r
\r
	TObjArray* fLHCStateArray;     // Array of values for the LHC State\r
	TObjArray* fMachineModeArray;  // Array of values for the LHC State\r
\r
	Double_t fMaxTimeLHCValidity;    // time until which the LHC Data Machine Mode and Beam Mode didn't change \r
\r
	ClassDef(AliGRPObject,6)\r
\r
};\r
\r
#endif\r