STEER/STEER/AliGRPObject.h

   1 #ifndef ALIGRPOBJECT_H\r
   2 #define ALIGRPOBJECT_H\r
   3 \r
   4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
   5  * See cxx source for full Copyright notice                               */\r
   6 \r
   7 /* $Id$ */\r
   8 \r
   9 //\r
  10 // AliGRPObject\r
  11 // class to store the information\r
  12 // coming from the GRP preprocessor\r
  13 // \r
  14 \r
  15 #include <time.h>\r
  16 #include <TString.h>\r
  17 #include <TTimeStamp.h>\r
  18 #include <TArrayD.h>\r
  19 \r
  20 class TMap;\r
  21 \r
  22 class AliDCSSensor;\r
  23 class AliSplineFit;\r
  24 class AliLog;\r
  25 \r
  26 class AliGRPObject : public TObject {\r
  27  public:\r
  28 \r
  29         enum Stats {kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4};\r
  30         \r
  31         enum StatusBits {kPolConvLHC = BIT(14), kUniformBMap = BIT(15),kConvSqrtSHalfGeV = BIT(16)};\r
  32 \r
  33         enum DP_HallProbes { \r
  34                  khpL3bsf17H1= 0 , khpL3bsf17H2, khpL3bsf17H3, khpL3bsf17Temperature, \r
  35                  khpL3bsf4H1, khpL3bsf4H2, khpL3bsf4H3, khpL3bsf4Temperature, \r
  36                  khpL3bkf17H1, khpL3bkf17H2, khpL3bkf17H3, khpL3bkf17Temperature, \r
  37                  khpL3bkf4H1, khpL3bkf4H2, khpL3bkf4H3, khpL3bkf4Temperature, \r
  38                  khpL3bsf13H1, khpL3bsf13H2, khpL3bsf13H3, khpL3bsf13Temperature,\r
  39                  khpL3bsf8H1, khpL3bsf8H2, khpL3bsf8H3, khpL3bsfy8Temperature,\r
  40                  khpL3bkf13H1, khpL3bkf13H2, khpL3bkf13H3, khpL3bkf13Temperature,\r
  41                  khpL3bkf8H1, khpL3bkf8H2, khpL3bkf8H3, khpL3bkf8Temperature,\r
  42                  khpDipoleInsideH1, khpDipoleInsideH2, khpDipoleInsideH3, khpDipoleInsideTemperature,\r
  43                  khpDipoleOutsideH1, khpDipoleOutsideH2, khpDipoleOutsideH3, khpDipoleOutsideTemperature};\r
  44 \r
  45 \r
  46         AliGRPObject();\r
  47         AliGRPObject(const AliGRPObject & obj);\r
  48         AliGRPObject& operator=(const AliGRPObject & obj);\r
  49         ~AliGRPObject();\r
  50 \r
  51         // getters\r
  52         Bool_t    IsBeamEnergyIsSqrtSHalfGeV() const {return TestBit(kConvSqrtSHalfGeV);}\r
  53         Bool_t    IsPolarityConventionLHC() const {return TestBit(kPolConvLHC);}\r
  54         Bool_t    IsUniformBMap() const {return TestBit(kUniformBMap);}\r
  55         time_t    GetTimeStart() const {return fTimeStart;}\r
  56         time_t    GetTimeEnd() const {return fTimeEnd;}\r
  57         Float_t   GetBeamEnergy() const;\r
  58         TString   GetBeamType() const {return fBeamType;}\r
  59         Char_t    GetNumberOfDetectors() const {return fNumberOfDetectors;}\r
  60         UInt_t    GetDetectorMask() const {return fDetectorMask;}\r
  61         TString   GetLHCPeriod() const {return fLHCPeriod;}\r
  62         TString   GetRunType() const {return fRunType;}\r
  63         TString   GetLHCState() const {return fLHCState;}\r
  64         TString   GetMachineMode() const {return fMachineMode;}\r
  65         TObjArray*   GetLHCStateArray() const {return fLHCStateArray;}\r
  66         TObjArray*   GetMachineModeArray() const {return fMachineModeArray;}\r
  67         Char_t    GetL3Polarity() const {return fL3Polarity;}\r
  68         Char_t    GetDipolePolarity() const {return fDipolePolarity;}\r
  69         Float_t*  GetL3Current() const {return fL3Current;}\r
  70         Float_t   GetL3Current(Stats stat) const {return fL3Current[stat];}\r
  71         Float_t*  GetDipoleCurrent() const {return fDipoleCurrent;}\r
  72         Float_t   GetDipoleCurrent(Stats stat) const {return fDipoleCurrent[stat];}\r
  73         Float_t*  GetCavernTemperature() const {return fCavernTemperature;}\r
  74         Float_t   GetCavernTemperature(Stats stat) const {return fCavernTemperature[stat];}\r
  75         AliDCSSensor*   GetCavernAtmosPressure() const {return fCavernAtmosPressure;}\r
  76         AliDCSSensor*   GetCavernAtmosPressure2() const {return fCavernAtmosPressure2;}\r
  77         AliDCSSensor*   GetSurfaceAtmosPressure() const {return fSurfaceAtmosPressure;}\r
  78         AliDCSSensor*   GetBestCavernAtmosPressure() const ;\r
  79         AliDCSSensor*   GetBestCavernAtmosPressure(const TTimeStamp& time) const;\r
  80         static AliDCSSensor* GetBestCavernAtmosPressure(AliDCSSensor* cavern1, \r
  81                            AliDCSSensor* cavern2, AliDCSSensor* surface, const TTimeStamp& time);\r
  82 \r
  83 \r
  84         Float_t*  GetHallProbesArray(DP_HallProbes hp) const;\r
  85         Float_t   GetHallProbes(Int_t hp) const {return fHallProbes[hp];}\r
  86         Float_t   GetHallProbes(DP_HallProbes hp, Stats stat) const {return fHallProbes[hp*fPoints+stat];}\r
  87 \r
  88         Int_t    GetPoints() const {return fPoints;}\r
  89         Int_t    GetDimension() const {return fDimension;}\r
  90 \r
  91         Double_t GetMaxTimeLHCValidity() const {return fMaxTimeLHCValidity;}\r
  92         //\r
  93         TObjArray* GetQATrigClasses()    const {return (TObjArray*)fQATrigClasses;}\r
  94         TObjArray* GetQACloningRequest() const {return (TObjArray*)fQACloningRequest;}\r
  95         //\r
  96         // setters\r
  97         void SetBeamEnergyIsSqrtSHalfGeV(Bool_t v=kTRUE) {SetBit(kConvSqrtSHalfGeV,v);}\r
  98         void SetPolarityConventionLHC(Bool_t v=kTRUE) {return SetBit(kPolConvLHC,v);}\r
  99         void SetUniformBMap(Bool_t v=kTRUE) {return SetBit(kUniformBMap,v);}\r
 100         void SetTimeStart(time_t timeStart)  {fTimeStart = timeStart;}\r
 101         void SetTimeEnd(time_t timeEnd)  {fTimeEnd = timeEnd;}\r
 102         void SetBeamEnergy(Float_t beamEnergy)  {fBeamEnergy = beamEnergy;}\r
 103         void SetBeamType(TString beamType)  {fBeamType = beamType;}\r
 104         void SetNumberOfDetectors(Char_t numberOfDetectors)  {fNumberOfDetectors = numberOfDetectors;}\r
 105         void SetDetectorMask(UInt_t detectorMask)  {fDetectorMask = detectorMask;}\r
 106         void SetLHCPeriod(TString lhcPeriod)  {fLHCPeriod = lhcPeriod;}\r
 107         void SetRunType(TString runType)  {fRunType = runType;}\r
 108         void SetLHCState(TString lhcState)  {fLHCState = lhcState;}\r
 109         void SetMachineMode(TString machineMode)  {fMachineMode = machineMode;}\r
 110         void SetLHCStateArray(TObjArray* lhcStateArray)  {fLHCStateArray = lhcStateArray;}\r
 111         void SetMachineModeArray(TObjArray* machineModeArray)  {fMachineModeArray = machineModeArray;}\r
 112         void SetL3Polarity(Char_t l3Polarity)  {fL3Polarity = l3Polarity;}\r
 113         void SetDipolePolarity(Char_t dipolePolarity)  {fDipolePolarity = dipolePolarity;}\r
 114         void SetL3Current(const Float_t* l3Current)  {\r
 115                 for (Int_t i = 0;i<fPoints;i++) fL3Current[i] = l3Current[i];\r
 116         }\r
 117         void SetL3Current(Float_t l3Current, Stats stat)  {fL3Current[stat] = l3Current;}\r
 118         void SetDipoleCurrent(const Float_t* dipoleCurrent) {\r
 119                 for (Int_t i = 0;i<fPoints;i++) fDipoleCurrent[i] = dipoleCurrent[i];\r
 120         }\r
 121         void SetDipoleCurrent(Float_t dipoleCurrent, Stats stat)  {fDipoleCurrent[stat] = dipoleCurrent;}\r
 122         void SetCavernTemperature(const Float_t* cavernTemperature)  {\r
 123                 for (Int_t i = 0;i<fPoints;i++) fCavernTemperature[i] = cavernTemperature[i];\r
 124         }\r
 125         void SetCavernTemperature(Float_t cavernTemperature, Stats stat)  {fCavernTemperature[stat] = cavernTemperature;}\r
 126         void SetCavernAtmosPressure(AliDCSSensor* const cavernAtmosPressure)  {fCavernAtmosPressure = cavernAtmosPressure;}\r
 127         void SetCavernAtmosPressure2(AliDCSSensor* const cavernAtmosPressure)  {fCavernAtmosPressure2 = cavernAtmosPressure;}\r
 128         void SetSurfaceAtmosPressure(AliDCSSensor* const surfacePressure)  {fSurfaceAtmosPressure = surfacePressure;}\r
 129 \r
 130         void SetHallProbes(DP_HallProbes hp, Float_t hall_probe, Stats stat)  {fHallProbes[hp*fPoints+stat] = hall_probe;}\r
 131         void SetHallProbes(const Float_t* hall_probe){\r
 132                 for (Int_t i = 0; i< fDimension; i++) fHallProbes[i] =  hall_probe[i];}\r
 133 \r
 134         void SetHallProbes(DP_HallProbes hp, const Float_t* hall_probe);  \r
 135         void SetPoints(Int_t points) {fPoints = points;}\r
 136         void SetDimension(Int_t dimension) {fDimension = dimension;}\r
 137         void SetMaxTimeLHCValidity(Double_t maxTimeLHCValidity) {fMaxTimeLHCValidity = maxTimeLHCValidity;}\r
 138         //\r
 139         void SetQATrigClasses(TObjArray* arr)    {fQATrigClasses = arr;}\r
 140         void SetQACloningRequest(TObjArray* arr) {fQACloningRequest = arr;}\r
 141         //\r
 142         // getters for "invalid" flags\r
 143 \r
 144         static Float_t GetInvalidFloat() {return fgkInvalidFloat;}\r
 145         static TString GetInvalidString() {return fgkInvalidString;}\r
 146         static Int_t GetInvalidInt() {return fgkInvalidInt;}\r
 147         static Int_t GetInvalidUInt() {return fgkInvalidUInt;}\r
 148         static Char_t GetInvalidChar() {return fgkInvalidChar;}\r
 149         static Int_t GetNumberOfHP() {return fgknDCSDPHallProbes;}\r
 150         static const char* GetHPDP(Int_t indexHP) {return fgkDCSDataPointsHallProbes[indexHP];}\r
 151 \r
 152         Double_t EvalCavernPressure(const TTimeStamp& time, Bool_t& inside) const;\r
 153         static Double_t EvalCavernPressure(AliDCSSensor* cavern1, \r
 154                       AliDCSSensor* cavern2, AliDCSSensor* surface, \r
 155                       const TTimeStamp& time, Bool_t& inside);\r
 156 \r
 157         // to read old GRP object in TMap format\r
 158 \r
 159         void ReadValuesFromMap(const TMap* map);        \r
 160 \r
 161         void SetSingleBeamType(Int_t ibeamType, TString beamType)  {fSeparateBeamType[ibeamType] = beamType;}\r
 162         TString   GetSingleBeamType(Int_t ibeamType) const {return fSeparateBeamType[ibeamType];}\r
 163 \r
 164         void SetNFalseDataQualityFlag(Int_t nFalses) {fNFalseDataQualityFlag = nFalses;}\r
 165         Int_t GetNFalseDataQualityFlag() const {return fNFalseDataQualityFlag;}\r
 166 \r
 167         void SetFalseDataQualityFlagPeriods(Double_t* falses);\r
 168         TArrayD* GetFalseDataQualityFlagPeriods() const {return fFalseDataQualityFlag;}\r
 169 \r
 170         Double_t GetStartFalseDataQualityFlag(Int_t iperiod) const;\r
 171         Double_t GetEndFalseDataQualityFlag(Int_t iperiod) const;\r
 172 \r
 173         void SetBeamTypeFromLHC(TString beamTypeFromLHC)  {fBeamTypeFromLHC = beamTypeFromLHC;}\r
 174         TString   GetBeamTypeFromLHC() const {return fBeamTypeFromLHC;}\r
 175 \r
 176  private:\r
 177 \r
 178         static const Float_t fgkInvalidFloat;   // value to identify invalid data - float\r
 179         static const TString fgkInvalidString;  // value to identify invalid data - string\r
 180         static const Char_t fgkInvalidChar;     // value to identify invalid data - char\r
 181         static const Int_t fgkInvalidInt;       // value to identify invalid data - int\r
 182         static const Int_t fgkInvalidUInt;       // value to identify invalid data - uint\r
 183         static const Int_t   fgknDCSDPHallProbes;               //! number of dcs dps\r
 184         static const char*   fgkDCSDataPointsHallProbes[];      //! names of dcs dps\r
 185 \r
 186         Int_t fPoints;                    // number of statistical quantities to be stored\r
 187         Int_t fDimension;                 // dimension of Hall Probes array\r
 188 \r
 189         time_t   fTimeStart;              // DAQ_time_start entry from DAQ logbook\r
 190         time_t   fTimeEnd;                // DAQ_time_end entry from DAQ logbook\r
 191         Float_t  fBeamEnergy;             // beamEnergy entry from DAQ logbook\r
 192         TString  fBeamType;               // beamType entry from DAQ logbook\r
 193         Char_t   fNumberOfDetectors;      // numberOfDetectors entry from DAQ logbook\r
 194         UInt_t   fDetectorMask;           // detectorMask entry from DAQ logbook\r
 195         TString  fLHCPeriod;              // LHCperiod entry from DAQ logbook \r
 196         TString  fRunType;                // RunType entry from DAQ logbook \r
 197         TString  fLHCState;               // LHCState entry from DCS DB\r
 198         Char_t    fL3Polarity;            // L3Polarity entry from DCS DB\r
 199         Char_t    fDipolePolarity;        // DipolePolarity entry from DCS DB                                     \r
 200         Float_t*  fL3Current;             // [fPoints]\r
 201                                           // L3Current entry from DCS DB\r
 202         Float_t*  fDipoleCurrent;         // [fPoints]\r
 203                                           // DipoleCurrent entry from DCS DB\r
 204         Float_t*  fCavernTemperature;     // [fPoints]\r
 205                                           // CavernTemperature entry from DCS DB\r
 206         AliDCSSensor*  fCavernAtmosPressure;    // CavernAtmosPressure entry from DCS DB\r
 207         AliDCSSensor*  fCavernAtmosPressure2;    // CavernAtmosPressure2 entry from DCS DB\r
 208         AliDCSSensor*  fSurfaceAtmosPressure;   // SurfaceAtmosPressure entry from DCS DB\r
 209 \r
 210         // Hall Probes\r
 211 \r
 212         Float_t* fHallProbes;       //[fDimension] \r
 213                                     // array containg the values for the Hall Probes\r
 214 \r
 215         TString  fMachineMode;      // Machine Mode from LHC\r
 216         TObjArray* fLHCStateArray;     // Array of values for the LHC State\r
 217         TObjArray* fMachineModeArray;  // Array of values for the LHC State\r
 218         TObjArray* fQATrigClasses;     // RS: Array of trigger class to watch in QA\r
 219         TObjArray* fQACloningRequest;  // RS: Array of cloning requests for QA histos\r
 220         Double_t fMaxTimeLHCValidity;    // time until which the LHC Data Machine Mode and Beam Mode didn't change \r
 221         TString  fSeparateBeamType[2];   // separate beam Types from LHC\r
 222         Int_t fNFalseDataQualityFlag;    // number of times the data quality flag turned to FALSE\r
 223         TArrayD* fFalseDataQualityFlag;  // array of starts (even positions) and ends (odd poistions) of the periods\r
 224                                          // when the data quality flag was FALSE\r
 225         TString fBeamTypeFromLHC;        // string containing the information about the beam types AS SENT BY LHC (in the form "beam1-beam2")\r
 226         \r
 227         ClassDef(AliGRPObject,10)\r
 228 \r
 229 };\r
 230 \r
 231 #endif\r