#include "AliLHCData.h"\r
#include "TMap.h"\r
#include "AliDCSArray.h"\r
+#include "AliLHCReader.h"\r
#include <TString.h>\r
#include <TObjArray.h>\r
\r
\r
//___________________________________________________________________\r
AliLHCData::AliLHCData(const TMap* dcsMap, double tmin, double tmax)\r
- : fTMin(tmin),fTMax(tmax),fFillNumber(0),fData(0)\r
+ : fTMin(0),fTMax(0),fFillNumber(0),fData(0),fFile2Process(0),fMap2Process(0)\r
{\r
+ FillData(dcsMap,tmin,tmax);\r
+}\r
+\r
+//___________________________________________________________________\r
+AliLHCData::AliLHCData(const Char_t* dcsFile, double tmin, double tmax)\r
+ : fTMin(0),fTMax(0),fFillNumber(0),fData(0),fFile2Process(dcsFile),fMap2Process(0)\r
+{\r
+ FillData(dcsFile,tmin,tmax);\r
+}\r
+\r
+//___________________________________________________________________\r
+Bool_t AliLHCData::FillData(const TMap* dcsMap,double tmin, double tmax)\r
+{\r
+ // process DCS map and fill all fields. \r
Clear();\r
- SetTMin(tmin);\r
- SetTMin(tmax);\r
- FillData(dcsMap);\r
+ fMap2Process = dcsMap;\r
+ FillData(tmin,tmax);\r
+ return kTRUE;\r
}\r
\r
//___________________________________________________________________\r
-Bool_t AliLHCData::FillData(const TMap* dcsMap, double tmin, double tmax)\r
+Bool_t AliLHCData::FillData(const Char_t* dcsFile,double tmin, double tmax)\r
+{\r
+ // process DCS file and fill all fields. \r
+ Clear();\r
+ fFile2Process = dcsFile;\r
+ FillData(tmin,tmax);\r
+ return kTRUE;\r
+}\r
+\r
+//___________________________________________________________________\r
+Bool_t AliLHCData::FillData(double tmin, double tmax)\r
{\r
// process DCS map and fill all fields. \r
// Accept only entries with timestamp between tmin and tmax\r
SetTMax(tmax);\r
//\r
// -------------------------- extract Fill Number\r
- int iEntry;\r
- TObjArray* arr = GetDCSEntry(dcsMap, fgkDCSNames[kFillNum],iEntry,fTMin,fTMax);\r
- if (arr && iEntry>=0) SetFillNumber( ExtractInt( (AliDCSArray*)arr->At(iEntry), 0) );\r
+ int iFirst=0,iLast=0;\r
+ TObjArray* arr = GetDCSEntry(fgkDCSNames[kFillNum],iFirst,iLast,fTMin,fTMax);\r
+ if (arr) SetFillNumber( ExtractInt( (AliDCSArray*)arr->At(iFirst), 0) );\r
+ if (fFile2Process) delete arr; // array was created on demand\r
//\r
for (int ibm=0;ibm<2;ibm++) {\r
//\r
sprintf(buff,fgkDCSNames[kBunchConf],ibm+1); // ----- declared bunch configuration\r
- FillBunchConfig(dcsMap, fBunchConfDecl[ibm], buff);\r
+ FillBunchConfig(fBunchConfDecl[ibm], buff);\r
//\r
sprintf(buff,fgkDCSNames[kBunchLgtFillB],ibm+1); // ----- measured bunch configuration\r
- FillBunchConfig(dcsMap, fBunchConfMeas[ibm], buff);\r
+ FillBunchConfig(fBunchConfMeas[ibm], buff);\r
//\r
- sprintf(buff,fgkDCSNames[kBunchLgt],ibm+1); // ----- maesured bunch lenghts\r
- FillBunchInfo(dcsMap, fBunchLengths[ibm],buff,ibm,kFALSE); \r
+ sprintf(buff,fgkDCSNames[kBunchLgt],ibm+1); // ----- measured bunch lenghts\r
+ FillBunchInfo(fBunchLengths[ibm],buff,ibm,kFALSE); \r
//\r
sprintf(buff,fgkDCSNames[kIntBunchAv],ibm+1); // ----- B-by-B intensities\r
- FillBunchInfo(dcsMap, fIntensPerBunch[ibm],buff,ibm,kTRUE);\r
+ FillBunchInfo(fIntensPerBunch[ibm],buff,ibm,kTRUE);\r
//\r
//\r
sprintf(buff,fgkDCSNames[kIntTot],ibm+1); // ----- total intensities for beam 1 and 2\r
- FillScalarRecord(dcsMap, fIntensTotal[ibm], buff);\r
+ FillScalarRecord(fIntensTotal[ibm], buff);\r
//\r
sprintf(buff,fgkDCSNames[kIntTotAv],ibm+1); // ----- total intensities for beam 1 and 2 from B-by-B average\r
- FillScalarRecord(dcsMap, fIntensTotalAv[ibm], buff);\r
+ FillScalarRecord(fIntensTotalAv[ibm], buff);\r
//\r
sprintf(buff,fgkDCSNames[kBeamSzEmittH],ibm+1); // ----- H emittance for beam 1 and 2 \r
- FillScalarRecord(dcsMap, fEmittanceH[ibm], buff);\r
+ FillScalarRecord(fEmittanceH[ibm], buff);\r
//\r
sprintf(buff,fgkDCSNames[kBeamSzEmittV],ibm+1); // ----- V emittance for beam 1 and 2 \r
- FillScalarRecord(dcsMap, fEmittanceV[ibm], buff);\r
+ FillScalarRecord(fEmittanceV[ibm], buff);\r
//\r
sprintf(buff ,fgkDCSNames[kBeamSzSigH], ibm+1); // ----- H sigmas and errors for beam 1 and 2 \r
sprintf(buff1,fgkDCSNames[kBeamSzSigHErr],ibm+1);\r
- FillScalarRecord(dcsMap, fBeamSigmaH[ibm], buff, buff1);\r
+ FillScalarRecord(fBeamSigmaH[ibm], buff, buff1);\r
//\r
sprintf(buff ,fgkDCSNames[kBeamSzSigV], ibm+1); // ----- V sigmas and errors for beam 1 and 2 \r
sprintf(buff1,fgkDCSNames[kBeamSzSigVErr],ibm+1);\r
- FillScalarRecord(dcsMap, fBeamSigmaV[ibm], buff, buff1);\r
+ FillScalarRecord(fBeamSigmaV[ibm], buff, buff1);\r
//\r
}\r
//\r
+ FlagInteractingBunches(fBunchConfMeas[0],fBunchConfMeas[1]);\r
+ FlagInteractingBunches(fBunchConfDecl[0],fBunchConfDecl[1]);\r
+ //\r
for (int ilr=0;ilr<2;ilr++) {\r
//\r
sprintf(buff ,fgkDCSNames[kLumBunch], ilr ? 'R':'L'); // ---- BC-by-BC luminosity at IP2 and its error\r
sprintf(buff1,fgkDCSNames[kLumBunchErr], ilr ? 'R':'L');\r
- FillBCLuminosities(dcsMap, fLuminPerBC[ilr], buff, buff1, kTRUE);\r
+ FillBCLuminosities(fLuminPerBC[ilr], buff, buff1, 0); // BRAN L uses beam2 as a reference, BRAN R - beam1\r
//\r
sprintf(buff ,fgkDCSNames[kLumTot] , ilr ? 'R':'L'); // ---- total luminosity at IP2 and its error\r
sprintf(buff1,fgkDCSNames[kLumTotErr], ilr ? 'R':'L');\r
- FillScalarRecord(dcsMap, fLuminTotal[ilr], buff, buff1);\r
+ FillScalarRecord(fLuminTotal[ilr], buff, buff1);\r
//\r
sprintf(buff ,fgkDCSNames[kLumAcqMode], ilr ? 'R':'L'); // ---- luminosity acquisition mode\r
- FillAcqMode(dcsMap, fLuminAcqMode[ilr], buff);\r
+ FillAcqMode(fLuminAcqMode[ilr], buff);\r
//\r
sprintf(buff, fgkDCSNames[kLumCrossAng] , ilr ? 'R':'L'); //----- crossing angle at IP2 and its error\r
sprintf(buff1,fgkDCSNames[kLumCrossAngErr], ilr ? 'R':'L');\r
- FillScalarRecord(dcsMap, fCrossAngle[ilr], buff, buff1);\r
+ FillScalarRecord(fCrossAngle[ilr], buff, buff1);\r
// \r
}\r
//\r
for (int icl=0;icl<kNCollimators;icl++) { // ----- collimators positions\r
for (int jaw=0;jaw<kNJaws;jaw++) {\r
sprintf(buff,fgkDCSNames[kCollPos], fgkDCSColNames[icl],fgkDCSColJaws[jaw]); \r
- FillScalarRecord(dcsMap, fCollimators[icl][jaw], buff);\r
+ FillScalarRecord(fCollimators[icl][jaw], buff);\r
} // jaws\r
} // collimators\r
//\r
//\r
// RunControl info\r
- FillStringRecord(dcsMap, fRCInjScheme, fgkDCSNames[kRCInjSch]); // ---- active injection scheme\r
- FillScalarRecord(dcsMap, fRCBeta, fgkDCSNames[kRCBeta]); // ---- target beta \r
- FillScalarRecord(dcsMap, fRCAngH, fgkDCSNames[kRCCrossAng]); // ---- horisontal angle\r
- FillScalarRecord(dcsMap, fRCAngV,fgkDCSNames[kRCVang] ); // ---- vertical angle\r
+ FillStringRecord(fRCInjScheme, fgkDCSNames[kRCInjSch]); // ---- active injection scheme\r
+ FillScalarRecord(fRCBeta, fgkDCSNames[kRCBeta]); // ---- target beta \r
+ FillScalarRecord(fRCAngH, fgkDCSNames[kRCCrossAng]); // ---- horisontal angle\r
+ FillScalarRecord(fRCAngV,fgkDCSNames[kRCVang] ); // ---- vertical angle\r
//\r
return kTRUE;\r
}\r
\r
//___________________________________________________________________\r
-TObjArray* AliLHCData::GetDCSEntry(const TMap* dcsMap,const char* key,int &entry,double tmin,double tmax) const\r
+TObjArray* AliLHCData::GetDCSEntry(const char* key,int &entry,int &last,double tmin,double tmax) const\r
{\r
- // extract array from the DCS map and find the first entry within the time limits\r
+ // extract array from the DCS map or file and find the first entry within the time limits\r
entry = -1;\r
- TObjArray* arr = (TObjArray*)dcsMap->GetValue(key);\r
+ last = -2;\r
+ TObjArray* arr;\r
+ if (fMap2Process) arr = (TObjArray*)fMap2Process->GetValue(key);\r
+ else if (fFile2Process) {\r
+ AliLHCReader rd;\r
+ arr = rd.ReadSingleLHCDP(fFile2Process,key);\r
+ }\r
+ else {\r
+ AliError("Neither DCS map nor DCS filename are set");\r
+ return 0; \r
+ }\r
+ //\r
if (!arr || !arr->GetEntriesFast()) { \r
AliWarning(Form("No data for %s",key)); \r
+ if (fMap2Process) delete arr; // created on demand\r
return 0;\r
}\r
int ntot = arr->GetEntriesFast();\r
+ //\r
+ // search 1st entry before or at tmin\r
+ AliDCSArray* ent = 0;\r
+ Bool_t found = kFALSE;\r
for (entry=0;entry<ntot;entry++) {\r
- AliDCSArray* ent = (AliDCSArray*)arr->At(entry);\r
- if (ent->GetTimeStamp()>=tmin && ent->GetTimeStamp()<=tmax) break;\r
+ ent = (AliDCSArray*)arr->At(entry);\r
+ if (ent->GetTimeStamp()>=tmin-kMarginSOR && ent->GetTimeStamp()<=tmax+kMarginEOR) {\r
+ found = kTRUE;\r
+ if (ent->GetTimeStamp()>tmin) break;\r
+ }\r
}\r
- if (entry==ntot) {\r
+ if (!found) {\r
entry = -1;\r
TString str;\r
str += AliLHCDipValD::TimeAsString(tmin);\r
str += " : ";\r
str += AliLHCDipValD::TimeAsString(tmax);\r
AliWarning(Form("All entries for %s are outside the requested range:\n%s",key,str.Data()));\r
+ if (fMap2Process) delete arr; // created on demand\r
+ return 0;\r
}\r
+ if (entry>0) entry--;\r
+ //\r
+ // search last entry at or after tmin\r
+ ent = 0;\r
+ for (last=entry;last<ntot;last++) {\r
+ ent = (AliDCSArray*)arr->At(last);\r
+ if (ent->GetTimeStamp()>tmax) break;\r
+ }\r
+ if (last == ntot) last--;\r
+ else if (ent->GetTimeStamp()>tmax+kMarginEOR) last--;\r
+ //\r
return arr;\r
}\r
\r
AliLHCDipValI *prevObj = 0;\r
for (int i=0;i<nrec;i++) {\r
AliLHCDipValI* curObj = (AliLHCDipValI*)fData[start+i];\r
- if (TimeDifference(tstamp,curObj->GetTimeStamp())>0) break;\r
+ if (TimeDifference(tstamp,curObj->GetTimeStamp())<0) break;\r
prevObj = curObj;\r
}\r
if (!prevObj && nrec>0) prevObj = (AliLHCDipValI*)fData[start]; // if no exact match, return the 1st one\r
}\r
\r
//___________________________________________________________________\r
-Int_t AliLHCData::FillScalarRecord(const TMap* dcsMap, int refs[2], const char* rec, const char* recErr)\r
+Int_t AliLHCData::FillScalarRecord(int refs[2], const char* rec, const char* recErr)\r
{\r
// fill record for scalar value, optionally accompanied by measurement error \r
//\r
AliInfo(Form("Acquiring record: %s",rec));\r
//\r
TObjArray *arr=0,*arrE=0;\r
- Int_t nEntries=0,nEntriesE=0,iEntry=0,iEntryE=0;\r
+ Int_t iLast=0,iLastE=0,iFirst=0,iFirstE=0;\r
//\r
refs[kStart] = fData.GetEntriesFast();\r
refs[kNStor] = 0;\r
//\r
- if ( !(arr=GetDCSEntry(dcsMap,rec,iEntry,fTMin,fTMax)) || iEntry<0 ) return -1;\r
- nEntries = arr->GetEntriesFast();\r
+ if ( !(arr=GetDCSEntry(rec,iFirst,iLast,fTMin,fTMax)) ) return -1;\r
//\r
int dim = 1;\r
if (recErr) {\r
- if ( !(arrE=GetDCSEntry(dcsMap,recErr,iEntryE,fTMin,fTMax)) || iEntryE<0 ) nEntriesE = -999;\r
- else nEntriesE = arrE->GetEntriesFast();\r
+ arrE = GetDCSEntry(recErr,iFirstE,iLastE,fTMin,fTMax);\r
dim += 1;\r
}\r
//\r
- while (iEntry<nEntries) {\r
- AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iEntry++);\r
+ Bool_t last = kFALSE;\r
+ while (iFirst<=iLast) {\r
+ AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iFirst++);\r
double tstamp = dcsVal->GetTimeStamp();\r
- if (tstamp>fTMax) break;\r
//\r
AliLHCDipValF* curValF = new AliLHCDipValF(dim,tstamp); // start new period\r
(*curValF)[0] = ExtractDouble(dcsVal,0); // value\r
//\r
if (recErr) {\r
double errVal = -1;\r
- while (iEntryE<nEntriesE) { // try to find corresponding error\r
- AliDCSArray *dcsValE = (AliDCSArray*) arrE->At(iEntryE);\r
+ while (iFirstE<=iLastE) { // try to find corresponding error\r
+ AliDCSArray *dcsValE = (AliDCSArray*) arrE->At(iFirstE);\r
double tstampE = dcsValE->GetTimeStamp();\r
- if (tstampE>fTMax) break;\r
int tdif = TimeDifference(tstamp,tstampE);\r
if (!tdif) { // error matches to value\r
errVal = ExtractDouble(dcsValE,0);\r
- iEntryE++; \r
+ iFirstE++; \r
break;\r
}\r
- else if (tdif>0) iEntryE++; // error time lags behind, read the next one\r
+ else if (tdif>0) iFirstE++; // error time lags behind, read the next one\r
else break; // error time is ahead of value, no error associated\r
}\r
(*curValF)[dim-1] = errVal; // error\r
//\r
fData.Add(curValF);\r
refs[kNStor]++;\r
+ if (last) break;\r
}\r
//\r
+ if (fFile2Process) {\r
+ delete arr;\r
+ delete arrE;\r
+ }\r
return refs[kNStor];\r
}\r
\r
//___________________________________________________________________\r
-Int_t AliLHCData::FillBunchConfig(const TMap* dcsMap, int refs[2],const char* rec)\r
+Int_t AliLHCData::FillBunchConfig(int refs[2],const char* rec)\r
{\r
// fill record for bunch configuration\r
//\r
AliInfo(Form("Acquiring record: %s",rec));\r
TObjArray *arr;\r
- Int_t nEntries,iEntry;\r
+ Int_t iLast,iFirst;\r
//\r
refs[kStart] = fData.GetEntriesFast();\r
refs[kNStor] = 0;\r
//\r
- if ( !(arr=GetDCSEntry(dcsMap,rec,iEntry,fTMin,fTMax)) || iEntry<0 ) return -1;\r
- nEntries = arr->GetEntriesFast();\r
+ if ( !(arr=GetDCSEntry(rec,iFirst,iLast,fTMin,fTMax)) ) return -1;\r
//\r
AliLHCDipValI* prevRecI=0;\r
- while (iEntry<nEntries) {\r
- AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iEntry++);\r
+ // \r
+ while (iFirst<=iLast) {\r
+ AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iFirst++);\r
double tstamp = dcsVal->GetTimeStamp();\r
- if (tstamp>fTMax) break;\r
//\r
int bucket=0, nbunch=0, ndiff=0;\r
int nSlots = dcsVal->GetNEntries(); // count number of actual bunches (non-zeros)\r
prevRecI = curValI;\r
}\r
//\r
+ if (fFile2Process) delete arr;\r
return refs[kNStor];\r
}\r
\r
//___________________________________________________________________\r
-Int_t AliLHCData::FillAcqMode(const TMap* dcsMap, int refs[2],const char* rec)\r
+Int_t AliLHCData::FillAcqMode(int refs[2],const char* rec)\r
{\r
// fill acquisition mode\r
//\r
AliInfo(Form("Acquiring record: %s",rec));\r
TObjArray *arr;\r
- Int_t nEntries,iEntry;\r
+ Int_t iLast,iFirst;\r
//\r
refs[kStart] = fData.GetEntriesFast();\r
refs[kNStor] = 0;\r
//\r
- if ( !(arr=GetDCSEntry(dcsMap,rec,iEntry,fTMin,fTMax)) || iEntry<0 ) return -1;\r
- nEntries = arr->GetEntriesFast();\r
+ if ( !(arr=GetDCSEntry(rec,iFirst,iLast,fTMin,fTMax)) ) return -1;\r
//\r
AliLHCDipValI* prevRecI=0;\r
- while (iEntry<nEntries) {\r
- AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iEntry++);\r
+ while (iFirst<=iLast) {\r
+ AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iFirst++);\r
double tstamp = dcsVal->GetTimeStamp();\r
- if (tstamp>fTMax) break;\r
//\r
int nSlots = dcsVal->GetNEntries();\r
if (nSlots<1) continue;\r
prevRecI = curValI;\r
}\r
//\r
+ if (fFile2Process) delete arr;\r
return refs[kNStor];\r
}\r
\r
//___________________________________________________________________\r
-Int_t AliLHCData::FillStringRecord(const TMap* dcsMap, int refs[2],const char* rec)\r
+Int_t AliLHCData::FillStringRecord(int refs[2],const char* rec)\r
{\r
// fill record with string value\r
//\r
AliInfo(Form("Acquiring record: %s",rec));\r
TString prevRec;\r
TObjArray *arr;\r
- Int_t nEntries,iEntry;\r
+ Int_t iLast,iFirst;\r
//\r
refs[kStart] = fData.GetEntriesFast();\r
refs[kNStor] = 0;\r
//\r
- if ( !(arr=GetDCSEntry(dcsMap,rec,iEntry,fTMin,fTMax)) || iEntry<0 ) return -1;\r
- nEntries = arr->GetEntriesFast();\r
+ if ( !(arr=GetDCSEntry(rec,iFirst,iLast,fTMin,fTMax)) ) return -1;\r
//\r
- while (iEntry<nEntries) {\r
- AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iEntry++);\r
+ while (iFirst<=iLast) {\r
+ AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iFirst++);\r
double tstamp = dcsVal->GetTimeStamp();\r
- if (tstamp>fTMax) break;\r
//\r
TString &str = ExtractString(dcsVal);\r
if (!prevRec.IsNull()) {if (str == prevRec) continue;} // skip similar record\r
fData.Add(curValS);\r
refs[kNStor]++;\r
}\r
+ if (fFile2Process) delete arr;\r
return refs[kNStor];\r
}\r
\r
//___________________________________________________________________\r
-Int_t AliLHCData::FillBunchInfo(const TMap* dcsMap, int refs[2],const char* rec, int ibm, Bool_t inRealSlots)\r
+Int_t AliLHCData::FillBunchInfo(int refs[2],const char* rec, int ibm, Bool_t inRealSlots)\r
{\r
// fill bunch properties for beam ibm\r
// if inRealSlots = true, then the value is taken from bunchRFbucket/10, otherwise, the value \r
//\r
AliInfo(Form("Acquiring record: %s",rec));\r
TObjArray *arr;\r
- Int_t nEntries,iEntry;\r
+ Int_t iLast,iFirst;\r
//\r
refs[kStart] = fData.GetEntriesFast();\r
refs[kNStor] = 0;\r
//\r
- if ( !(arr=GetDCSEntry(dcsMap,rec,iEntry,fTMin,fTMax)) || iEntry<0 ) return -1;\r
- nEntries = arr->GetEntriesFast();\r
+ if ( !(arr=GetDCSEntry(rec,iFirst,iLast,fTMin,fTMax)) ) return -1;\r
//\r
- while (iEntry<nEntries) {\r
- AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iEntry++);\r
+ while (iFirst<=iLast) {\r
+ AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iFirst++);\r
double tstamp = dcsVal->GetTimeStamp();\r
- if (tstamp>fTMax) break;\r
//\r
AliLHCDipValI *bconf = GetBunchConfigMeasured(ibm,tstamp);\r
if (!bconf) {\r
fData.Add(curValF);\r
refs[kNStor]++;\r
}\r
+ if (fFile2Process) delete arr;\r
return refs[kNStor];\r
//\r
}\r
\r
//___________________________________________________________________\r
-Int_t AliLHCData::FillBCLuminosities(const TMap* dcsMap, int refs[2],const char* rec, const char* recErr, Bool_t opt)\r
+Int_t AliLHCData::FillBCLuminosities(int refs[2],const char* rec, const char* recErr, int useBeam)\r
{\r
// fill luminosities per bunch crossing\r
//\r
AliInfo(Form("Acquiring record: %s",rec));\r
TObjArray *arr,*arrE=0;\r
- Int_t nEntries=0,nEntriesE=0,iEntry=0,iEntryE=0;\r
+ Int_t iLast=0,iLastE=0,iFirst=0,iFirstE=0;\r
//\r
refs[kStart] = fData.GetEntriesFast();\r
refs[kNStor] = 0;\r
//\r
- if ( !(arr=GetDCSEntry(dcsMap,rec,iEntry,fTMin,fTMax)) || iEntry<0 ) return -1;\r
- nEntries = arr->GetEntriesFast();\r
+ if ( !(arr=GetDCSEntry(rec,iFirst,iLast,fTMin,fTMax)) ) return -1;\r
//\r
- while (iEntry<nEntries) {\r
- AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iEntry++);\r
+ while (iFirst<=iLast) {\r
+ AliDCSArray *dcsVal = (AliDCSArray*) arr->At(iFirst++);\r
double tstamp = dcsVal->GetTimeStamp();\r
- if (tstamp>fTMax) break;\r
//\r
- AliLHCDipValI *bconf = GetBunchConfigMeasured(0,tstamp); // luminosities are stored according to 1st beam bunches\r
+ AliLHCDipValI *bconf;\r
+ bconf = GetBunchConfigMeasured(useBeam,tstamp); // luminosities are stored according to beam bunches\r
if (!bconf) {\r
- AliWarning(Form("Mearured bunch configuration for beam 1 at t=%.1f is not available, trying declared one",tstamp));\r
- bconf = GetBunchConfigDeclared(0,tstamp);\r
+ AliWarning(Form("Mearured bunch configuration for beam%d at t=%.1f is not available, trying declared one",useBeam,tstamp));\r
+ bconf = GetBunchConfigDeclared(useBeam,tstamp);\r
}\r
if (!bconf) {\r
- AliWarning(Form("Declared bunch configuration for beam 1 at t=%.1f is not available, skip this record",tstamp));\r
+ AliWarning(Form("Declared bunch configuration for beam%i at t=%.1f is not available, skip this record",useBeam,tstamp));\r
return -1;\r
}\r
int nSlots = dcsVal->GetNEntries(); // count number of actual bunches (non-zeros)\r
int nbunch = bconf->GetSize();\r
double* dcsArr = dcsVal->GetDouble();\r
//\r
- // ATTENTION: FOR THE MOMENT STORE ALL SLOTS CORRESPONDING TO FILLED BUNCHES (until the scheme is clarified)\r
if (nbunch>nSlots) {\r
AliWarning(Form("More N bunches than slots in %s at time %.1f",rec,tstamp));\r
continue;\r
}\r
- int dim = nbunch;\r
+ int dim = 0;\r
+ if (!bconf->IsProcessed1()) {\r
+ AliWarning(Form("Bunch conf. for beam%d has no marked interacting bunches, store all luminosity for all filled bunches",useBeam));\r
+ dim = nbunch;\r
+ }\r
+ else { // count number of interacting bunches\r
+ for (int i=nbunch;i--;) if ((*bconf)[i]<0) dim++;\r
+ }\r
+ //\r
if (recErr) {\r
- if ( !(arrE=GetDCSEntry(dcsMap,recErr,iEntryE,fTMin,fTMax)) || iEntryE<0 ) nEntriesE = -999;\r
- else nEntriesE = arrE->GetEntriesFast();\r
+ arrE=GetDCSEntry(recErr,iFirstE,iLastE,fTMin,fTMax);\r
dim += 1;\r
}\r
AliLHCDipValF* curValF = new AliLHCDipValF(dim,tstamp);\r
- for (int i=nbunch;i--;) {\r
- int ind = opt ? (*bconf)[i]/10 : i;\r
+ int cnt = 0;\r
+ for (int i=0;i<nbunch;i++) {\r
+ int slot = (*bconf)[i];\r
+ if (bconf->IsProcessed1() && slot>0) continue;\r
+ //\r
+ int ind = TMath::Abs(slot)/10;\r
if (ind>nSlots) {\r
- AliError(Form("Bunch %d refers to wrong slot %d, set to -1",i,(*bconf)[i]));\r
- (*curValF)[i] = -1;\r
+ AliError(Form("Bunch %d refers to wrong slot %d, set to -1",cnt,slot));\r
+ (*curValF)[cnt] = -1;\r
}\r
- else (*curValF)[i] = dcsArr[ind];\r
+ else (*curValF)[cnt] = dcsArr[ind];\r
+ cnt++;\r
}\r
//\r
if (recErr) {\r
double errVal = -1;\r
- while (iEntryE<nEntriesE) { // try to find corresponding error\r
- AliDCSArray *dcsValE = (AliDCSArray*) arrE->At(iEntryE);\r
+ while (iFirstE<=iLastE) { // try to find corresponding error\r
+ AliDCSArray *dcsValE = (AliDCSArray*) arrE->At(iFirstE);\r
double tstamp1 = dcsValE->GetTimeStamp();\r
- if (tstamp1>fTMax) break;\r
int tdif = TimeDifference(tstamp,tstamp1);\r
if (!tdif) { // error matches to value\r
errVal = dcsValE->GetDouble()[0];\r
- iEntryE++; \r
+ iFirstE++; \r
break;\r
}\r
- else if (tdif>0) iEntryE++; // error time lags behind, read the next one\r
+ else if (tdif>0) iFirstE++; // error time lags behind, read the next one\r
else break; // error time is ahead of value, no error associated\r
}\r
(*curValF)[dim-1] = errVal; // error\r
fData.Add(curValF);\r
refs[kNStor]++;\r
}\r
+ if (fFile2Process) {\r
+ delete arr;\r
+ delete arrE;\r
+ }\r
return refs[kNStor];\r
//\r
}\r
// print full info\r
TString opts = opt;\r
opts.ToLower();\r
+ Bool_t utcTime = opts.Contains("loc") ? kFALSE:kTRUE;\r
Bool_t full = kTRUE;\r
if (!opts.Contains("f")) {\r
printf("Use Print(\"f\") to print full info\n");\r
printf("Printing short info:\n<RecordType>(number of records): <TimeStamp, value> for 1st record only\n");\r
full = kFALSE;\r
}\r
- printf("Fill#%6d Validity: %s - %s\n",fFillNumber,\r
- AliLHCDipValI::TimeAsString(fTMin),AliLHCDipValI::TimeAsString(fTMax));\r
+ TString sdtmn = AliLHCDipValI::TimeAsString(fTMin,utcTime);\r
+ TString sdtmx = AliLHCDipValI::TimeAsString(fTMax,utcTime);\r
+ printf("Fill#%6d Validity: %s - %s (%s)\n",fFillNumber,sdtmn.Data(),sdtmx.Data(),utcTime ? "UTC":"LOC");\r
//\r
printf("********** SETTINGS FROM RUN CONTROL **********\n");\r
//\r
- printf("** Injection Scheme");\r
- PrintAux(full,fRCInjScheme);\r
+ printf("* %-38s","Injection Scheme");\r
+ PrintAux(full,fRCInjScheme,opts);\r
//\r
- printf("** Beta Star");\r
- PrintAux(full,fRCBeta);\r
+ printf("* %-38s","Beta Star");\r
+ PrintAux(full,fRCBeta,opts);\r
//\r
- printf("** Horisontal Crossing Angle");\r
- PrintAux(full,fRCAngH);\r
+ printf("* %-38s","Horisontal Crossing Angle");\r
+ PrintAux(full,fRCAngH,opts);\r
//\r
- printf("** Vertical Crossing Angle");\r
- PrintAux(full,fRCAngV);\r
+ printf("* %-38s","Vertical Crossing Angle");\r
+ PrintAux(full,fRCAngV,opts);\r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d bunch filling scheme [negative: bunch interacting at IR2!]",ib+1);\r
- PrintAux(full,fBunchConfDecl[ib]);\r
+ printf("* Beam%d filling [- interacts at IR2!] ",ib+1);\r
+ PrintAux(full,fBunchConfDecl[ib],opts);\r
}\r
//\r
printf("\n********** MEASURED DATA **********\n");\r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d bunch filling scheme [negative: bunch interacts at IR2!]",ib+1);\r
- PrintAux(full,fBunchConfMeas[ib]);\r
+ printf("* Beam%d filling [- interacts at IR2!] ",ib+1);\r
+ PrintAux(full,fBunchConfMeas[ib],opts);\r
} \r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d total intensity",ib+1);\r
- PrintAux(full,fIntensTotal[ib]);\r
+ printf("* Beam%d total intensity ",ib+1);\r
+ PrintAux(full,fIntensTotal[ib],opts);\r
} \r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d total intensity from bunch average",ib+1);\r
- PrintAux(full,fIntensTotalAv[ib]);\r
+ printf("* Beam%d total intensity (bunch average) ",ib+1);\r
+ PrintAux(full,fIntensTotalAv[ib],opts);\r
} \r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d intensity per bunch",ib+1);\r
- PrintAux(full,fIntensPerBunch[ib]);\r
+ printf("* Beam%d intensity per bunch ",ib+1);\r
+ PrintAux(full,fIntensPerBunch[ib],opts);\r
}\r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d bunch lengths",ib+1);\r
- PrintAux(full,fBunchLengths[ib]);\r
+ printf("* Beam%d bunch lengths ",ib+1);\r
+ PrintAux(full,fBunchLengths[ib],opts);\r
} \r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d H. emittance",ib+1);\r
- PrintAux(full,fEmittanceH[ib]);\r
+ printf("* Beam%d Horisontal emittance ",ib+1);\r
+ PrintAux(full,fEmittanceH[ib],opts);\r
}\r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d V. emittance",ib+1);\r
- PrintAux(full,fEmittanceV[ib]);\r
+ printf("* Beam%d Vertical emittance ",ib+1);\r
+ PrintAux(full,fEmittanceV[ib],opts);\r
}\r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d H. sigma",ib+1);\r
- PrintAux(full,fBeamSigmaH[ib]);\r
+ printf("* Beam%d Horisontal sigma ",ib+1);\r
+ PrintAux(full,fBeamSigmaH[ib],opts);\r
}\r
//\r
for (int ib=0;ib<2;ib++) {\r
- printf("** Beam%d V. sigma",ib+1);\r
- PrintAux(full,fBeamSigmaV[ib]);\r
+ printf("* Beam%d Vertical sigma ",ib+1);\r
+ PrintAux(full,fBeamSigmaV[ib],opts);\r
}\r
//\r
for (int lr=0;lr<2;lr++) {\r
- printf("** Total luminosity from BRANB_4%c2",lr ? 'R':'L');\r
- PrintAux(full,fLuminTotal[lr]);\r
+ printf("* Total luminosity from BRANB_4%c2 ",lr ? 'R':'L');\r
+ PrintAux(full,fLuminTotal[lr],opts);\r
} \r
//\r
for (int lr=0;lr<2;lr++) {\r
- printf("** Luminosity acquisition mode, BRANB_4%c2",lr ? 'R':'L');\r
- PrintAux(full,fLuminPerBC[lr]);\r
+ printf("* Luminosity acq.mode, BRANB_4%c2 ",lr ? 'R':'L');\r
+ PrintAux(full,fLuminAcqMode[lr],opts+"bit");\r
} \r
//\r
for (int lr=0;lr<2;lr++) {\r
- printf("** Luminosity per Bunch Crossing from BRANB_4%c2",lr ? 'R':'L');\r
- PrintAux(full,fLuminPerBC[lr]);\r
+ printf("* Luminosity per BC from BRANB_4%c2 ",lr ? 'R':'L');\r
+ PrintAux(full,fLuminPerBC[lr],opts);\r
}\r
//\r
for (int lr=0;lr<2;lr++) {\r
- printf("** Crossing angle, side %c",lr ? 'R':'L');\r
- PrintAux(full,fCrossAngle[lr]);\r
+ printf("* Crossing angle, side %c ",lr ? 'R':'L');\r
+ PrintAux(full,fCrossAngle[lr],opts);\r
}\r
//\r
for (int coll=0;coll<kNCollimators;coll++)\r
for (int jaw=0;jaw<kNJaws;jaw++) {\r
- printf("** Collimator %s:%s",fgkDCSColNames[coll],fgkDCSColJaws[jaw]);\r
- PrintAux(full,fCollimators[coll][jaw]);\r
+ printf("* Collimator %10s:%16s",fgkDCSColNames[coll],fgkDCSColJaws[jaw]);\r
+ PrintAux(full,fCollimators[coll][jaw],opts);\r
}\r
//\r
}\r
\r
//___________________________________________________________________\r
-void AliLHCData::PrintAux(Bool_t full, const Int_t refs[2]) const\r
+void AliLHCData::PrintAux(Bool_t full, const Int_t refs[2], const Option_t *opt) const\r
{\r
// aux method to print the reocrds of the same type\r
int nrec = refs[kNStor];\r
printf(": N/A\n"); \r
return;\r
}\r
- printf(": (%d):\t",nrec); // number of records\r
+ printf(": (%3d):\t",nrec); // number of records\r
if (!full) nrec = 1;\r
int sz = ((AliLHCDipValI*)fData[refs[kStart]])->GetSizeTotal(); // dimension of the record\r
Bool_t isStr = ((AliLHCDipValI*)fData[refs[kStart]])->IsTypeC();\r
if ((!isStr && sz>2) || nrec>1) printf("\n"); // long record, open new line\r
- for (int i=0;i<nrec;i++) fData[refs[kStart]+i]->Print();\r
+ for (int i=0;i<nrec;i++) fData[refs[kStart]+i]->Print(opt);\r
//\r
}\r
\r
fFillNumber = 0;\r
fTMin = 0;\r
fTMax = 1e10;\r
+ fFile2Process = 0;\r
+ fMap2Process = 0;\r
+ //\r
for (int i=2;i--;) {\r
fRCInjScheme[i] = 0;\r
fRCBeta[i] = 0;\r
TString scheme = rec->GetValues();\r
return scheme.Contains("wp",TString::kIgnoreCase);\r
}\r
+\r
+//___________________________________________________________________\r
+void AliLHCData::FlagInteractingBunches(const Int_t beam1[2],const Int_t beam2[2])\r
+{\r
+ // assign - sign to interacting bunches\r
+ const int kMaxSlots = 3564;\r
+ const int kOffsBeam1 = 346;\r
+ const int kOffsBeam2 = 3019;\r
+ //\r
+ for (int ib1=0;ib1<beam1[kNStor];ib1++) {\r
+ AliLHCDipValI *bm1 = (AliLHCDipValI*)fData[ beam1[kStart] + ib1];\r
+ if (!bm1) continue;\r
+ AliLHCDipValI *bm2 = (AliLHCDipValI*)FindRecValidFor(beam2[kStart],beam2[kNStor], bm1->GetTimeStamp());\r
+ if (!bm2) continue;\r
+ //\r
+ int nb1 = bm1->GetSize();\r
+ int nb2 = bm2->GetSize();\r
+ int i1,i2;\r
+ for (i1=0;i1<nb1;i1++) {\r
+ int bunch2=-1, bunch1 = TMath::Abs((*bm1)[i1]);\r
+ int slot2 =-1, slot1 = (bunch1/10 + kOffsBeam1)%kMaxSlots;\r
+ for (i2=0;i2<nb2;i2++) {\r
+ bunch2 = TMath::Abs((*bm2)[i2]);\r
+ slot2 = (bunch2/10 + kOffsBeam2)%kMaxSlots;\r
+ if (slot1==slot2) break;\r
+ }\r
+ if (slot1!=slot2) continue;\r
+ (*bm1)[i1] = -bunch1;\r
+ (*bm2)[i2] = -bunch2;\r
+ bm1->SetProcessed1();\r
+ bm2->SetProcessed1();\r
+ }\r
+ }\r
+}\r
+\r
+//___________________________________________________________________\r
+Int_t AliLHCData::GetMeanIntensity(int beamID, Double_t &colliding, Double_t &noncolliding) const\r
+{\r
+ // get average intensity for all, colliding and non-colliding bunches\r
+ // on success returns number of intensity records used (1 per ~10 min)\r
+ colliding = noncolliding = -1.;\r
+ if (beamID<0||beamID>1) {\r
+ AliError(Form("BeamID must be either 0 or 1, %d requested",beamID));\r
+ return -10;\r
+ }\r
+ //\r
+ int nrec = GetNIntensityPerBunch(beamID);\r
+ if (nrec<1) return -1;\r
+ AliLHCDipValI *conf = GetBunchConfigMeasured(beamID);\r
+ if (!conf) conf = GetBunchConfigDeclared(beamID);\r
+ if (!conf) return -2;\r
+ int nb = conf->GetSize();\r
+ //\r
+ for (int irec=0;irec<nrec;irec++) {\r
+ AliLHCDipValF* rInt = GetIntensityPerBunch(beamID,irec);\r
+ for (int ib=0;ib<nb;ib++) {\r
+ double val = rInt->GetValue(ib);\r
+ if (val<0) continue;\r
+ int bID = conf->GetValue(ib);\r
+ if (bID<0) colliding += val;\r
+ else noncolliding += val;\r
+ }\r
+ }\r
+ colliding /= nrec;\r
+ noncolliding /= nrec;\r
+ return nrec;\r
+}\r
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff