STEER/AliLHCData.h

   1 #ifndef ALILHCDATA_H\r
   2 #define ALILHCDATA_H\r
   3 \r
   4 /********************************************************************************\r
   5 *                                                                               *\r
   6 *   AliLHCData: summary of the LHC related information from LHC DIP.            *\r
   7 *   Created from the TMap provided by the AliLHCReader with optional beginning  *\r
   8 *                                                                               *\r
   9 *   The data are (wrapped in the AliLHCDipValT):                                *\r
  10 *   made of TimeStamp (double) and array of values                              *\r
  11 *                                                                               *\r
  12 *   Multiple entries for each type of data are possible. To obtaine number of   *\r
  13 *   records (with distinct timestamp) for give type od records use:             *\r
  14 *   int GetNBunchConfigMeasured(int beam) (with beam=0,1) etc.                  *\r
  15 *                                                                               *\r
  16 *   To get i-th entry, use brec= AliLHCDipValI* GetBunchConfigMeasured(bm,i);   *\r
  17 *   Note: exact type of templated AliLHCDipValT pointer depends on the record   *\r
  18 *   type, concult getters to know it.                                           *\r
  19 *                                                                               *\r
  20 *   Then, once the pointer is obtained, details can be accessed:                *\r
  21 *   int nBunches = brec->GetSize();                                             *\r
  22 *   for (int i=0;i<nBunches;i++) printf("Bunch#%d: %d\n",i,(*brec)[i]);         *\r
  23 *                                                                               *\r
  24 *   ATTENTION: Bunch RFBucked is NEGATIVE for bunches interacting at IR2        *\r
  25 *                                                                               *\r
  26 *                                                                               *\r
  27 *                                                                               *\r
  28 *   Author: ruben.shahoyan@cern.ch                                              *\r
  29 *                                                                               *\r
  30 ********************************************************************************/\r
  31 \r
  32 #include "AliLHCDipValT.h"\r
  33 #include "TObject.h"\r
  34 class TObjArray;\r
  35 //class AliLHCDipValT;\r
  36 \r
  37 class AliDCSArray;\r
  38 class TString;\r
  39 class TMap;\r
  40 class AliLHCReader;\r
  41 \r
  42 \r
  43 class AliLHCData : public TObject\r
  44 {\r
  45  public:\r
  46   enum          {kStart,kNStor};\r
  47   enum BeamID_t {kBeam1,kBeam2};\r
  48   enum Proj_t   {kX,kY};\r
  49   enum Side_t   {kLeft,kRight};\r
  50   enum Collim_t {kTCTVB4L2, kTCTVB4R2, kTCLIA4R2, kNCollimators};\r
  51   enum ColJaw_t {kGapDn,kGapUp,kLeftDn,kLeftUp,kRightDn,kRightUp,kNJaws};\r
  52   enum          {kMaxBSlots = 3564};\r
  53   enum          {kMarginSOR = 60*60*24*30, // use margin of 30 days for SOR, when looking for the 1st record\r
  54                  kMarginEOR = 60*15};      // use margin of 15 min for EOR, when looking for the last record\r
  55   //\r
  56   enum {kIntTot,kIntTotAv,kIntBunchAv,\r
  57         kLumAcqMode,kLumTot,kLumTotErr,kLumBunch,kLumBunchErr,kLumCrossAng,kLumCrossAngErr,\r
  58         kBunchConf,kFillNum,kBunchLgtNB,kBunchLgt,kBunchLgtFillB,\r
  59         kRCInjSch,kRCBeta,kRCCrossAng,kRCVang,\r
  60         kBeamSzAcqMode,kBeamSzSigH,kBeamSzSigV,kBeamSzEmittH,kBeamSzEmittV,kBeamSzSigHErr,kBeamSzSigVErr,\r
  61         kCollPos};\r
  62   //\r
  63   //le\r
  64  public:\r
  65   //\r
  66  AliLHCData() : fTMin(0),fTMax(1e10),fFillNumber(0),fData(0),fFile2Process(0),fMap2Process(0) {Clear();}\r
  67   AliLHCData(const TMap*   dcsMap,  double tmin=0, double tmax=1.e10);\r
  68   AliLHCData(const Char_t* dcsFile, double tmin=0, double tmax=1.e10);\r
  69   virtual ~AliLHCData() {}\r
  70   //\r
  71   Bool_t                FillData(const TMap*   dcsMap,  double tmin=0, double tmax=1.e20);\r
  72   Bool_t                FillData(const Char_t* dcsFile, double tmin=0, double tmax=1.e20);\r
  73   Double_t              GetTMin()                                    const {return fTMin;}\r
  74   Double_t              GetTMax()                                    const {return fTMax;}\r
  75   Int_t                 GetFillNumber()                              const {return fFillNumber;}\r
  76   void                  SetFillNumber(Int_t fill)                          {fFillNumber = fill;}\r
  77   void                  SetTMin(Double_t t)                                {fTMin = t<0?0:(t>1e10?1e10:t);}\r
  78   void                  SetTMax(Double_t t)                                {fTMax = t<0?0:(t>1e10?1e10:t);}\r
  79   //\r
  80   virtual void          Print(const Option_t *opt="")                const;\r
  81   //\r
  82   Int_t GetNBunchConfigMeasured(int bm)           const {return GoodPairID(bm)?fBunchConfMeas[bm][kNStor]:-1;}\r
  83   Int_t GetNBunchConfigDeclared(int bm)           const {return GoodPairID(bm)?fBunchConfDecl[bm][kNStor]:-1;}\r
  84   Int_t GetNBunchLengths(int bm)                  const {return GoodPairID(bm)?fBunchLengths[bm][kNStor]:-1;}\r
  85   Int_t GetNTotalIntensity(int bm)                const {return GoodPairID(bm)?fIntensTotal[bm][kNStor]:-1;}\r
  86   Int_t GetNTotalIntensityAv(int bm)              const {return GoodPairID(bm)?fIntensTotalAv[bm][kNStor]:-1;}\r
  87   Int_t GetNIntensityPerBunch(int bm)             const {return GoodPairID(bm)?fIntensPerBunch[bm][kNStor]:-1;}\r
  88   Int_t GetNEmittanceH(int bm)                    const {return GoodPairID(bm)?fEmittanceH[bm][kNStor]:-1;}\r
  89   Int_t GetNEmittanceV(int bm)                    const {return GoodPairID(bm)?fEmittanceV[bm][kNStor]:-1;}\r
  90   Int_t GetNBeamSigmaH(int bm)                    const {return GoodPairID(bm)?fBeamSigmaH[bm][kNStor]:-1;}\r
  91   Int_t GetNBeamSigmaV(int bm)                    const {return GoodPairID(bm)?fBeamSigmaV[bm][kNStor]:-1;}\r
  92   //\r
  93   Int_t GetNLuminosityTotal(int lr)               const {return GoodPairID(lr)?fLuminTotal[lr][kNStor]:-1;}\r
  94   Int_t GetNLuminosityPerBunch(int lr)            const {return GoodPairID(lr)?fLuminPerBC[lr][kNStor]:-1;}\r
  95   Int_t GetNLuminosityAcqMode(int lr)             const {return GoodPairID(lr)?fLuminAcqMode[lr][kNStor]:-1;}\r
  96   Int_t GetNCrossingAngle(int lr)                 const {return GoodPairID(lr)?fCrossAngle[lr][kNStor]:-1;}\r
  97   //\r
  98   Int_t GetNInjectionScheme()                     const {return fRCInjScheme[kNStor];}\r
  99   Int_t GetNRCBetaStar()                          const {return fRCBeta[kNStor];}\r
 100   Int_t GetNRCAngleH()                            const {return fRCAngH[kNStor];}\r
 101   Int_t GetNRCAngleV()                            const {return fRCAngV[kNStor];}\r
 102   //\r
 103   Int_t GetNCollimatorJawPos(int coll,int jaw)    const;\r
 104   //\r
 105   AliLHCDipValI* GetBunchConfigMeasured(int bm, int i=0)  const;\r
 106   AliLHCDipValF* GetBunchLengths(int bm, int i=0)         const;\r
 107   AliLHCDipValI* GetBunchConfigDeclared(int bm, int i=0)  const;\r
 108   AliLHCDipValF* GetTotalIntensity(int bm, int i=0)       const;\r
 109   AliLHCDipValF* GetTotalIntensityAv(int bm, int i=0)     const;\r
 110   AliLHCDipValF* GetIntensityPerBunch(int bm, int i=0)    const;\r
 111   AliLHCDipValF* GetEmittanceH(int bm, int i=0)           const;\r
 112   AliLHCDipValF* GetEmittanceV(int bm, int i=0)           const;\r
 113   AliLHCDipValF* GetBeamSigmaH(int bm, int i=0)           const;\r
 114   AliLHCDipValF* GetBeamSigmaV(int bm, int i=0)           const;\r
 115   AliLHCDipValF* GetLuminosityTotal(int lr, int i=0)      const;\r
 116   AliLHCDipValF* GetLuminosityPerBunch(int lr, int i=0)   const;\r
 117   AliLHCDipValI* GetLuminosityAcqMode(int lr, int i=0)    const;\r
 118   AliLHCDipValF* GetCrossAngle(int lr, int i=0)           const;\r
 119   AliLHCDipValC* GetInjectionScheme(int i=0)              const;\r
 120   AliLHCDipValF* GetRCBetaStar(int i=0)                   const;\r
 121   AliLHCDipValF* GetRCAngleH(int i=0)                     const; \r
 122   AliLHCDipValF* GetRCAngleV(int i=0)                     const; \r
 123   AliLHCDipValF* GetCollimJawPos(int coll, int jaw, int i=0) const;\r
 124   //\r
 125   void           FlagInteractingBunches(const Int_t beam1[2],const Int_t beam2[2]);\r
 126   TObject*       FindRecValidFor(int start,int nrec, double tstamp) const;\r
 127   AliLHCDipValI* GetBunchConfigMeasured(int beam,double tstamp)  const;\r
 128   AliLHCDipValI* GetBunchConfigDeclared(int beam,double tstamp)  const;\r
 129   Int_t          GetNInteractingBunchesMeasured(int i=0)         const;\r
 130   Int_t          GetNInteractingBunchesDeclared(int i=0)         const;\r
 131   Int_t          IsPilotPresent(int i=0)                         const;\r
 132   //\r
 133   // return array with beginning [0] and number of records for corresponding info (in the fData)\r
 134   const Int_t* GetOffsBunchConfigMeasured(int bm)         const {return GoodPairID(bm)?fBunchConfMeas[bm]:0;}\r
 135   const Int_t* GetOffsBunchConfigDeclared(int bm)         const {return GoodPairID(bm)?fBunchConfDecl[bm]:0;}\r
 136   const Int_t* GetOffsBunchLengths(int bm)                const {return GoodPairID(bm)?fBunchLengths[bm]:0;}\r
 137   const Int_t* GetOffsTotalIntensity(int bm)              const {return GoodPairID(bm)?fIntensTotal[bm]:0;}\r
 138   const Int_t* GetOffsTotalIntensityAv(int bm)            const {return GoodPairID(bm)?fIntensTotalAv[bm]:0;}\r
 139   const Int_t* GetOffsIntensityPerBunch(int bm)           const {return GoodPairID(bm)?fIntensPerBunch[bm]:0;}\r
 140   const Int_t* GetOffsEmittanceH(int bm)                  const {return GoodPairID(bm)?fEmittanceH[bm]:0;}\r
 141   const Int_t* GetOffsEmittanceV(int bm)                  const {return GoodPairID(bm)?fEmittanceV[bm]:0;}\r
 142   const Int_t* GetOffsBeamSigmaH(int bm)                  const {return GoodPairID(bm)?fBeamSigmaH[bm]:0;}\r
 143   const Int_t* GetOffsBeamSigmaV(int bm)                  const {return GoodPairID(bm)?fBeamSigmaV[bm]:0;}\r
 144   //\r
 145   const Int_t* GetOffsLuminosityTotal(int lr)             const {return GoodPairID(lr)?fLuminTotal[lr]:0;}\r
 146   const Int_t* GetOffsLuminosityPerBunch(int lr)          const {return GoodPairID(lr)?fLuminPerBC[lr]:0;}\r
 147   const Int_t* GetOffsLuminosityAcqMode(int lr)           const {return GoodPairID(lr)?fLuminAcqMode[lr]:0;}\r
 148   const Int_t* GetOffsCrossingAngle(int lr)               const {return GoodPairID(lr)?fCrossAngle[lr]:0;}\r
 149   //\r
 150   const Int_t* GetOffsInjectionScheme()                   const {return fRCInjScheme;}\r
 151   const Int_t* GetOffsRCBetaStar()                        const {return fRCBeta;}\r
 152   const Int_t* GetOffsRCAngleH()                          const {return fRCAngH;}\r
 153   const Int_t* GetOffsRCAngleV()                          const {return fRCAngV;}\r
 154   //\r
 155   const Int_t* GetOffsCollimatorJawPos(int coll,int jaw)  const;\r
 156   //\r
 157   const TObjArray&  GetData()                             const {return fData;}\r
 158   //\r
 159   // analysis methods\r
 160   Int_t GetMeanIntensity(int beamID, Double_t &colliding, Double_t &noncolliding) const;\r
 161   //\r
 162  protected:\r
 163   //\r
 164   Bool_t                FillData(double tmin=0, double tmax=1.e20);\r
 165   virtual void          Clear(const Option_t *opt="");\r
 166   void                  PrintAux(Bool_t full,const Int_t refs[2],const Option_t *opt="") const;\r
 167   TObjArray*            GetDCSEntry(const char* key,int &entry,int &last,double tmin,double tmax) const;\r
 168   Int_t                 FillScalarRecord(  int refs[2], const char* rec, const char* recErr=0);\r
 169   Int_t                 FillBunchConfig(   int refs[2], const char* rec);\r
 170   Int_t                 FillStringRecord(  int refs[2], const char* rec);\r
 171   Int_t                 FillAcqMode(       int refs[2], const char* rec);\r
 172   Int_t                 FillBunchInfo(     int refs[2], const char* rec,int ibm, Bool_t inRealSlots);\r
 173   Int_t                 FillBCLuminosities(int refs[2], const char* rec, const char* recErr, Int_t useBeam);\r
 174   //\r
 175   Int_t                 ExtractInt(AliDCSArray* dcsArray,Int_t el)    const;\r
 176   Double_t              ExtractDouble(AliDCSArray* dcsArray,Int_t el) const;\r
 177   TString&              ExtractString(AliDCSArray* dcsArray)          const;\r
 178  AliLHCData(const AliLHCData& src) : TObject(src),fTMin(0),fTMax(0),fFillNumber(0),fData(0),fFile2Process(0),fMap2Process(0) { /*dummy*/ }\r
 179   AliLHCData& operator=(const AliLHCData& ) { /*dummy*/ return *this;}\r
 180   Int_t                 TimeDifference(double v1,double v2,double tol=0.9) const;\r
 181   Bool_t                IzZero(double val, double tol=1e-16)         const {return TMath::Abs(val)<tol;}\r
 182   Bool_t                GoodPairID(int beam)                         const;\r
 183   //\r
 184  protected:\r
 185   //\r
 186   Double_t        fTMin;                              // selection timeMin\r
 187   Double_t        fTMax;                              // selection timeMax\r
 188   Int_t           fFillNumber;                        // fill number           : kFillNum\r
 189   //\r
 190   //---------------- Last index gives: 0 - beginning of the records in fData, 1 - number of records\r
 191   //\r
 192   //              infrormation from RunControl\r
 193   Int_t           fRCInjScheme[2];                    // active injection scheme                       : String |kRCInjScheme\r
 194   Int_t           fRCBeta[2];                         // target beta                                   : Float  |kRCBeta\r
 195   Int_t           fRCAngH[2];                         // horisontal angle                              : Float  |kRCCrossAng\r
 196   Int_t           fRCAngV[2];                         // vertical angle                                : Float  |kRCVang\r
 197   Int_t           fBunchConfDecl[2][2];               // declared beam configuration                   : Float  |kBunchConf                \r
 198   //\r
 199   //              measured information\r
 200   Int_t           fBunchConfMeas[2][2];               // measured beam configuration                   : Int    |kBunchLgtFillB\r
 201   Int_t           fBunchLengths[2][2];                // measured beam lenghts                         : Float  |kBunchLgt\r
 202   Int_t           fIntensTotal[2][2];                 // total beam intensities                        : Float  |kIntTot\r
 203   Int_t           fIntensTotalAv[2][2];               // total beam intensities from bunch averages    : Float  |kIntTotAv\r
 204   Int_t           fIntensPerBunch[2][2];              // bunch-by-bunch intensities                    : Float  |kIntBunchAv\r
 205   //\r
 206   Int_t           fCrossAngle[2][2];                  // crossing angle   at IP2 and its error         : Float  |kLimCrossAng, kLumCrossAngErr\r
 207   Int_t           fEmittanceH[2][2];                  // beam H emittances                             : Float  |kBeamSzEmittH\r
 208   Int_t           fEmittanceV[2][2];                  // beam V emittances                             : Float  |kBeamSzEmittV\r
 209   Int_t           fBeamSigmaH[2][2];                  // beam H sigma and error                        : Float  |kBeamSzSigH,kBeamSzSigHErr\r
 210   Int_t           fBeamSigmaV[2][2];                  // beam V sigma and error                        : Float  |kBeamSzSigV,kBeamSzSigVErr\r
 211   //\r
 212   Int_t           fLuminTotal[2][2];                  // total luminosity at IP2 and its error         : Float  |kLumTot, kLumTotErr\r
 213   Int_t           fLuminPerBC[2][2];                  // luminosity at IP2 for each BC and its error   : Float  |kLumBunch,kLumBunchErr\r
 214   Int_t           fLuminAcqMode[2][2];                // luminosity acquisition mode                   : Int    | kLumAcqMode\r
 215   //\r
 216   Int_t           fCollimators[kNCollimators][kNJaws][2];// collimator jaws positions                  : Float  |kCollPos\r
 217   //\r
 218   TObjArray       fData;                              // single storage for various records\r
 219   //\r
 220   static const Char_t *fgkDCSNames[];                 // beam related DCS names to extract\r
 221   static const Char_t *fgkDCSColNames[];              // collimators to extract\r
 222   static const Char_t *fgkDCSColJaws[];               // names of collimator pieces\r
 223   //\r
 224  private:\r
 225   // non-persistent objects used at the filling time\r
 226   const Char_t*   fFile2Process;                      //! name of DCS file\r
 227   const TMap*     fMap2Process;                       //! DCS map to process \r
 228 \r
 229   ClassDef(AliLHCData,1)\r
 230 };\r
 231 \r
 232 \r
 233 //_____________________________________________________________________________\r
 234 inline Int_t AliLHCData::GetNCollimatorJawPos(int coll,int jaw) const {// get n records\r
 235   return (coll>=0&&coll<kNCollimators&&jaw>=0&&jaw<kNJaws)? fCollimators[coll][jaw][kNStor]:0;\r
 236 }\r
 237 \r
 238 inline const Int_t* AliLHCData::GetOffsCollimatorJawPos(int coll,int jaw)  const { // offset array\r
 239   return (coll>=0&&coll<kNCollimators&&jaw>=0&&jaw<kNJaws)? fCollimators[coll][jaw]:0;\r
 240 }\r
 241 \r
 242 inline AliLHCDipValI* AliLHCData::GetBunchConfigMeasured(int bm, int i) const { // get record\r
 243   return (GoodPairID(bm) && i>=0 && i<fBunchConfMeas[bm][kNStor]) ? (AliLHCDipValI*)fData[fBunchConfMeas[bm][kStart]+i]:0;\r
 244 }\r
 245 \r
 246 inline AliLHCDipValF* AliLHCData::GetBunchLengths(int bm, int i) const { // get record\r
 247   return (GoodPairID(bm) && i>=0 && i<fBunchLengths[bm][kNStor]) ? (AliLHCDipValF*)fData[fBunchLengths[bm][kStart]+i]:0;\r
 248 }\r
 249 \r
 250 inline AliLHCDipValI* AliLHCData::GetBunchConfigDeclared(int bm, int i) const { // get record\r
 251   return (GoodPairID(bm) && i>=0 && i<fBunchConfDecl[bm][kNStor]) ? (AliLHCDipValI*)fData[fBunchConfDecl[bm][kStart]+i]:0;\r
 252 }\r
 253 \r
 254 inline AliLHCDipValF* AliLHCData::GetTotalIntensity(int bm, int i) const { // get record\r
 255   return (GoodPairID(bm) && i>=0 && i<fIntensTotal[bm][kNStor]) ? (AliLHCDipValF*)fData[fIntensTotal[bm][kStart]+i]:0;\r
 256 }\r
 257 \r
 258 inline AliLHCDipValF* AliLHCData::GetTotalIntensityAv(int bm, int i) const { // get record\r
 259   return (GoodPairID(bm) && i>=0 && i<fIntensTotalAv[bm][kNStor]) ? (AliLHCDipValF*)fData[fIntensTotalAv[bm][kStart]+i]:0;\r
 260 }\r
 261 \r
 262 inline AliLHCDipValF* AliLHCData::GetIntensityPerBunch(int bm, int i) const { // get record\r
 263   return (GoodPairID(bm) && i>=0 && i<fIntensPerBunch[bm][kNStor]) ? (AliLHCDipValF*)fData[fIntensPerBunch[bm][kStart]+i]:0;\r
 264 }\r
 265 \r
 266 inline AliLHCDipValF* AliLHCData::GetEmittanceH(int bm, int i) const { // get record\r
 267   return (GoodPairID(bm) && i>=0 && i<fEmittanceH[bm][kNStor]) ? (AliLHCDipValF*)fData[fEmittanceH[bm][kStart]+i]:0;\r
 268 }\r
 269 \r
 270 inline AliLHCDipValF* AliLHCData::GetEmittanceV(int bm, int i) const { // get record\r
 271   return (GoodPairID(bm) && i>=0 && i<fEmittanceV[bm][kNStor]) ? (AliLHCDipValF*)fData[fEmittanceV[bm][kStart]+i]:0;\r
 272 }\r
 273 \r
 274 inline AliLHCDipValF* AliLHCData::GetBeamSigmaH(int bm, int i) const { // get record\r
 275   return (GoodPairID(bm) && i>=0 && i<fBeamSigmaH[bm][kNStor]) ? (AliLHCDipValF*)fData[fBeamSigmaH[bm][kStart]+i]:0;\r
 276 }\r
 277 \r
 278 inline AliLHCDipValF* AliLHCData::GetBeamSigmaV(int bm, int i) const { // get record\r
 279   return (GoodPairID(bm) && i>=0 && i<fBeamSigmaV[bm][kNStor]) ? (AliLHCDipValF*)fData[fBeamSigmaV[bm][kStart]+i]:0;\r
 280 }\r
 281 \r
 282 inline AliLHCDipValF* AliLHCData::GetLuminosityTotal(int lr, int i) const { // get record\r
 283   return (GoodPairID(lr) && i>=0 && i<fLuminTotal[lr][kNStor]) ? (AliLHCDipValF*)fData[fLuminTotal[lr][kStart]+i]:0;\r
 284 }\r
 285 \r
 286 inline AliLHCDipValF* AliLHCData::GetLuminosityPerBunch(int lr, int i) const { // get record\r
 287   return (GoodPairID(lr) && i>=0 && i<fLuminPerBC[lr][kNStor]) ? (AliLHCDipValF*)fData[fLuminPerBC[lr][kStart]+i]:0;\r
 288 }\r
 289 \r
 290 inline AliLHCDipValI* AliLHCData::GetLuminosityAcqMode(int lr, int i) const { // get record\r
 291   return (GoodPairID(lr) && i>=0 && i<fLuminAcqMode[lr][kNStor]) ? (AliLHCDipValI*)fData[fLuminAcqMode[lr][kStart]+i]:0;\r
 292 }\r
 293 \r
 294 inline AliLHCDipValF* AliLHCData::GetCrossAngle(int lr, int i) const { // get record\r
 295   return (GoodPairID(lr) && i>=0 && i<fCrossAngle[lr][kNStor]) ? (AliLHCDipValF*)fData[fCrossAngle[lr][kStart]+i]:0;\r
 296 }\r
 297 \r
 298 inline AliLHCDipValC* AliLHCData::GetInjectionScheme(int i) const { // get record\r
 299   return (i>=0 && i<fRCInjScheme[kNStor]) ? (AliLHCDipValC*)fData[fRCInjScheme[kStart]+i]:0;\r
 300 }\r
 301 \r
 302 inline AliLHCDipValF* AliLHCData::GetRCBetaStar(int i) const { // get record\r
 303   return (i>=0 && i<fRCBeta[kNStor]) ? (AliLHCDipValF*)fData[fRCBeta[kStart]+i]:0;\r
 304 }\r
 305 \r
 306 inline AliLHCDipValF* AliLHCData::GetRCAngleH(int i) const { // get record\r
 307   return (i>=0 && i<fRCAngH[kNStor]) ? (AliLHCDipValF*)fData[fRCAngH[kStart]+i]:0;\r
 308 }\r
 309 \r
 310 inline AliLHCDipValF* AliLHCData::GetRCAngleV(int i) const { // get record\r
 311   return (i>=0 && i<fRCAngV[kNStor]) ? (AliLHCDipValF*)fData[fRCAngV[kStart]+i]:0;\r
 312 }\r
 313 \r
 314 inline AliLHCDipValF* AliLHCData::GetCollimJawPos(int coll, int jaw, int i) const { // get record\r
 315   return (coll>=0 && coll<kNCollimators && jaw>=0 && jaw<kNJaws && \r
 316           i>=0 && i<fCollimators[coll][jaw][kNStor]) ? (AliLHCDipValF*)fData[fCollimators[coll][jaw][kStart]+i]:0;\r
 317 }\r
 318 \r
 319 \r
 320 #endif\r