4 /********************************************************************************
\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
9 * The data are (wrapped in the AliLHCDipValT): *
\r
10 * made of TimeStamp (double) and array of values *
\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
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
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
24 * ATTENTION: Bunch RFBucked is NEGATIVE for bunches interacting at IR2 *
\r
28 * Author: ruben.shahoyan@cern.ch *
\r
30 ********************************************************************************/
\r
32 #include "AliLHCDipValT.h"
\r
33 #include "TObject.h"
\r
35 //class AliLHCDipValT;
\r
43 class AliLHCData : public TObject
\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
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
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
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
80 virtual void Print(const Option_t *opt="") const;
\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
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
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
103 Int_t GetNCollimatorJawPos(int coll,int jaw) const;
\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
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
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
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
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
155 const Int_t* GetOffsCollimatorJawPos(int coll,int jaw) const;
\r
157 const TObjArray& GetData() const {return fData;}
\r
161 Bool_t FillData(double tmin=0, double tmax=1.e20);
\r
162 virtual void Clear(const Option_t *opt="");
\r
163 void PrintAux(Bool_t full,const Int_t refs[2],const Option_t *opt="") const;
\r
164 TObjArray* GetDCSEntry(const char* key,int &entry,int &last,double tmin,double tmax) const;
\r
165 Int_t FillScalarRecord( int refs[2], const char* rec, const char* recErr=0);
\r
166 Int_t FillBunchConfig( int refs[2], const char* rec);
\r
167 Int_t FillStringRecord( int refs[2], const char* rec);
\r
168 Int_t FillAcqMode( int refs[2], const char* rec);
\r
169 Int_t FillBunchInfo( int refs[2], const char* rec,int ibm, Bool_t inRealSlots);
\r
170 Int_t FillBCLuminosities(int refs[2], const char* rec, const char* recErr, Int_t useBeam);
\r
172 Int_t ExtractInt(AliDCSArray* dcsArray,Int_t el) const;
\r
173 Double_t ExtractDouble(AliDCSArray* dcsArray,Int_t el) const;
\r
174 TString& ExtractString(AliDCSArray* dcsArray) const;
\r
175 AliLHCData(const AliLHCData& src) : TObject(src),fTMin(0),fTMax(0),fFillNumber(0),fData(0),fFile2Process(0),fMap2Process(0) { /*dummy*/ }
\r
176 AliLHCData& operator=(const AliLHCData& ) { /*dummy*/ return *this;}
\r
177 Int_t TimeDifference(double v1,double v2,double tol=0.9) const;
\r
178 Bool_t IzZero(double val, double tol=1e-16) const {return TMath::Abs(val)<tol;}
\r
179 Bool_t GoodPairID(int beam) const;
\r
183 Double_t fTMin; // selection timeMin
\r
184 Double_t fTMax; // selection timeMax
\r
185 Int_t fFillNumber; // fill number : kFillNum
\r
187 //---------------- Last index gives: 0 - beginning of the records in fData, 1 - number of records
\r
189 // infrormation from RunControl
\r
190 Int_t fRCInjScheme[2]; // active injection scheme : String |kRCInjScheme
\r
191 Int_t fRCBeta[2]; // target beta : Float |kRCBeta
\r
192 Int_t fRCAngH[2]; // horisontal angle : Float |kRCCrossAng
\r
193 Int_t fRCAngV[2]; // vertical angle : Float |kRCVang
\r
194 Int_t fBunchConfDecl[2][2]; // declared beam configuration : Float |kBunchConf
\r
196 // measured information
\r
197 Int_t fBunchConfMeas[2][2]; // measured beam configuration : Int |kBunchLgtFillB
\r
198 Int_t fBunchLengths[2][2]; // measured beam lenghts : Float |kBunchLgt
\r
199 Int_t fIntensTotal[2][2]; // total beam intensities : Float |kIntTot
\r
200 Int_t fIntensTotalAv[2][2]; // total beam intensities from bunch averages : Float |kIntTotAv
\r
201 Int_t fIntensPerBunch[2][2]; // bunch-by-bunch intensities : Float |kIntBunchAv
\r
203 Int_t fCrossAngle[2][2]; // crossing angle at IP2 and its error : Float |kLimCrossAng, kLumCrossAngErr
\r
204 Int_t fEmittanceH[2][2]; // beam H emittances : Float |kBeamSzEmittH
\r
205 Int_t fEmittanceV[2][2]; // beam V emittances : Float |kBeamSzEmittV
\r
206 Int_t fBeamSigmaH[2][2]; // beam H sigma and error : Float |kBeamSzSigH,kBeamSzSigHErr
\r
207 Int_t fBeamSigmaV[2][2]; // beam V sigma and error : Float |kBeamSzSigV,kBeamSzSigVErr
\r
209 Int_t fLuminTotal[2][2]; // total luminosity at IP2 and its error : Float |kLumTot, kLumTotErr
\r
210 Int_t fLuminPerBC[2][2]; // luminosity at IP2 for each BC and its error : Float |kLumBunch,kLumBunchErr
\r
211 Int_t fLuminAcqMode[2][2]; // luminosity acquisition mode : Int | kLumAcqMode
\r
213 Int_t fCollimators[kNCollimators][kNJaws][2];// collimator jaws positions : Float |kCollPos
\r
215 TObjArray fData; // single storage for various records
\r
217 static const Char_t *fgkDCSNames[]; // beam related DCS names to extract
\r
218 static const Char_t *fgkDCSColNames[]; // collimators to extract
\r
219 static const Char_t *fgkDCSColJaws[]; // names of collimator pieces
\r
222 // non-persistent objects used at the filling time
\r
223 const Char_t* fFile2Process; //! name of DCS file
\r
224 const TMap* fMap2Process; //! DCS map to process
\r
226 ClassDef(AliLHCData,1)
\r
230 //_____________________________________________________________________________
\r
231 inline Int_t AliLHCData::GetNCollimatorJawPos(int coll,int jaw) const {// get n records
\r
232 return (coll>=0&&coll<kNCollimators&&jaw>=0&&jaw<kNJaws)? fCollimators[coll][jaw][kNStor]:0;
\r
235 inline const Int_t* AliLHCData::GetOffsCollimatorJawPos(int coll,int jaw) const { // offset array
\r
236 return (coll>=0&&coll<kNCollimators&&jaw>=0&&jaw<kNJaws)? fCollimators[coll][jaw]:0;
\r
239 inline AliLHCDipValI* AliLHCData::GetBunchConfigMeasured(int bm, int i) const { // get record
\r
240 return (GoodPairID(bm) && i>=0 && i<fBunchConfMeas[bm][kNStor]) ? (AliLHCDipValI*)fData[fBunchConfMeas[bm][kStart]+i]:0;
\r
243 inline AliLHCDipValF* AliLHCData::GetBunchLengths(int bm, int i) const { // get record
\r
244 return (GoodPairID(bm) && i>=0 && i<fBunchLengths[bm][kNStor]) ? (AliLHCDipValF*)fData[fBunchLengths[bm][kStart]+i]:0;
\r
247 inline AliLHCDipValI* AliLHCData::GetBunchConfigDeclared(int bm, int i) const { // get record
\r
248 return (GoodPairID(bm) && i>=0 && i<fBunchConfDecl[bm][kNStor]) ? (AliLHCDipValI*)fData[fBunchConfDecl[bm][kStart]+i]:0;
\r
251 inline AliLHCDipValF* AliLHCData::GetTotalIntensity(int bm, int i) const { // get record
\r
252 return (GoodPairID(bm) && i>=0 && i<fIntensTotal[bm][kNStor]) ? (AliLHCDipValF*)fData[fIntensTotal[bm][kStart]+i]:0;
\r
255 inline AliLHCDipValF* AliLHCData::GetTotalIntensityAv(int bm, int i) const { // get record
\r
256 return (GoodPairID(bm) && i>=0 && i<fIntensTotalAv[bm][kNStor]) ? (AliLHCDipValF*)fData[fIntensTotalAv[bm][kStart]+i]:0;
\r
259 inline AliLHCDipValF* AliLHCData::GetIntensityPerBunch(int bm, int i) const { // get record
\r
260 return (GoodPairID(bm) && i>=0 && i<fIntensPerBunch[bm][kNStor]) ? (AliLHCDipValF*)fData[fIntensPerBunch[bm][kStart]+i]:0;
\r
263 inline AliLHCDipValF* AliLHCData::GetEmittanceH(int bm, int i) const { // get record
\r
264 return (GoodPairID(bm) && i>=0 && i<fEmittanceH[bm][kNStor]) ? (AliLHCDipValF*)fData[fEmittanceH[bm][kStart]+i]:0;
\r
267 inline AliLHCDipValF* AliLHCData::GetEmittanceV(int bm, int i) const { // get record
\r
268 return (GoodPairID(bm) && i>=0 && i<fEmittanceV[bm][kNStor]) ? (AliLHCDipValF*)fData[fEmittanceV[bm][kStart]+i]:0;
\r
271 inline AliLHCDipValF* AliLHCData::GetBeamSigmaH(int bm, int i) const { // get record
\r
272 return (GoodPairID(bm) && i>=0 && i<fBeamSigmaH[bm][kNStor]) ? (AliLHCDipValF*)fData[fBeamSigmaH[bm][kStart]+i]:0;
\r
275 inline AliLHCDipValF* AliLHCData::GetBeamSigmaV(int bm, int i) const { // get record
\r
276 return (GoodPairID(bm) && i>=0 && i<fBeamSigmaV[bm][kNStor]) ? (AliLHCDipValF*)fData[fBeamSigmaV[bm][kStart]+i]:0;
\r
279 inline AliLHCDipValF* AliLHCData::GetLuminosityTotal(int lr, int i) const { // get record
\r
280 return (GoodPairID(lr) && i>=0 && i<fLuminTotal[lr][kNStor]) ? (AliLHCDipValF*)fData[fLuminTotal[lr][kStart]+i]:0;
\r
283 inline AliLHCDipValF* AliLHCData::GetLuminosityPerBunch(int lr, int i) const { // get record
\r
284 return (GoodPairID(lr) && i>=0 && i<fLuminPerBC[lr][kNStor]) ? (AliLHCDipValF*)fData[fLuminPerBC[lr][kStart]+i]:0;
\r
287 inline AliLHCDipValI* AliLHCData::GetLuminosityAcqMode(int lr, int i) const { // get record
\r
288 return (GoodPairID(lr) && i>=0 && i<fLuminAcqMode[lr][kNStor]) ? (AliLHCDipValI*)fData[fLuminAcqMode[lr][kStart]+i]:0;
\r
291 inline AliLHCDipValF* AliLHCData::GetCrossAngle(int lr, int i) const { // get record
\r
292 return (GoodPairID(lr) && i>=0 && i<fCrossAngle[lr][kNStor]) ? (AliLHCDipValF*)fData[fCrossAngle[lr][kStart]+i]:0;
\r
295 inline AliLHCDipValC* AliLHCData::GetInjectionScheme(int i) const { // get record
\r
296 return (i>=0 && i<fRCInjScheme[kNStor]) ? (AliLHCDipValC*)fData[fRCInjScheme[kStart]+i]:0;
\r
299 inline AliLHCDipValF* AliLHCData::GetRCBetaStar(int i) const { // get record
\r
300 return (i>=0 && i<fRCBeta[kNStor]) ? (AliLHCDipValF*)fData[fRCBeta[kStart]+i]:0;
\r
303 inline AliLHCDipValF* AliLHCData::GetRCAngleH(int i) const { // get record
\r
304 return (i>=0 && i<fRCAngH[kNStor]) ? (AliLHCDipValF*)fData[fRCAngH[kStart]+i]:0;
\r
307 inline AliLHCDipValF* AliLHCData::GetRCAngleV(int i) const { // get record
\r
308 return (i>=0 && i<fRCAngV[kNStor]) ? (AliLHCDipValF*)fData[fRCAngV[kStart]+i]:0;
\r
311 inline AliLHCDipValF* AliLHCData::GetCollimJawPos(int coll, int jaw, int i) const { // get record
\r
312 return (coll>=0 && coll<kNCollimators && jaw>=0 && jaw<kNJaws &&
\r
313 i>=0 && i<fCollimators[coll][jaw][kNStor]) ? (AliLHCDipValF*)fData[fCollimators[coll][jaw][kStart]+i]:0;
\r