void
Digits2Raw()
{
// AliLog::SetModuleDebugLevel("FMD", 10);
AliLog::SetModuleDebugLevel("RAW", 1);
AliRunLoader* runLoader = AliRunLoader::Open("galice.root", "Alice", "read");
if (!runLoader) {
AliError("Coulnd't read the file galice.root");
return;
}
if (runLoader->LoadgAlice()) return;
AliRun* run = runLoader->GetAliRun();
// Get the FMD
AliFMD* fmd = static_cast<AliFMD*>(run->GetDetector("FMD"));
if (!fmd) {
AliError("Failed to get detector FMD from loader");
return;
}
// Get the FMD loader
AliLoader* loader = runLoader->GetLoader("FMDLoader");
if (!loader) {
AliError("Failed to get detector FMD loader from loader");
return;
}
if (runLoader->LoadHeader()) {
AliError("Failed to get event header information from loader");
return;
}
TTree* treeE = runLoader->TreeE();
AliCDBManager::Instance()->SetRun(0);
AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
AliFMDParameters::Instance()->Init(kFALSE,
(AliFMDParameters::kPulseGain|
(AliFMDParameters::kPedestal|
AliFMDParameters::kDeadMap|
AliFMDParameters::kSampleRate|
AliFMDParameters::kAltroMap|
AliFMDParameters::kStripRange)));
AliFMDParameters::Instance()->SetZeroSuppression(1);
// AliFMDParameters::Instance()->SetPedestal(100);
// AliFMDParameters::Instance()->SetPedestalWidth(0);
// AliFMDParameters::Instance()->SetZSPreSamples(0);
// AliFMDParameters::Instance()->SetZSPostSamples(0);
fmd->Digits2Raw();
}
/**
* End of job processing
*/
void Terminate(Option_t*)
{
fList = dynamic_cast<TList*>(GetOutputData(1));
if (!fList) {
AliError(Form("No output list defined (%p)", GetOutputData(1)));
if (GetOutputData(1)) GetOutputData(1)->Print();
return;
}
TList* output = new TList;
output->SetName("triggerResults");
output->SetOwner();
fVertexMC = static_cast<TH1D*>(fList->FindObject("vertexMC"));
fVertexESD = static_cast<TH1D*>(fList->FindObject("vertexESD"));
fM = static_cast<TH1D*>(fList->FindObject("m"));
if (fVertexMC) {
TH1D* vtxMC = static_cast<TH1D*>(fVertexMC->Clone("vertexMC"));
vtxMC->SetDirectory(0);
if (vtxMC->GetEntries() > 0)
vtxMC->Scale(1. / vtxMC->GetEntries());
else
vtxMC->Scale(0);
output->Add(vtxMC);
}
if (fVertexESD) {
TH1D* vtxESD = static_cast<TH1D*>(fVertexESD->Clone("vertexESD"));
vtxESD->SetDirectory(0);
if (vtxESD->GetEntries() > 0)
vtxESD->Scale(1. / vtxESD->GetEntries());
else
vtxESD->Scale(0);
output->Add(vtxESD);
}
if (fM) {
TH1D* m = static_cast<TH1D*>(fM->Clone("m"));
m->SetDirectory(0);
m->SetYTitle("P(N_{ch}|_{|#eta|<1} < X)");
if (m->GetBinContent(1) > 0)
m->Scale(1. / m->GetBinContent(1));
else
m->Scale(0);
output->Add(m);
}
TString vtxReq;
if (fVertexRequirement & kMC) vtxReq.Append("MC ");
if (fVertexRequirement & kESD) vtxReq.Append("ESD ");
output->Add(new TNamed("vtxReq", vtxReq.Data()));
output->Add(new TNamed("trkReq",
fTrackletRequirement == kMC ? "MC" : "ESD"));
fInel.Finish(fList, output);
fInelGt0.Finish(fList, output);
fNSD.Finish(fList, output);
fNClusterGt0.Finish(fList, output);
PostData(2, output);
}
/// Add a AliAnalysisTaskEmcalJetCDFUE task - info from AliEmcalJetTask*
/// \param AliEmcalJetTask *jetFinderTask
/// \param Double_t jetptcut
/// \param Double_t jetareacut
/// \param const char *type ; either TPC, EMCAL or USER
/// \param Int_t leadhadtype ; 0 = charged, 1 = neutral, 2 = both
/// \param const char *nrho
/// \param const char *taskname
/// \return AliAnalysisTaskEmcalJetCDFUE* task
AliAnalysisTaskEmcalJetCDFUE *AddTaskEmcalJetCDFUE ( AliEmcalJetTask *jetFinderTask,
Double_t jetptcut = 1.,
Double_t jetptcutmax = 250.,
Double_t jetareacut = 0.001,
const char *type = "TPC", // EMCAL, TPC
Int_t leadhadtype = 0, // AliJetContainer :: Int_t fLeadingHadronType; 0 = charged, 1 = neutral, 2 = both
const char *nrho = "",
const char *taskname = "JetCDF" )
{
if ( !jetFinderTask->InheritsFrom ( AliEmcalJetTask::Class() ) )
{ AliError("AddTaskEmcalJetSample :: task is not/ does not inherits from AliEmcalJetTask"); }
const char *ntracks = jetFinderTask->GetTracksName();
const char *nclusters = jetFinderTask->GetClusName();
const char *njets = jetFinderTask->GetJetsName();
Double_t jetradius = jetFinderTask->GetRadius();
return AddTaskEmcalJetCDFUE ( ntracks , nclusters, njets, nrho, jetradius, jetptcut, jetptcutmax, jetareacut, type, leadhadtype, taskname );
}
/// Add a AliAnalysisTaskEmcalJetCDFUE task - info from char* taskname
/// \param const char* taskname ; to be retrieved from list of tasks
/// \param Double_t jetptcut
/// \param Double_t jetareacut
/// \param const char *type ; either TPC, EMCAL or USER
/// \param Int_t leadhadtype ; 0 = charged, 1 = neutral, 2 = both
/// \param const char *nrho
/// \param const char *taskname
/// \return AliAnalysisTaskEmcalJetCDFUE* task
AliAnalysisTaskEmcalJetCDFUE *AddTaskEmcalJetCDFUE ( const char* taskname,
Double_t jetptcut = 1.,
Double_t jetptcutmax = 250.,
Double_t jetareacut = 0.001,
const char *type = "TPC", // EMCAL, TPC
Int_t leadhadtype = 0, // AliJetContainer :: Int_t fLeadingHadronType; 0 = charged, 1 = neutral, 2 = both
const char *nrho = "",
const char *taskname = "JetCDF" )
{
AliAnalysisManager* mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) { ::Error("AddTaskEmcalJetCDF", "No analysis manager to connect to."); }
AliEmcalJetTask* jf = dynamic_cast<AliEmcalJetTask*>(mgr->GetTask(taskname));
if (!jf) { AliError("AddTaskEmcalJetCDF :: task is not EmcalJetTask");}
const char *ntracks = jf->GetTracksName();
const char *nclusters = jf->GetClusName();
const char *njets = jf->GetJetsName();
Double_t jetradius = jf->GetRadius();
return AddTaskEmcalJetCDFUE ( ntracks , nclusters, njets, nrho, jetradius, jetptcut, jetptcutmax, jetareacut, type, leadhadtype, taskname );
}
AliCFTaskVertexingHF *AddTaskCFVertexingHF3Prong(TString suffixName="", const char* cutFile = "./DplustoKpipiCuts.root", Int_t configuration = AliCFTaskVertexingHF::kCheetah, Bool_t isKeepDfromB=kFALSE, Bool_t isKeepDfromBOnly=kFALSE, Int_t pdgCode = 411, Char_t isSign = 2, Bool_t useWeight=kFALSE, TString multFile="", Bool_t useNchWeight=kFALSE, Bool_t useNtrkWeight=kFALSE, TString estimatorFilename="", Int_t multiplicityEstimator = AliCFTaskVertexingHF::kNtrk10, Bool_t isPPbData = kFALSE, Double_t refMult=9.26, Bool_t isFineNtrkBin=kFALSE, TString multweighthistoname = "hNtrUnCorrEvWithCandWeight")
//AliCFContainer *AddTaskCFVertexingHF3Prong(const char* cutFile = "./DplustoKpipiCuts.root", Int_t configuration = AliCFTaskVertexingHF::kSnail, Bool_t isKeepDfromB=kFALSE, Bool_t isKeepDfromBOnly=kFALSE, Int_t pdgCode = 411, Char_t isSign = 2)
{
printf("Addig CF task using cuts from file %s\n",cutFile);
if (configuration == AliCFTaskVertexingHF::kSnail){
printf("The configuration is set to be SLOW --> all the variables will be used to fill the CF\n");
}
else if (configuration == AliCFTaskVertexingHF::kCheetah){
printf("The configuration is set to be FAST --> using only pt, y, ct, phi, zvtx, centrality, fake, multiplicity to fill the CF\n");
}
else if (configuration == AliCFTaskVertexingHF::kFalcon){
printf("The configuration is set to be FAST --> using only pt, y, centrality, multiplicity to fill the CF\n");
}
else{
printf("The configuration is not defined! returning\n");
return;
}
gSystem->Sleep(2000);
// isSign = 0 --> D+ only
// isSign = 1 --> D- only
// isSign = 2 --> both
TString expected;
if (isSign == 0 && pdgCode < 0){
AliError(Form("Error setting PDG code (%d) and sign (0 --> particle (%d) only): they are not compatible, returning",pdgCode));
return 0x0;
}
else if (isSign == 1 && pdgCode > 0){
AliError(Form("Error setting PDG code (%d) and sign (1 --> antiparticle (%d) only): they are not compatible, returning",pdgCode));
return 0x0;
}
else if (isSign > 2 || isSign < 0){
AliError(Form("Sign not valid (%d, possible values are 0, 1, 2), returning"));
return 0x0;
}
TFile* fileCuts = TFile::Open(cutFile);
if(!fileCuts || (fileCuts && !fileCuts->IsOpen())){
AliFatal(" Cut file not found");
return 0x0;
}
AliRDHFCutsDplustoKpipi *cutsDplustoKpipi = (AliRDHFCutsDplustoKpipi*)fileCuts->Get("AnalysisCuts");
TH1F *hMult=0x0;
if(multFile.EqualTo("") ) {
printf("Will not be corrected with weights \n");
}else{
TFile *fileMult = TFile::Open(multFile.Data());
if(isPPbData && multweighthistoname=="") {
hMult = (TH1F*)fileMult->Get("hNtrUnCorrEvWithCandWeight");
}
else if(!isPPbData && multweighthistoname==""){
hMult=(TH1F*)fileMult->Get("hGenPrimaryParticlesInelGt0");
}
else {
hMult=(TH1F*)fileMult->Get(multweighthistoname.Data());
}
}
// check that the fKeepD0fromB flag is set to true when the fKeepD0fromBOnly flag is true
// for now the binning is the same than for all D's
if(isKeepDfromBOnly) isKeepDfromB = true;
/*
Double_t ptmin_0_4;
Double_t ptmax_0_4;
Double_t ptmin_4_8;
Double_t ptmax_4_8;
Double_t ptmin_8_10;
Double_t ptmax_8_10;
if(!isKeepDfromB){
ptmin_0_4 = 0.0 ;
ptmax_0_4 = 4.0 ;
ptmin_4_8 = 4.0 ;
ptmax_4_8 = 8.0 ;
ptmin_8_10 = 8.0 ;
ptmax_8_10 = 10.0 ;
} else{
ptmin_0_4 = 0.0 ;
ptmax_0_4 = 3.0 ;
ptmin_4_8 = 3.0 ;
ptmax_4_8 = 5.0 ;
ptmin_8_10 = 5.0 ;
ptmax_8_10 = 10.0 ;
}
*/
//CONTAINER DEFINITION
Info("AliCFTaskVertexingHF","SETUP CONTAINER");
const Double_t phimax = 2*TMath::Pi();
//Setting up the container grid...
UInt_t nstep = 10; //number of selection steps: MC with limited acceptance, MC, Acceptance, Vertex, Refit, Reco (no cuts), RecoAcceptance, RecoITSClusters (RecoAcceptance included), RecoPPR (RecoAcceptance+RecoITSCluster included), RecoPID
// const Int_t nbinpt_0_4 = 8 ; //bins in pt from 0 to 4 GeV
// const Int_t nbinpt_4_8 = 4 ; //bins in pt from 4 to 8 GeV
// const Int_t nbinpt_8_10 = 1 ; //bins in pt from 8 to 10 GeV
/*
Int_t nbinpt_0_4;
Int_t nbinpt_4_8;
Int_t nbinpt_8_10;
if (!isKeepDfromB){
nbinpt_0_4 = 8 ; //bins in pt from 0 to 4 GeV
nbinpt_4_8 = 4 ; //bins in pt from 4 to 8 GeV
nbinpt_8_10 = 1 ; //bins in pt from 8 to 10 GeV
}else{
nbinpt_0_4 = 3 ; //bins in pt from 0 to 3 GeV
nbinpt_4_8 = 1 ; //bins in pt from 3 to 5 GeV
nbinpt_8_10 = 1 ; //bins in pt from 5 to 10 GeV
}
*/
const Int_t nbinpt = cutsDplustoKpipi->GetNPtBins(); // bins in pT
printf("pT: nbin (from cuts file) = %d\n",nbinpt);
const Int_t nbiny = 24 ; //bins in y
const Int_t nbinphi = 18 ; //bins in phi
const Int_t nbincT = 2 ; //bins in cT
const Int_t nbinpointing = 35 ; //bins in cosPointingAngle
const Int_t nbinpTpi_0_4 = 8 ; //bins in ptPi from 0 to 4 GeV
const Int_t nbinpTpi_4_8 = 4 ; //bins in ptPi from 4 to 8 GeV
const Int_t nbinpTpi_8_10 = 1 ; //bins in ptPi from 8 to 10 GeV
const Int_t nbinpTk_0_4 = 8 ; //bins in ptKa from 0 to 4 GeV
const Int_t nbinpTk_4_8 = 4 ; //bins in ptKa from 4 to 8 GeV
const Int_t nbinpTk_8_10 = 1 ; //bins in ptKa from 8 to 10 GeV
const Int_t nbinpTpi2_0_4 = 8 ; //bins in ptpi2 from 0 to 4 GeV
const Int_t nbinpTpi2_4_8 = 4 ; //bins in ptpi2 from 4 to 8 GeV
const Int_t nbinpTpi2_8_10 = 1 ; //bins in ptpi2 from 8 to 10 GeV
const Int_t nbinzvtx = 30 ; //bins in z vertex
const Int_t nbincent = 18; //bins in centrality
const Int_t nbincent_0_10 = 4; //bins in centrality between 0 and 10
const Int_t nbincent_10_60 = 10; //bins in centrality between 10 and 60
const Int_t nbincent_60_100 = 4; //bins in centrality between 60 and 100
const Int_t nbinfake = 3; //bins in fake
const Int_t nbinpointingXY = 50; //bins in cosPointingAngleXY
const Int_t nbinnormDecayLXY = 20; //bins in NormDecayLengthXY
const Int_t nbinmult = 49; //bins in multiplicity (total number)
const Int_t nbinmult_0_20 = 20; //bins in multiplicity between 0 and 20
const Int_t nbinmult_20_50 = 15; //bins in multiplicity between 20 and 50
const Int_t nbinmult_50_80 = 10; //bins in multiplicity between 50 and 80
const Int_t nbinmult_80_100 = 4; //bins in multiplicity between 80 and 100
const Int_t nbinmult_100_400 = 3; //bins in multiplicity between 100 and 400
if(isPPbData) nbinmult += nbinmult_100_400;
// Fine Ntrk bining setting
Double_t *binLimmultFine;
Int_t nbinmultTmp=nbinmult;
if(isFineNtrkBin){
Int_t nbinLimmultFine=100;
if(isPPbData) nbinLimmultFine = 200;
const UInt_t nbinMultFine = nbinLimmultFine;
binLimmultFine = new Double_t[nbinMultFine+1];
for (Int_t ibin0 = 0 ; ibin0<nbinMultFine+1; ibin0++){
binLimmultFine[ibin0] = ibin0;
}
nbinmultTmp=nbinLimmultFine;
}
const Int_t nbinmultTot=nbinmultTmp;
//the sensitive variables, their indices
const UInt_t ipT = 0;
const UInt_t iy = 1;
const UInt_t iphi = 2;
const UInt_t icT = 3;
const UInt_t ipointing = 4;
const UInt_t ipTpi = 5;
const UInt_t ipTk = 6;
const UInt_t ipTpi2 = 7;
const UInt_t izvtx = 8;
const UInt_t icent = 9;
const UInt_t ifake = 10;
const UInt_t ipointingXY = 11;
const UInt_t inormDecayLXY = 12;
const UInt_t imult = 13;
const Int_t nvarTot = 14 ; //number of variables on the grid:pt, y, cosThetaStar, pTpi, pTk, cT, dca, d0pi, d0K, d0xd0, cosPointingAngle, phi, zvtx, centrality, fake, cosPointingAngleXY, normDecayLengthXY, multiplicity
//arrays for the number of bins in each dimension
Int_t iBin[nvarTot];
//iBin[ipT]=nbinpt_0_4+nbinpt_4_8+nbinpt_8_10;
iBin[ipT]=nbinpt;
iBin[iy]=nbiny;
iBin[iphi]=nbinphi;
// iBin[icT]=nbincT_0_4+nbincT_4_8+nbincT_8_10;
//iBin[4]=nbinpointing_0_4+nbinpointing_4_8+nbinpointing_8_10;
iBin[icT]=nbincT;
iBin[ipointing]=nbinpointing;
iBin[ipTpi]=nbinpt;
iBin[ipTk]=nbinpt;
iBin[ipTpi2]=nbinpt;
iBin[izvtx]=nbinzvtx;
iBin[icent]=nbincent;
iBin[ifake]=nbinfake;
iBin[ipointingXY]=nbinpointingXY;
iBin[inormDecayLXY]=nbinnormDecayLXY;
iBin[imult]=nbinmultTot;
//arrays for lower bounds :
Double_t *binLimpT=new Double_t[iBin[ipT]+1];
Double_t *binLimy=new Double_t[iBin[iy]+1];
Double_t *binLimphi=new Double_t[iBin[iphi]+1];
Double_t *binLimcT=new Double_t[iBin[icT]+1];
Double_t *binLimpointing=new Double_t[iBin[ipointing]+1];
Double_t *binLimpTpi=new Double_t[iBin[ipTpi]+1];
Double_t *binLimpTk=new Double_t[iBin[ipTk]+1];
Double_t *binLimpTpi2=new Double_t[iBin[ipTpi2]+1];
Double_t *binLimzvtx=new Double_t[iBin[izvtx]+1];
Double_t *binLimcent=new Double_t[iBin[icent]+1];
Double_t *binLimfake=new Double_t[iBin[ifake]+1];
Double_t *binLimpointingXY=new Double_t[iBin[ipointingXY]+1];
Double_t *binLimnormDecayLXY=new Double_t[iBin[inormDecayLXY]+1];
Double_t *binLimmult=new Double_t[iBin[imult]+1];
// checking limits
/*
if (ptmax_0_4 != ptmin_4_8) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","max lim 1st range != min lim 2nd range, please check!");
}
if (ptmax_4_8 != ptmin_8_10) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","max lim 2nd range != min lim 3rd range, please check!");
}
*/
// values for bin lower bounds
// pt
Float_t* floatbinLimpT = cutsDplustoKpipi->GetPtBinLimits();
for (Int_t ibinpT = 0 ; ibinpT<iBin[ipT]+1; ibinpT++){
binLimpT[ibinpT] = (Double_t)floatbinLimpT[ibinpT];
binLimpTpi[ibinpT] = (Double_t)floatbinLimpT[ibinpT];
binLimpTk[ibinpT] = (Double_t)floatbinLimpT[ibinpT];
binLimpTpi2[ibinpT] = (Double_t)floatbinLimpT[ibinpT];
}
for(Int_t i=0; i<=nbinpt; i++) printf("binLimpT[%d]=%f\n",i,binLimpT[i]);
/*
for(Int_t i=0; i<=nbinpt_0_4; i++) binLimpT[i]=(Double_t)ptmin_0_4 + (ptmax_0_4-ptmin_0_4)/nbinpt_0_4*(Double_t)i ;
if (binLimpT[nbinpt_0_4] != ptmin_4_8) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for pt - 1st range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinpt_4_8; i++) binLimpT[i+nbinpt_0_4]=(Double_t)ptmin_4_8 + (ptmax_4_8-ptmin_4_8)/nbinpt_4_8*(Double_t)i ;
if (binLimpT[nbinpt_0_4+nbinpt_4_8] != ptmin_8_10) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for pt - 2nd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinpt_8_10; i++) binLimpT[i+nbinpt_0_4+nbinpt_4_8]=(Double_t)ptmin_8_10 + (ptmax_8_10-ptmin_8_10)/nbinpt_8_10*(Double_t)i ;
*/
// y
for(Int_t i=0; i<=nbiny; i++) binLimy[i]=(Double_t)ymin + (ymax-ymin) /nbiny*(Double_t)i ;
// Phi
for(Int_t i=0; i<=nbinphi; i++) binLimphi[i]=(Double_t)phimin + (phimax-phimin) /nbinphi*(Double_t)i ;
// cT
for(Int_t i=0; i<=nbincT; i++) binLimcT[i]=(Double_t)cTmin + (cTmax-cTmin) /nbincT*(Double_t)i ;
// cosPointingAngle
for(Int_t i=0; i<=nbinpointing; i++) binLimpointing[i]=(Double_t)cosmin + (cosmax-cosmin) /nbinpointing*(Double_t)i ;
/*
// ptPi
for(Int_t i=0; i<=nbincT_0_4; i++) binLimcT[i]=(Double_t)ptmin_0_4 + (ptmax_0_4-ptmin_0_4)/nbincT_0_4*(Double_t)i ;
if (binLimcT[nbincT_0_4] != ptmin_4_8) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for ptPi - 1st range - differs from expected!");
}
for(Int_t i=0; i<=nbincT_4_8; i++) binLimcT[i+nbincT_0_4]=(Double_t)ptmin_4_8 + (ptmax_4_8-ptmin_4_8)/nbincT_4_8*(Double_t)i ;
if (binLimcT[nbincT_0_4+nbincT_4_8] != ptmin_8_10) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for ptPi - 2nd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbincT_8_10; i++) binLimcT[i+nbincT_0_4+nbincT_4_8]=(Double_t)ptmin_8_10 + (ptmax_8_10-ptmin_8_10)/nbincT_8_10*(Double_t)i ;
// ptKa
for(Int_t i=0; i<=nbinpointing_0_4; i++) binLimpointing[i]=(Double_t)ptmin_0_4 + (ptmax_0_4-ptmin_0_4)/nbinpointing_0_4*(Double_t)i ;
if (binLimpointing[nbinpointing_0_4] != ptmin_4_8) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for ptKa - 1st range - differs from expected!");
}
for(Int_t i=0; i<=nbinpointing_4_8; i++) binLimpointing[i+nbinpointing_0_4]=(Double_t)ptmin_4_8 + (ptmax_4_8-ptmin_4_8)/nbinpointing_4_8*(Double_t)i ;
if (binLimpointing[nbinpointing_0_4+nbinpointing_4_8] != ptmin_8_10) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for ptKa - 2nd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinpointing_8_10; i++) binLimpointing[i+nbinpointing_0_4+nbinpointing_4_8]=(Double_t)ptmin_8_10 + (ptmax_8_10-ptmin_8_10)/nbinpointing_8_10*(Double_t)i ;
*/
// z Primary Vertex
for(Int_t i=0; i<=nbinzvtx; i++) {
binLimzvtx[i]=(Double_t)zvtxmin + (zvtxmax-zvtxmin) /nbinzvtx*(Double_t)i ;
}
// centrality
for(Int_t i=0; i<=nbincent_0_10; i++) binLimcent[i]=(Double_t)centmin_0_10 + (centmax_0_10-centmin_0_10)/nbincent_0_10*(Double_t)i ;
if (binLimcent[nbincent_0_10] != centmin_10_60) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for cent - 1st range - differs from expected!\n");
}
for(Int_t i=0; i<=nbincent_10_60; i++) binLimcent[i+nbincent_0_10]=(Double_t)centmin_10_60 + (centmax_10_60-centmin_10_60)/nbincent_10_60*(Double_t)i ;
if (binLimcent[nbincent_0_10+nbincent_10_60] != centmin_60_100) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for cent - 2st range - differs from expected!\n");
}
for(Int_t i=0; i<=nbincent_60_100; i++) binLimcent[i+nbincent_0_10+nbincent_10_60]=(Double_t)centmin_60_100 + (centmax_60_100-centmin_60_100)/nbincent_60_100*(Double_t)i ;
// fake
for(Int_t i=0; i<=nbinfake; i++) {
binLimfake[i]=(Double_t)fakemin + (fakemax-fakemin)/nbinfake * (Double_t)i;
}
// cosPointingAngleXY
for(Int_t i=0; i<=nbinpointingXY; i++) binLimpointingXY[i]=(Double_t)cosminXY + (cosmaxXY-cosminXY) /nbinpointingXY*(Double_t)i ;
// normDecayLXY
for(Int_t i=0; i<=nbinnormDecayLXY; i++) binLimnormDecayLXY[i]=(Double_t)normDecLXYmin + (normDecLXYmax-normDecLXYmin) /nbinnormDecayLXY*(Double_t)i ;
// multiplicity
for(Int_t i=0; i<=nbinmult_0_20; i++) binLimmult[i]=(Double_t)multmin_0_20 + (multmax_0_20-multmin_0_20)/nbinmult_0_20*(Double_t)i ;
if (binLimmult[nbinmult_0_20] != multmin_20_50) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for mult - 1st range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinmult_20_50; i++) binLimmult[i+nbinmult_0_20]=(Double_t)multmin_20_50 + (multmax_20_50-multmin_20_50)/nbinmult_20_50*(Double_t)i ;
if (binLimmult[nbinmult_0_20+nbinmult_20_50] != multmin_50_80) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for mult - 2nd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinmult_50_80; i++) binLimmult[i+nbinmult_0_20+nbinmult_20_50]=(Double_t)multmin_50_80 + (multmax_50_80-multmin_50_80)/nbinmult_50_80*(Double_t)i ;
if (binLimmult[nbinmult_0_20+nbinmult_20_50+nbinmult_50_80] != multmin_80_100) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for mult - 3rd range - differs from expected!\n");
}
for(Int_t i=0; i<=nbinmult_80_100; i++) binLimmult[i+nbinmult_0_20+nbinmult_20_50+nbinmult_50_80]=(Double_t)multmin_80_100 + (multmax_80_100-multmin_80_100)/nbinmult_80_100*(Double_t)i ;
if (binLimmult[nbinmult_0_20+nbinmult_20_50+nbinmult_50_80+nbinmult_80_100] != multmin_100_400) {
Error("AliCFHeavyFlavourTaskMultiVarMultiStep","Calculated bin lim for mult - 4th range - differs from expected!\n");
}
if(isPPbData){
for (Int_t i = 0; i<=nbinmult_100_400; i++) binLimmult[i+nbinmult_0_20+nbinmult_20_50+nbinmult_50_80+nbinmult_80_100]= (Double_t)multmin_100_400 + (multmax_100_400-multmin_100_400)/nbinmult_100_400*(Double_t)i ;
}
//one "container" for MC
TString nameContainer="";
if(!isKeepDfromB) {
nameContainer="CFHFcontainer_DplustoKpipi_Prompt";
}
else if(isKeepDfromBOnly){
nameContainer="CFHFcontainer_DplustoKpipi_FromB";
}
else {
nameContainer="CFHFcontainer_DplustoKpipi_All";
}
nameContainer += suffixName.Data();
AliCFContainer* container;
if (configuration == AliCFTaskVertexingHF::kSnail){
container = new AliCFContainer(nameContainer,"container for tracks",nstep,nvarTot,iBin);
//setting the bin limits
printf("pt\n");
container -> SetBinLimits(ipT,binLimpT);
printf("y\n");
container -> SetBinLimits(iy,binLimy);
printf("Phi\n");
container -> SetBinLimits(iphi,binLimphi);
printf("cT\n");
container -> SetBinLimits(icT,binLimcT);
printf("pointing angle\n");
container -> SetBinLimits(ipointing,binLimpointing);
printf("ptpi\n");
container -> SetBinLimits(ipTpi,binLimpTpi);
printf("ptK\n");
container -> SetBinLimits(ipTk,binLimpTk);
printf("ptpi2\n");
container -> SetBinLimits(ipTpi2,binLimpTpi2);
printf("zvtx \n");
container -> SetBinLimits(izvtx,binLimzvtx);
printf("cent\n");
container -> SetBinLimits(icent,binLimcent);
printf("fake\n");
container -> SetBinLimits(ifake,binLimfake);
printf("pointingXY\n");
container -> SetBinLimits(ipointingXY,binLimpointingXY);
printf("normDecayLXY\n");
container -> SetBinLimits(inormDecayLXY,binLimnormDecayLXY);
printf("multiplicity\n");
if(isFineNtrkBin) container -> SetBinLimits(imult,binLimmultFine);
else container -> SetBinLimits(imult,binLimmult);
container -> SetVarTitle(ipT,"pt");
container -> SetVarTitle(iy,"y");
container -> SetVarTitle(iphi, "phi");
container -> SetVarTitle(icT, "ct");
container -> SetVarTitle(ipointing, "pointing");
container -> SetVarTitle(ipTpi, "ptpi");
container -> SetVarTitle(ipTk, "ptK");
container -> SetVarTitle(ipTpi2, "ptpi2");
container -> SetVarTitle(izvtx, "zvtx");
container -> SetVarTitle(icent, "centrality");
container -> SetVarTitle(ifake, "fake");
container -> SetVarTitle(ipointingXY, "piointingXY");
container -> SetVarTitle(inormDecayLXY, "normDecayLXY");
container -> SetVarTitle(imult, "multiplicity");
}
else if (configuration == AliCFTaskVertexingHF::kCheetah){
//arrays for the number of bins in each dimension
const Int_t nvar = 8;
const UInt_t ipTFast = 0;
const UInt_t iyFast = 1;
const UInt_t icTFast = 2;
const UInt_t iphiFast = 3;
const UInt_t izvtxFast = 4;
const UInt_t icentFast = 5;
const UInt_t ifakeFast = 6;
const UInt_t imultFast = 7;
Int_t iBinFast[nvar];
iBinFast[ipTFast] = iBin[ipT];
iBinFast[iyFast] = iBin[iy];
iBinFast[icTFast] = iBin[icT];
iBinFast[iphiFast] = iBin[iphi];
iBinFast[izvtxFast] = iBin[izvtx];
iBinFast[icentFast] = iBin[icent];
iBinFast[ifakeFast] = iBin[ifake];
iBinFast[imultFast] = iBin[imult];
container = new AliCFContainer(nameContainer,"container for tracks",nstep,nvar,iBinFast);
printf("pt\n");
container -> SetBinLimits(ipTFast,binLimpT);
printf("y\n");
container -> SetBinLimits(iyFast,binLimy);
printf("ct\n");
container -> SetBinLimits(icTFast,binLimcT);
printf("phi\n");
container -> SetBinLimits(iphiFast,binLimphi);
printf("zvtx\n");
container -> SetBinLimits(izvtxFast,binLimzvtx);
printf("centrality\n");
container -> SetBinLimits(icentFast,binLimcent);
printf("fake\n");
container -> SetBinLimits(ifakeFast,binLimfake);
printf("multiplicity\n");
if(isFineNtrkBin) container -> SetBinLimits(imultFast,binLimmultFine);
else container -> SetBinLimits(imultFast,binLimmult);
container -> SetVarTitle(ipTFast,"pt");
container -> SetVarTitle(iyFast,"y");
container -> SetVarTitle(icTFast, "ct");
container -> SetVarTitle(iphiFast, "phi");
container -> SetVarTitle(izvtxFast, "zvtx");
container -> SetVarTitle(icentFast, "centrality");
container -> SetVarTitle(ifakeFast, "fake");
container -> SetVarTitle(imultFast, "multiplicity");
}
else if (configuration == AliCFTaskVertexingHF::kFalcon){
//arrays for the number of bins in each dimension
const Int_t nvar = 4;
const UInt_t ipTSuperFast = 0;
const UInt_t iySuperFast = 1;
const UInt_t icentSuperFast = 2;
const UInt_t imultSuperFast = 3;
Int_t iBinSuperFast[nvar];
iBinSuperFast[ipTSuperFast] = iBin[ipT];
iBinSuperFast[iySuperFast] = iBin[iy];
iBinSuperFast[icentSuperFast] = iBin[icent];
iBinSuperFast[imultSuperFast] = iBin[imult];
container = new AliCFContainer(nameContainer,"container for tracks",nstep,nvar,iBinSuperFast);
printf("pt\n");
container -> SetBinLimits(ipTSuperFast,binLimpT);
printf("y\n");
container -> SetBinLimits(iySuperFast,binLimy);
printf("centrality\n");
container -> SetBinLimits(icentSuperFast,binLimcent);
printf("multiplicity\n");
if(isFineNtrkBin) container -> SetBinLimits(imultSuperFast,binLimmultFine);
else container -> SetBinLimits(imultSuperFast,binLimmult);
container -> SetVarTitle(ipTSuperFast,"pt");
container -> SetVarTitle(iySuperFast,"y");
container -> SetVarTitle(icentSuperFast, "centrality");
container -> SetVarTitle(imultSuperFast, "multiplicity");
}
//return container;
container -> SetStepTitle(0, "MCLimAcc");
container -> SetStepTitle(1, "MC");
container -> SetStepTitle(2, "MCAcc");
container -> SetStepTitle(3, "RecoVertex");
container -> SetStepTitle(4, "RecoRefit");
container -> SetStepTitle(5, "Reco");
container -> SetStepTitle(6, "RecoAcc");
container -> SetStepTitle(7, "RecoITSCluster");
container -> SetStepTitle(8, "RecoCuts");
container -> SetStepTitle(9, "RecoPID");
//CREATE THE CUTS -----------------------------------------------
// Gen-Level kinematic cuts
AliCFTrackKineCuts *mcKineCuts = new AliCFTrackKineCuts("mcKineCuts","MC-level kinematic cuts");
//Particle-Level cuts:
AliCFParticleGenCuts* mcGenCuts = new AliCFParticleGenCuts("mcGenCuts","MC particle generation cuts");
Bool_t useAbsolute = kTRUE;
if (isSign != 2){
useAbsolute = kFALSE;
}
mcGenCuts->SetRequirePdgCode(pdgCode, useAbsolute); // kTRUE set in order to include antiparticle
mcGenCuts->SetAODMC(1); //special flag for reading MC in AOD tree (important)
// Acceptance cuts:
AliCFAcceptanceCuts* accCuts = new AliCFAcceptanceCuts("accCuts", "Acceptance cuts");
AliCFTrackKineCuts *kineAccCuts = new AliCFTrackKineCuts("kineAccCuts","Kine-Acceptance cuts");
kineAccCuts->SetPtRange(ptmin,ptmax);
kineAccCuts->SetEtaRange(etamin,etamax);
// Rec-Level kinematic cuts
AliCFTrackKineCuts *recKineCuts = new AliCFTrackKineCuts("recKineCuts","rec-level kine cuts");
AliCFTrackQualityCuts *recQualityCuts = new AliCFTrackQualityCuts("recQualityCuts","rec-level quality cuts");
AliCFTrackIsPrimaryCuts *recIsPrimaryCuts = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts","rec-level isPrimary cuts");
printf("CREATE MC KINE CUTS\n");
TObjArray* mcList = new TObjArray(0) ;
mcList->AddLast(mcKineCuts);
mcList->AddLast(mcGenCuts);
printf("CREATE ACCEPTANCE CUTS\n");
TObjArray* accList = new TObjArray(0) ;
accList->AddLast(kineAccCuts);
printf("CREATE RECONSTRUCTION CUTS\n");
TObjArray* recList = new TObjArray(0) ; // not used!!
recList->AddLast(recKineCuts);
recList->AddLast(recQualityCuts);
recList->AddLast(recIsPrimaryCuts);
TObjArray* emptyList = new TObjArray(0);
//CREATE THE INTERFACE TO CORRECTION FRAMEWORK USED IN THE TASK
printf("CREATE INTERFACE AND CUTS\n");
AliCFManager* man = new AliCFManager() ;
man->SetParticleContainer(container);
man->SetParticleCutsList(0 , mcList); // MC, Limited Acceptance
man->SetParticleCutsList(1 , mcList); // MC
man->SetParticleCutsList(2 , accList); // Acceptance
man->SetParticleCutsList(3 , emptyList); // Vertex
man->SetParticleCutsList(4 , emptyList); // Refit
man->SetParticleCutsList(5 , emptyList); // AOD
man->SetParticleCutsList(6 , emptyList); // AOD in Acceptance
man->SetParticleCutsList(7 , emptyList); // AOD with required n. of ITS clusters
man->SetParticleCutsList(8 , emptyList); // AOD Reco (PPR cuts implemented in Task)
man->SetParticleCutsList(9 , emptyList); // AOD Reco PID
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskCompareHF", "No analysis manager to connect to.");
return NULL;
}
//CREATE THE TASK
printf("CREATE TASK\n");
// create the task
AliCFTaskVertexingHF *task = new AliCFTaskVertexingHF("AliCFTaskVertexingHF",cutsDplustoKpipi);
task->SetConfiguration(configuration);
task->SetFillFromGenerated(kFALSE);
task->SetDecayChannel(31);
task->SetUseWeight(useWeight);
task->SetCFManager(man); //here is set the CF manager
task->SetSign(isSign);
task->SetCentralitySelection(kFALSE);
task->SetFakeSelection(0);
task->SetRejectCandidateIfNotFromQuark(kTRUE); // put to false if you want to keep HIJING D0!!
task->SetUseMCVertex(kFALSE); // put to true if you want to do studies on pp
task->SetUseNchWeight(useNchWeight); //correction with mult weight
if(useNchWeight || useNtrkWeight){
if(hMult) task->SetMCNchHisto(hMult);
else{
AliFatal("Histogram for multiplicity weights not found");
return 0x0;
}
task->SetUseNchWeight(kTRUE);
if(useNtrkWeight) task->SetUseNchTrackletsWeight();
}
if(isPPbData) {
task->SetIsPPbData(kTRUE);
}
if (isKeepDfromB && !isKeepDfromBOnly) task->SetDselection(2);
if (isKeepDfromB && isKeepDfromBOnly) task->SetDselection(1);
TF1* funcWeight = 0x0;
if (task->GetUseWeight()) {
funcWeight = (TF1*)fileCuts->Get("funcWeight");
if (funcWeight == 0x0){
Printf("FONLL Weights will be used");
}
else {
task->SetWeightFunction(funcWeight);
Printf("User-defined Weights will be used. The function being:");
task->GetWeightFunction()->Print();
}
}
task->SetMultiplicityEstimator(multiplicityEstimator);
if(estimatorFilename.EqualTo("") ) {
printf("Estimator file not provided, multiplicity corrected histograms will not be filled\n");
task->SetUseZvtxCorrectedNtrkEstimator(kFALSE);
} else{
TFile* fileEstimator=TFile::Open(estimatorFilename.Data());
if(!fileEstimator) {
AliFatal("File with multiplicity estimator not found");
return;
}
task->SetUseZvtxCorrectedNtrkEstimator(kTRUE);
task->SetReferenceMultiplcity(refMult);
if (isPPbData) { //load multiplicity estimators for pPb
const Char_t* periodNames[2] = {"LHC13b", "LHC13c"};
TProfile *multEstimatorAvg[2];
for (Int_t ip=0; ip < 2; ip++) {
multEstimatorAvg[ip] = (TProfile*)(fileEstimator->Get(Form("SPDmult10_%s",periodNames[ip]))->Clone(Form("SPDmult10_%s_clone",periodNames[ip])));
if (!multEstimatorAvg[ip]) {
AliFatal(Form("Multiplicity estimator for %s not found! Please check your estimator file",periodNames[ip]));
return;
}
}
task->SetMultiplVsZProfileLHC13b(multEstimatorAvg[0]);
task->SetMultiplVsZProfileLHC13c(multEstimatorAvg[1]);
} else { //load multiplicity estimators for pp
const Char_t* periodNames[4] = {"LHC10b", "LHC10c", "LHC10d", "LHC10e"};
TProfile* multEstimatorAvg[4];
for(Int_t ip=0; ip<4; ip++) {
multEstimatorAvg[ip] = (TProfile*)(fileEstimator->Get(Form("SPDmult10_%s",periodNames[ip]))->Clone(Form("SPDmult10_%s_clone",periodNames[ip])));
if (!multEstimatorAvg[ip]) {
AliFatal(Form("Multiplicity estimator for %s not found! Please check your estimator file",periodNames[ip]));
return;
}
}
task->SetMultiplVsZProfileLHC10b(multEstimatorAvg[0]);
task->SetMultiplVsZProfileLHC10c(multEstimatorAvg[1]);
task->SetMultiplVsZProfileLHC10d(multEstimatorAvg[2]);
task->SetMultiplVsZProfileLHC10e(multEstimatorAvg[3]);
}
}
Printf("***************** CONTAINER SETTINGS *****************");
Printf("decay channel = %d",(Int_t)task->GetDecayChannel());
Printf("FillFromGenerated = %d",(Int_t)task->GetFillFromGenerated());
Printf("Dselection = %d",(Int_t)task->GetDselection());
Printf("Sign = %d",(Int_t)task->GetSign());
Printf("Centrality selection = %d",(Int_t)task->GetCentralitySelection());
Printf("Fake selection = %d",(Int_t)task->GetFakeSelection());
Printf("RejectCandidateIfNotFromQuark selection = %d",(Int_t)task->GetRejectCandidateIfNotFromQuark());
Printf("UseMCVertex selection = %d",(Int_t)task->GetUseMCVertex());
Printf("***************END CONTAINER SETTINGS *****************\n");
//-----------------------------------------------------------//
// create correlation matrix for unfolding - only eta-pt //
//-----------------------------------------------------------//
Bool_t AcceptanceUnf = kTRUE; // unfold at acceptance level, otherwise PPR
Int_t thnDim[4];
//first half : reconstructed
//second half : MC
thnDim[0] = iBin[ipT];
thnDim[2] = iBin[ipT];
thnDim[1] = iBin[iy];
thnDim[3] = iBin[iy];
TString nameCorr="";
if(!isKeepDfromB) {
nameCorr="CFHFcorr_DplustoKpipi_Prompt";
}
else if(isKeepDfromBOnly){
nameCorr="CFHFcorr_DplustoKpipi_FromB";
}
else {
nameCorr="CFHFcorr_DplustoKpipi_All";
}
nameCorr += suffixName.Data();
THnSparseD* correlation = new THnSparseD(nameCorr,"THnSparse with correlations",4,thnDim);
Double_t** binEdges = new Double_t[2];
// set bin limits
binEdges[0]= binLimpT;
binEdges[1]= binLimy;
correlation->SetBinEdges(0,binEdges[0]);
correlation->SetBinEdges(2,binEdges[0]);
correlation->SetBinEdges(1,binEdges[1]);
correlation->SetBinEdges(3,binEdges[1]);
correlation->Sumw2();
// correlation matrix ready
//------------------------------------------------//
task->SetCorrelationMatrix(correlation); // correlation matrix for unfolding
// Create and connect containers for input/output
// ------ input data ------
AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
// ----- output data -----
TString outputfile = AliAnalysisManager::GetCommonFileName();
TString output1name="", output2name="", output3name="", output4name="", output5name="";
output2name=nameContainer;
output3name=nameCorr;
output5name= "coutProfDp";
if(!isKeepDfromB) {
outputfile += ":PWG3_D2H_CFtaskDplustoKpipi_Prompt";
output1name="CFHFhist_DplustoKpipi_Prompt";
output3name+="_Prompt";
output4name= "Cuts_DplustoKpipi_Prompt";
output5name+="_Prompt";
}
else if(isKeepDfromBOnly){
outputfile += ":PWG3_D2H_CFtaskDplustoKpipi_FromB";
output1name="CFHFhist_DplustoKpipi_FromB";
output3name+="_FromB";
output4name= "Cuts_DplustoKpipi_FromB";
output5name+="_FromB";
}
else{
outputfile += ":PWG3_D2H_CFtaskDplustoKpipi_All";
output1name="CFHFhist_DplustoKpipi_All";
output3name+="_All";
output4name= "Cuts_DplustoKpipi_All";
output5name+="_All";
}
outputfile += suffixName.Data();
output1name += suffixName.Data();
output4name += suffixName.Data();
output5name += suffixName.Data();
//now comes user's output objects :
// output TH1I for event counting
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(output1name, TH1I::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
// output Correction Framework Container (for acceptance & efficiency calculations)
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(output2name, AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
// Unfolding - correlation matrix
AliAnalysisDataContainer *coutput3 = mgr->CreateContainer(output3name, THnSparseD::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
AliAnalysisDataContainer *coutput4 = mgr->CreateContainer(output4name, AliRDHFCuts::Class(),AliAnalysisManager::kOutputContainer, outputfile.Data());
// estimators list
AliAnalysisDataContainer *coutput5 = mgr->CreateContainer(output5name, TList::Class(),AliAnalysisManager::kOutputContainer, outputfile.Data());
mgr->AddTask(task);
mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
mgr->ConnectOutput(task,1,coutput1);
mgr->ConnectOutput(task,2,coutput2);
mgr->ConnectOutput(task,3,coutput3);
mgr->ConnectOutput(task,4,coutput4);
mgr->ConnectOutput(task,5,coutput5);
return task;
}
void MakeLHCDataEntry(char* storageUri="local://$ALICE_ROOT/../AliRoot/OCDB", Int_t firstRun=0, Int_t lastRun=999999999)
{
AliCDBManager *cdb = AliCDBManager::Instance();
cdb->SetDefaultStorage(storageUri);
// Get time start from the simulated LHCData file
Double_t timeStart = 0.0;
Double_t timeEnd = 1.0e+10;
TString fileName(gSystem->ExpandPathName("$ALICE_ROOT/../AliRoot/GRP/ShuttleInput/testShuttle_GRP_run_number_testShuttle_data.txt"));
Printf("Getting the file %s", fileName.Data());
const Int_t fgknLHCDP = 9; // number of dcs dps from LHC data
const char* fgkLHCDataPoints[fgknLHCDP] = {
"LHC_Beam_Energy",
"LHC_MachineMode",
"LHC_BeamMode",
"LHC_Beams_Particle_Type",
"BPTX_Phase_Shift_B1",
"BPTX_Phase_Shift_B2",
"LHC_Particle_Type_B1",
"LHC_Particle_Type_B2",
"LHC_Data_Quality_Flag"
};
AliGRPObject *grpobj = new AliGRPObject();
// grpobj->SetBeamEnergyIsSqrtSHalfGeV(); // new format
//
//Getting the LHC Data from DCS FXS
//
AliLHCReader lhcReader;
// Processing data to be put in AliGRPObject
// Energy
Printf("*************Energy ");
TObjArray* energyArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[0]);
if (energyArray){
Float_t energy = ProcessEnergy(energyArray,timeStart);
if (energy != -1.) {
grpobj->SetBeamEnergy(energy);
grpobj->SetBeamEnergyIsSqrtSHalfGeV(kTRUE);
}
delete energyArray;
}
else {
AliError("Energy not found in LHC Data file!!!");
}
Double_t timeBeamModeEnd = timeEnd; // max validity for Beam Mode
Double_t timeMachineModeEnd = timeEnd; // max validity for Machine Mode
Double_t timeBeamEnd = timeEnd; // max validity for Beam Type
Double_t timeBeamTypeEnd[2] = {timeEnd, timeEnd}; // max validity for Beam Type1,2
Double_t timeBeamModeStart = -1; // min validity for Beam Mode
Double_t timeMachineModeStart = -1; // min validity for Machine Mode
Double_t timeBeamStart = -1; // min validity for Beam Type
Double_t timeBeamTypeStart[2] = {-1,-1}; // min validity for Beam Type1,2
Int_t indexBeamMode = -1; // index of measurement used to set Beam Mode
Int_t indexMachineMode = -1; // index of measurement used to set Machine Mode
Int_t indexBeam = -1; // index of measurement used to set Beam Type
Int_t indexBeamType[2] = {-1, -1}; // index of measurement used to set Beam Type1,2
Bool_t foundBeamModeStart = kFALSE; // flag to be set in case an entry for the Beam Mode is found before (or at) SOR
Bool_t foundMachineModeStart = kFALSE; // flag to be set in case an entry for the Machine Mode is found before (or at) SOR
Bool_t foundBeamStart = kFALSE; // flag to be set in case an entry for the Beam Type is found before (or at) SOR
Bool_t foundBeamTypeStart[2] = {kFALSE, kFALSE}; // flag to be set in case an entry for the Beam Type1,2 is found before (or at) SOR
Bool_t flagBeamMode = kFALSE; //flag set true if a changed occurred in BeamMode
Bool_t flagMachineMode = kFALSE; //flag set true if a changed occurred in MachineMode
Bool_t flagBeam = kFALSE; //flag set true if a changed occurred in BeamType
Bool_t flagBeamType[2] = {kFALSE, kFALSE}; //flag set true if a changed occurred in BeamType1,2
Double_t arrayTimes[5]={2.E9, 2.E9, 2.E9, 2.E9, 2.E9}; // array to keep track of the times of the possible changes of the LHC DPs; each entry set to Wed May 18 2033, 03:33:20 GMT (ALICE should not be running anymore...)
// arrayTimes elements order correspond to the one used in the array of the strings fgkLHCDataPoints, i.e.:
// arrayTimes[0] --> MachineMode
// arrayTimes[1] --> BeamMode
// arrayTimes[2] --> BeamType (when written together)
// arrayTimes[3] --> BeamType1 (when written separate)
// arrayTimes[4] --> BeamType2 (when written separate)
// BeamMode
Printf("*************BeamMode (LHCState) ");
TObjArray* beamModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[2]);
Int_t nBeamMode = -1;
if (beamModeArray){
nBeamMode = beamModeArray->GetEntries();
if (nBeamMode==0){
Printf("Found zero entries for the Beam Mode, leaving it empty");
}
else{
for (Int_t iBeamMode = 0; iBeamMode<nBeamMode; iBeamMode++){
AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(iBeamMode);
if (beamMode){
if (beamMode->GetTimeStamp()<=timeStart && beamMode->GetTimeStamp()>=timeBeamModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
timeBeamModeStart = beamMode->GetTimeStamp();
indexBeamMode = iBeamMode;
foundBeamModeStart = kTRUE;
}
else {
break;
}
}
}
if (!foundBeamModeStart){
Printf("No value for the Beam Mode found before start of run, the Beam Mode will remain empty");
}
else {
AliDCSArray* beamMode = (AliDCSArray*)beamModeArray->At(indexBeamMode);
TObjString* beamModeString = beamMode->GetStringArray(0);
Printf(Form("LHC State (corresponding to BeamMode) = %s (set at %f)",(beamModeString->String()).Data(),beamMode->GetTimeStamp()));
grpobj->SetLHCState(beamModeString->String());
if (indexBeamMode < nBeamMode-1){
AliDCSArray* beamMode1 = (AliDCSArray*)beamModeArray->At(indexBeamMode+1);
if (beamMode1){
if (beamMode1->GetTimeStamp()<=timeStart){
Printf("ERROR: you did not choose the correct value! there is still something before (or at) SOR, but later than this!");
}
else if (beamMode1->GetTimeStamp()>timeStart && beamMode1->GetTimeStamp()<=timeEnd){
timeBeamModeEnd = beamMode1->GetTimeStamp();
TObjString* beamModeString1 = beamMode1->GetStringArray(0);
TString bmString0 = beamModeString->String();
TString bmString1 = beamModeString1->String();
if (bmString0.CompareTo(bmString1.Data(),TString::kIgnoreCase) == -1){
Printf("WARNING: The beam mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",bmString0.Data(), bmString1.Data(), timeBeamModeEnd, bmString0.Data());
flagBeamMode = kTRUE;
arrayTimes[1]=timeBeamModeEnd;
}
}
}
else {
Printf("Invalid pointer for the first entry for Beam Mode after the first valid one, not considering anything after what has already been found");
}
}
}
}
delete beamModeArray;
}
else{
Printf("ERROR: Beam mode array not found in LHC Data file!!!");
}
// MachineMode
Printf("*************MachineMode ");
TObjArray* machineModeArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[1]);
Int_t nMachineMode = -1;
if (machineModeArray){
nMachineMode = machineModeArray->GetEntries();
if (nMachineMode==0){
Printf("No Machine Mode found, leaving it empty");
}
else{
for (Int_t iMachineMode = 0; iMachineMode<nMachineMode; iMachineMode++){
AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(iMachineMode);
if (machineMode){
if (machineMode->GetTimeStamp()<=timeStart && machineMode->GetTimeStamp()>=timeMachineModeStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
timeMachineModeStart = machineMode->GetTimeStamp();
indexMachineMode = iMachineMode;
foundMachineModeStart = kTRUE;
}
else{
break;
}
}
}
if (!foundMachineModeStart){
Printf("No value for the Machine Mode found before start of run, the Machine Mode will remain empty");
}
else {
AliDCSArray* machineMode = (AliDCSArray*)machineModeArray->At(indexMachineMode);
TObjString* machineModeString = machineMode->GetStringArray(0);
Printf(Form("MachineMode = %s (set at %f)",(machineModeString->String()).Data(),machineMode->GetTimeStamp()));
grpobj->SetMachineMode(machineModeString->String());
if (indexMachineMode < nMachineMode-1){
AliDCSArray* machineMode1 = (AliDCSArray*)machineModeArray->At(indexMachineMode+1);
if (machineMode1){
if (machineMode1->GetTimeStamp()>timeStart && machineMode1->GetTimeStamp()<=timeEnd){
timeMachineModeEnd = machineMode1->GetTimeStamp();
TObjString* machineModeString1 = machineMode1->GetStringArray(0);
TString mmString0 = machineModeString->String();
TString mmString1 = machineModeString1->String();
if (mmString0.CompareTo(mmString1.Data(),TString::kIgnoreCase) == -1){
Printf("WARNING: The machine mode changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",mmString0.Data(),mmString1.Data(),timeMachineModeEnd,mmString0.Data());
flagMachineMode = kTRUE;
arrayTimes[0]=timeMachineModeEnd;
}
}
}
else {
Printf("Invalid pointer for the first entry for Machine Mode after the first valid one, not considering anything after what has already been found");
}
}
}
}
delete machineModeArray;
}
else{
Printf("ERROR: Machine mode array not found in LHC Data file!!!");
}
// BeamType1 and BeamType2 - both put in the same string
Printf("*************BeamType ");
TObjArray* beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[3]);
if (beamArray){
Int_t nBeam = beamArray->GetEntries();
if (nBeam==0){
Printf("No Beam Type found, leaving it empty");
}
else{
for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
if (beam){
if (beam->GetTimeStamp()<=timeStart && beam->GetTimeStamp()>=timeBeamStart){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
timeBeamStart = beam->GetTimeStamp();
indexBeam = iBeam;
foundBeamStart = kTRUE;
}
else{
break;
}
}
}
if (!foundBeamStart){
Printf("No value for the Beam Type found before start of run, the (common) Beam Type will remain empty");
}
else {
AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
TObjString* beamString = beam->GetStringArray(0);
TString beamType = beamString->String();
Printf(Form("Beam Type = %s",beamType.Data()));
if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
Printf("Setting beam type to p-p");
grpobj->SetBeamType("p-p");
}
else { // if there is no PROTON beam, we suppose it is Pb, and we put A-A
Printf("Setting beam type to A-A");
grpobj->SetBeamType("A-A");
}
/*
else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
Printf("Setting beam type to Pb-Pb");
grpobj->SetBeamType("Pb-Pb");
}
else{
Printf("ERROR: Beam Type not known, leaving it empty");
}
*/
if (indexBeam < nBeam-1){
AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
if (beam1){
if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
timeBeamEnd = beam1->GetTimeStamp();
TObjString* beamString1 = beam1->GetStringArray(0);
TString beamType1 = beamString1->String();
if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
Printf("WARNING: The Beam Type changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",beamType.Data(),(beamString1->String()).Data(),timeBeamEnd,beamType.Data());
flagBeam = kTRUE;
arrayTimes[2] = timeBeamEnd;
}
}
}
else {
Printf("Invalid pointer for the first entry for Beam Type after the first valid one, not considering anything after what has already been found");
}
}
}
}
delete beamArray;
}
else{
Printf("ERROR: Beam Type array not found in LHC Data file!!!");
}
// BeamType1 and BeamType2 - in separete string
Printf("*************BeamType, 1 and 2 ");
Int_t indexBeamTypeString = 6; // index of the string with the alias of BeanType1 in the array fgkLHCDataPoints
TString combinedBeamType = "-"; // combined beam type, built from beam type 1 and beam type 2
TString combinedBeamTypeFromLHC = "-"; // combined beam type, built from beam type 1 and beam type 2 AS SENT FROM LHC
for (Int_t ibeamType = 0; ibeamType<2; ibeamType++){
beamArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[indexBeamTypeString+ibeamType]);
if (beamArray){
Int_t nBeam = beamArray->GetEntries();
if (nBeam==0){
Printf(Form("No Beam Type %s found, leaving it empty",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
}
else{
for (Int_t iBeam = 0; iBeam<nBeam; iBeam++){
AliDCSArray* beam = (AliDCSArray*)beamArray->At(iBeam);
if (beam){
if (beam->GetTimeStamp()<=timeStart && beam->GetTimeStamp()>=timeBeamTypeStart[ibeamType]){// taking always the very last entry: of two measurements have the same timestamp, the last one is taken
timeBeamTypeStart[ibeamType] = beam->GetTimeStamp();
indexBeamType[ibeamType] = iBeam;
foundBeamTypeStart[ibeamType] = kTRUE;
}
else{
break;
}
}
}
if (!foundBeamTypeStart[ibeamType]){
Printf(Form("No value for the Beam Type %s found before start of run, the Beam Type %d will remain empty", fgkLHCDataPoints[indexBeamTypeString+ibeamType], ibeamType));
}
else {
AliDCSArray* beam = (AliDCSArray*)beamArray->At(indexBeam);
TObjString* beamString = beam->GetStringArray(0);
TString beamType = beamString->String();
Printf(Form("Beam Type (for %s) = %s", fgkLHCDataPoints[indexBeamTypeString+ibeamType], beamType.Data()));
TString singleBeam = ParseBeamTypeString(beamType,ibeamType);
Printf(Form("Single Beam Type for beam %d set to %s", ibeamType, singleBeam.Data()));
grpobj->SetSingleBeamType(ibeamType, singleBeam);
if (beamType.CompareTo("PROTON",TString::kIgnoreCase) == 0){
Printf(Form("Setting beam %d for combined beam type to p", ibeamType));
if (ibeamType == 0) combinedBeamType.Prepend("p");
else combinedBeamType.Append("p");
}
else { // if there is no PROTON beam, we suppose it is Pb, and we put A-A
Printf(Form("Setting beam %d for combined beam type to A",ibeamType));
if (ibeamType == 0) combinedBeamType.Prepend("A");
else combinedBeamType.Append("A");
}
if (ibeamType == 0) combinedBeamTypeFromLHC.Prepend(beamType);
else combinedBeamTypeFromLHC.Append(beamType);
/*
else if (beamType.CompareTo("LEAD82",TString::kIgnoreCase) == 0){
Printf("Setting beam type to Pb-Pb");
grpobj->SetSingleBeamType(ibeamType, "Pb-Pb");
}
else{
Printf("ERROR: Beam Type not known, leaving it empty");
}
*/
if (indexBeamType[ibeamType] < nBeam-1){
AliDCSArray* beam1 = (AliDCSArray*)beamArray->At(indexBeam+1);
if (beam1){
if (beam1->GetTimeStamp()>timeStart && beam1->GetTimeStamp()<=timeEnd){
timeBeamTypeEnd[ibeamType] = beam1->GetTimeStamp();
TObjString* beamString1 = beam1->GetStringArray(0);
TString beamType1 = beamString1->String();
if (beamType.CompareTo(beamType1.Data(),TString::kIgnoreCase) == -1){
Printf("WARNING: The Beam Type for %s changed from %s to %s during the run at timestamp %f! Setting it to %s and keeping track of the time of the change to set MaxTimeLHCValidity afterward",fgkLHCDataPoints[indexBeamTypeString+ibeamType],beamType.Data(),(beamString1->String()).Data(),timeBeamEnd,beamType.Data());
flagBeamType[ibeamType] = kTRUE;
arrayTimes[3+ibeamType] = timeBeamTypeEnd[ibeamType];
}
}
}
else {
Printf(Form("Invalid pointer for the first entry for Beam Type %s after the first valid one, not considering anything after what has already been found",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
}
}
}
}
delete beamArray;
}
else{
AliError(Form("Beam Type %s array not found in LHC Data file!!!",fgkLHCDataPoints[indexBeamTypeString+ibeamType]));
}
}
Printf(Form("Setting combined beam type to %s",combinedBeamType.Data()));
grpobj->SetBeamType(combinedBeamType);
Printf(Form("Setting combined beam type form LHC to %s",combinedBeamTypeFromLHC.Data()));
grpobj->SetBeamTypeFromLHC(combinedBeamTypeFromLHC);
// Setting minTimeLHCValidity
if (flagBeamMode == kTRUE || flagMachineMode == kTRUE || flagBeam == kTRUE || flagBeamType[0] == kTRUE || flagBeamType[1] == kTRUE){
Double_t minTimeLHCValidity= TMath::MinElement(5,arrayTimes);
Printf("WARNING: Setting MaxTimeLHCValidity to %f",minTimeLHCValidity);
grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
}
/*
// Old way to determine the Maximum Time during which the LHC info is valid
if (timeBeamModeEnd!=0 || timeMachineModeEnd!=0 || timeBeamEnd !=0){
Double_t minTimeLHCValidity;
if (flagBeamMode == kFALSE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam only true --> it is the only one that changed
minTimeLHCValidity = timeBeamEnd;
}
else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode only true
minTimeLHCValidity = timeMachineModeEnd;
}
else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kFALSE){ // flagBeamMode only true
minTimeLHCValidity = timeBeamModeEnd;
}
else if (flagBeamMode == kFALSE && flagMachineMode == kTRUE && flagBeam == kTRUE){ // flagBeam and flagMachineMode only true
minTimeLHCValidity= TMath::Min(timeBeamEnd,timeMachineModeEnd);
}
else if (flagBeamMode == kTRUE && flagMachineMode == kFALSE && flagBeam == kTRUE){ // flagBeam and flagBeamMode only true
minTimeLHCValidity= TMath::Min(timeBeamEnd,timeBeamModeEnd);
}
else if (flagBeamMode == kTRUE && flagMachineMode == kTRUE && flagBeam == kFALSE){ // flagMachineMode and flagBeamMode only true
minTimeLHCValidity= TMath::Min(timeMachineModeEnd,timeBeamModeEnd);
}
else {
Double_t arrayTimes[3] = {timeBeamModeEnd,timeMachineModeEnd,timeBeamEnd};// flagMachineMode and flagBeamMode and flagBeam
minTimeLHCValidity= TMath::MinElement(3,arrayTimes);
}
Printf("WARNING: Setting MaxTimeLHCValidity to %f",minTimeLHCValidity));
grpobj->SetMaxTimeLHCValidity(minTimeLHCValidity);
}
*/
// Data Quality Flag --> storing start and end values of periods within the run during which the value was found to be FALSE
Printf("*************Data Quality Flag ");
TObjArray* dataQualityArray = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[8]);
Int_t nDataQuality = -1;
Double_t timeDataQualityStart = -1; // min validity for Data Quality Flag
Int_t indexDataQuality = -1; // index of first measurement used to set Data Quality Flag
Bool_t foundDataQualityStart = kFALSE; // flag to be set in case an entry for the Data Quality Flag is found before (or at) SOR
if (dataQualityArray){
nDataQuality = dataQualityArray->GetEntries();
if (nDataQuality==0){
Printf("No Data Quality Flag found, leaving it empty");
}
else{
for (Int_t iDataQuality = 0; iDataQuality<nDataQuality; iDataQuality++){
AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
if (dataQuality){
if (dataQuality->GetTimeStamp()<=timeStart && dataQuality->GetTimeStamp()>=timeDataQualityStart){// taking always the very last entry: if two measurements have the same timestamp, the last one is taken
timeDataQualityStart = dataQuality->GetTimeStamp();
indexDataQuality = iDataQuality;
foundDataQualityStart = kTRUE;
}
else{
// we suppose here that if the first measurement is not before SOR, then none will be (they MUST be in chronological order!!!)
break;
}
}
}
if (!foundDataQualityStart){
// The Data Quality Flag should be found and TRUE at the start of the run. For the time being, if it is not found, don't do anything, but it means there is a problem..
Printf("No value for the Data Quality Flag found before start of run, the Data Quality Flag will remain empty");
}
else {
// counting how many FALSE values there are
Bool_t foundEndOfFalse = kFALSE;
Int_t nFalse = 0;
for (Int_t iDataQuality = indexDataQuality; iDataQuality < nDataQuality; iDataQuality ++){
AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
Printf("dataQuality->GetTimeStamp() = %f, timeDataQualityStart = %f, timeEnd = %f", dataQuality->GetTimeStamp(), timeDataQualityStart, timeEnd );
if (dataQuality->GetTimeStamp()>=timeDataQualityStart && dataQuality->GetTimeStamp()<=timeEnd){ // considering only values between the first valid and the end of the run
Bool_t dataQualityFlag = dataQuality->GetBool(0);
Printf("DataQuality = %d (set at %f)",(Int_t)dataQualityFlag,dataQuality->GetTimeStamp());
if (dataQualityFlag != kTRUE){
if (iDataQuality == indexDataQuality) { // the first Data Quality value should be TRUE, but ignoring the problem now...
Printf("ERROR: The first value for the Data Quality MUST be TRUE! Ignoring for now...");
}
nFalse++;
}
}
}
Printf(Form("Found %d FALSE values for the Data Quality Flag",nFalse));
Double_t falses[nFalse*2]; // dimensioning this to the maximum possible, as if each false value was followed by a true one --> the false periods correspond to the number of falses
Int_t iDataQuality = indexDataQuality;
if (nFalse > 0){
Int_t iFalse = 0;
// filling the info about the periods when the flag was set to FALSE
// starting, like for the other DPS, from the measurement closest to SOR (the index of which is iDataQuality)
while (iDataQuality < nDataQuality){
Printf("iDataQuality = %d",iDataQuality);
AliDCSArray* dataQuality = (AliDCSArray*)dataQualityArray->At(iDataQuality);
if (dataQuality->GetTimeStamp()>=timeDataQualityStart && dataQuality->GetTimeStamp()<=timeEnd){ // considering only values between the first valid and the end of the run
Bool_t dataQualityFlag = dataQuality->GetBool(0);
Printf("DataQuality = %d (set at %f)",(Int_t)dataQualityFlag,dataQuality->GetTimeStamp());
if (dataQualityFlag == kTRUE){
// found TRUE value, continuing
iDataQuality++;
continue;
}
else{
/*
// the check was already done before
if (iDataQuality == indexDataQuality) { // the first Data Quality value should be TRUE, but ignoring the problem now...
Printf("ERROR: The first value for the Data Quality MUST be TRUE! Ignoring for now...");
}
*/
falses[iFalse*2] = dataQuality->GetTimeStamp();
foundEndOfFalse = kFALSE;
Int_t iDataQualityNext = iDataQuality+1;
while (iDataQualityNext < nDataQuality){
AliDCSArray* dataQualityNext = (AliDCSArray*)dataQualityArray->At(iDataQualityNext);
if (dataQualityNext->GetTimeStamp()>timeDataQualityStart && dataQualityNext->GetTimeStamp()<=timeEnd && dataQualityNext->GetTimeStamp() > dataQuality->GetTimeStamp()){ // considering only values between the first valid and the end of the run, and subsequent to the current value
Bool_t dataQualityFlagNext = dataQualityNext->GetBool(0);
Printf("DataQualityNext = %d (set at %f)",(Int_t)dataQualityFlagNext,dataQualityNext->GetTimeStamp());
if (dataQualityFlagNext == kTRUE){
// found TRUE value, first FALSE period completed
foundEndOfFalse = kTRUE;
falses[iFalse*2+1] = dataQualityNext->GetTimeStamp();
iFalse++;
break;
}
iDataQualityNext++;
}
}
if (!foundEndOfFalse) {
Printf("Please, note that the last FALSE value lasted until the end of the run");
falses[iFalse*2+1] = timeEnd;
iFalse++;
break;
}
iDataQuality = iDataQualityNext+1;
}
}
}
grpobj->SetNFalseDataQualityFlag(iFalse);
grpobj->SetFalseDataQualityFlagPeriods(falses);
}
}
}
delete dataQualityArray;
}
else{
Printf("ERROR: Data Quality Flag array not found in LHC Data file!!!");
}
// Processing data to go to AliLHCData object
AliLHCData* dt = new AliLHCData(fileName.Data(),timeStart,timeEnd);
// storing AliLHCData in OCDB
if (dt){
Printf(Form("Filled %d records to AliLHCData object",dt->GetData().GetEntriesFast()));
AliCDBMetaData md;
md.SetResponsible("Ruben Shahoyan");
md.SetComment("LHC data from the GRP preprocessor.");
Bool_t result = kTRUE;
AliCDBId id("GRP/GRP/LHCData", 0, AliCDBRunRange::Infinity());
result = cdb->Put(dt, id, &md);
delete dt;
if (!result){
Printf("Problems in storing LHC Data - but not going into Error");
}
}
// processing LHC Phase
TObjArray *beam1phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[4]);
TObjArray *beam2phase = lhcReader.ReadSingleLHCDP(fileName.Data(),fgkLHCDataPoints[5]);
if (beam1phase == 0x0 || beam2phase == 0x0){
Printf(Form("Problems in retrieving LHC Clock data from LHC file"));
return 4;
}
AliLHCClockPhase *phaseObj = ProcessLHCClockPhase(beam1phase,beam2phase,timeEnd);
delete beam1phase;
delete beam2phase;
if (phaseObj){
Printf(Form("LHC Phase found"));
AliCDBMetaData mdPhase;
mdPhase.SetResponsible("Cvetan Cheshkov");
mdPhase.SetComment("LHC Clock Phase");
Bool_t result = kTRUE;
AliCDBId id("GRP/Calib/LHCClockPhase", 0, AliCDBRunRange::Infinity());
result = cdb->Put(phaseObj, id, &mdPhase);
delete phaseObj;
if (!result) return 3;
}
else return 4;
return 0;
}
//_____________________________________________________________________________
void FnormMacro(
const char* filename="../LHC15g.MuMu.1.root",
const char* associatedSimFileName="",
const char* associatedSimFileName2="",
const char* beamYear="PbPb2011",const int DebugLevel =0)
{
// //_____ FNorm
// analysis.ComputeIntFnormFromCounters("",kFALSE);
// //_____
AliAnalysisMuMu ana(filename,associatedSimFileName,associatedSimFileName2,beamYear);
AliLog::SetGlobalDebugLevel(DebugLevel);
if (!ana.OC() || !ana.CC())
{
AliError("No mergeable/counter collection. Consider Upgrade()");
return ;
}
else
{
cout << " ================================================================ " << endl;
cout << " Compute Mean Fnorm From Counters " << endl;
cout << " ================================================================ " << endl;
}
// Get configuration settings
TObjArray* eventTypeArray = ana.Config()->GetListElements(AliAnalysisMuMuConfig::kEventSelectionList,IsSimulation());
TObjArray* triggerMuonArray = ana.Config()->GetListElements(AliAnalysisMuMuConfig::kDimuonTriggerList,IsSimulation());
TObjArray* triggerMBArray = ana.Config()->GetListElements(AliAnalysisMuMuConfig::kMinbiasTriggerList,IsSimulation());
TObjArray* centralityArray = ana.Config()->GetListElements(AliAnalysisMuMuConfig::kCentralitySelectionList, IsSimulation());
// Iterator for loops
TIter nextTriggerMuon(triggerMuonArray);
TIter nextTriggerMB(triggerMBArray);
TIter nextEventType(eventTypeArray);
TIter nextCentrality(centralityArray);
// Strings
TObjString* striggerMuon;
TObjString* striggerMB;
TObjString* seventType;
TObjString* scentrality;
//Pointers on histo
TH1*h(0x0);
TH1*h1(0x0);
TH1*h2(0x0);
Double_t FNormOverStat(0.);
Double_t FNormTotError(0.);
Double_t FNormTotErrorInverse(0.);
Double_t FNormTotErrorSys(0.);
Double_t Norm(1.);
Int_t n =0; //counter
nextEventType.Reset();
// Loop on each envenType (see MuMuConfig)
//==============================================================================
while ( ( seventType = static_cast<TObjString*>(nextEventType())) )
{
AliDebug(1,Form("EVENTTYPE %s",seventType->String().Data()));
nextTriggerMuon.Reset();
// Loop on each Muon trigger (see MuMuConfig)
//==============================================================================
while ( ( striggerMuon = static_cast<TObjString*>(nextTriggerMuon())) )
{
AliDebug(1,Form("-MUON TRIGGER %s",striggerMuon->String().Data()));
nextTriggerMB.Reset();
// Loop on each MB trigger (not the ones in MuMuConfig but the ones set)
//==============================================================================
while ( ( striggerMB = static_cast<TObjString*>(nextTriggerMB())) )
{
AliDebug(1,Form("-- MB PAIRCUT %s",striggerMB->String().Data()));
nextCentrality.Reset();
// Loop on each centrality
//==============================================================================
while ( ( scentrality = static_cast<TObjString*>(nextCentrality()) ) )
{
TString id(Form("/FNORM-%s/%s/%s/PbPb",striggerMuon->String().Data(),seventType->String().Data(),scentrality->String().Data())); // Path where are saved histos in the mergeable collection
h = OC()->Histo(id.Data(),Form("hFNormIntVSrun_%s",striggerMB->String().Data()));
if (!h)
{
AliDebug(1,Form("Can't get histo %s/hFNormIntVSrun_%s",id.Data(),striggerMB->String().Data()));
continue;
}
h1 = OC()->Histo(id.Data(),Form("hFNormInt_%s",striggerMB->String().Data()));
if (!h1)
{
AliDebug(1,Form("Can't get histo %s/hFNormInt_%s",id.Data(),striggerMB->String().Data()));
continue;
}
h2 = OC()->Histo(id.Data(),Form("hFNormIntSys_%s",striggerMB->String().Data()));
if (!h2)
{
AliDebug(1,Form("Can't get histo %s/hFNormIntSys_%s",id.Data(),striggerMB->String().Data()));
continue;
}
cout << Form("Fnorm from %s/%s added",id.Data(),h1->GetName()) << endl;
cout << Form("Fnorm from %s/%s added",id.Data(),h2->GetName()) << endl;
// Normalise with respect to centrality
if (scentrality->String().Contains("V0M_00.00_90.00"))
{
Norm = 1.;
FNormOverStat = FNormOverStat + (Norm*h1->GetBinContent(1)) /(TMath::Power(Norm *h1->GetBinError(1),2.));
FNormTotError = FNormTotError + 1./(TMath::Power(Norm*h1->GetBinError(1),2.));
FNormTotErrorInverse = FNormTotErrorInverse + 1./(TMath::Power(Norm*h1->GetBinError(1),-2.));
FNormTotErrorSys = FNormTotErrorSys + 1./(TMath::Power(Norm*h2->GetBinContent(1),2.));
cout <<"--- Quantities from histogram : " << endl;
cout <<" - Norm = " << Norm << endl;
cout <<" - FNormHisto = " << h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << h2->GetBinContent(1) << endl;
cout <<"--- Quantities (normalized) from histogram: " << endl;
cout <<" - FNormHisto = " << Norm*h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << Norm*h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << Norm*h2->GetBinContent(1) << endl;
cout <<"--- After addition : " << endl;
cout <<" - FNormOverStat = " << FNormOverStat << endl;
cout <<" - FNormTotError = " << FNormTotError << endl;
cout <<" - FNormTotErrorInverse = " << FNormTotErrorInverse << endl;
cout <<" - FNormTotErrorSys = " << FNormTotErrorSys << endl;
}
else if (scentrality->String().Contains("V0M_10.00_50.00"))
{
Norm = (1./0.4)*0.445*0.9;
FNormOverStat = FNormOverStat + (Norm*h1->GetBinContent(1)) /(TMath::Power(Norm *h1->GetBinError(1),2.));
FNormTotError = FNormTotError + 1./(TMath::Power(Norm*h1->GetBinError(1),2.));
FNormTotErrorInverse = FNormTotErrorInverse + 1./(TMath::Power(Norm*h1->GetBinError(1),-2.));
FNormTotErrorSys = FNormTotErrorSys + 1./(TMath::Power(Norm*h2->GetBinContent(1),2.));
cout <<"--- Quantities from histogram : " << endl;
cout <<" - Norm = " << Norm << endl;
cout <<" - FNormHisto = " << h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << h2->GetBinContent(1) << endl;
cout <<"--- Quantities (normalized) from histogram: " << endl;
cout <<" - FNormHisto = " << Norm*h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << Norm*h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << Norm*h2->GetBinContent(1) << endl;
cout <<"--- After addition : " << endl;
cout <<" - FNormOverStat = " << FNormOverStat << endl;
cout <<" - FNormTotError = " << FNormTotError << endl;
cout <<" - FNormTotErrorInverse = " << FNormTotErrorInverse << endl;
cout <<" - FNormTotErrorSys = " << FNormTotErrorSys << endl;
}
else if (scentrality->String().Contains("V0M_00.00_07.50"))
{
Norm = (1./0.075)*0.443*0.9;
FNormOverStat = FNormOverStat + (Norm*h1->GetBinContent(1)) /(TMath::Power(Norm *h1->GetBinError(1),2.));
FNormTotError = FNormTotError + 1./(TMath::Power(Norm*h1->GetBinError(1),2.));
FNormTotErrorInverse = FNormTotErrorInverse + 1./(TMath::Power(Norm*h1->GetBinError(1),-2.));
FNormTotErrorSys = FNormTotErrorSys + 1./(TMath::Power(Norm*h2->GetBinContent(1),2.));
cout <<"--- Quantities from histogram : " << endl;
cout <<" - Norm = " << Norm << endl;
cout <<" - FNormHisto = " << h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << h2->GetBinContent(1) << endl;
cout <<"--- Quantities (normalized) from histogram: " << endl;
cout <<" - FNormHisto = " << Norm*h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << Norm*h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << Norm*h2->GetBinContent(1) << endl;
cout <<"--- After addition : " << endl;
cout <<" - FNormOverStat = " << FNormOverStat << endl;
cout <<" - FNormTotError = " << FNormTotError << endl;
cout <<" - FNormTotErrorInverse = " << FNormTotErrorInverse << endl;
cout <<" - FNormTotErrorSys = " << FNormTotErrorSys << endl;
}
else
{
AliError("Check this method for centrality selection !");
return;
}
n++;
}
}
}
}
cout << "Mean FNorm computed from " << n <<" results = " << FNormOverStat/FNormTotError << " +/- " <<
TMath::Sqrt(FNormTotErrorInverse) << " (stat) +/-" << TMath::Sqrt(FNormTotErrorSys) << " (sys) " <<endl;
delete triggerMuonArray ;
delete triggerMBArray ;
delete eventTypeArray ;
delete centralityArray ;
}
AliAnalysisTaskPHOSNeutralMeson* AddTaskAliAnalysisTaskPHOSNeutralMeson(
TString taskName,
TString collisionCandidates,
Bool_t usePhysicsSelection,
Bool_t usePHOSTender,
Int_t clusterMinCells,
Float_t clusterMinE,
Float_t clusterMinM02,
Float_t distToBadCellOnCellLevel,
Float_t distToBadCell,
Bool_t doTimingCut,
Float_t timingCutMin,
Float_t timingCutMax,
Float_t zVertexCut,
TString recalOption,
Double_t recalFactorMod1,
Double_t recalFactorMod2,
Double_t recalFactorMod3,
TString mPtHistoMode,
Bool_t applyBadMap_manually,
Bool_t useIsVertexSelected2013pA,
TString badMapName = "defaultTenderBM",
Bool_t fillMCHistos = kFALSE,
Bool_t analyseAddedSignals = kFALSE,
TString mcParticleToAnalyse = "pi0",
Double_t expoPara1 = 0.0,
Double_t expoPara2 = 0.0,
Double_t expoPara3 = 0.0,
Double_t expoPara4 = 0.0,
TString additionalFileNameString = "",
Bool_t fillHitMapsAddedS = kFALSE,
Bool_t fillDecayInfoAddedS = kFALSE,
Char_t *suffix = "")
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskAliFraNeutralMeson", "No analysis manager to connect to.");
return NULL;
}
// ******************************************************
// ***** SETTINGS ***** ***** ***** ***** ***** *****
// for possible bad maps see alien:///alice/cern.ch/user/m/mhecker/BadMaps/:
// BM13c_6_15_allMd_all_noMod2 = BM_d_13c_22_6_2015_allMod_allMod2Off.root (old name)
// defaultTenderBM (switches off SetForceUsingBadMap for Tender!)
// BM_d_13c_22_6_2015_allMod_all.root BM_d_13c_28_4_15
Bool_t DoDistToBadCell = false;
if (distToBadCell > 0.00001) DoDistToBadCell = true;
Bool_t DoDistToBadCellOnCellLevel = false;
if (distToBadCellOnCellLevel > 0) DoDistToBadCellOnCellLevel = true;
// ***** ***** ***** ***** ***** ***** ***** ***** *****
// ******************************************************
TString ContName = "contPHOSNeutralMeson";
TString combinedName;
combinedName.Form("%s%s",ContName.Data(), suffix);
TString pathToBadMap;
if (badMapName !="defaultTenderBM") {
gSystem->Exec(Form("alien_cp alien:///alice/cern.ch/user/m/mhecker/BadMaps/%s.root .",badMapName.Data()));
pathToBadMap = Form("%s/",gSystem->pwd());
pathToBadMap += badMapName;
pathToBadMap += ".root";
}
// **** PHOS TENDER ***********
if(usePHOSTender) {
cout<<"###### PHOS TENDER ! ######"<<endl;
// ~~~~~~~~~~~~~ Loading Tender for AODs ~~~~~~~~~~~~~~~~~~
Int_t tenderPassNumber = 1; // does not matter (just has to be >= 0). tender then finds the correct pass itself
gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_PbPb/AddAODPHOSTender.C");
AliPHOSTenderTask *tenderPHOS = AddAODPHOSTender("PHOSTenderTask","PHOStender","",tenderPassNumber);
AliPHOSTenderSupply *PHOSSupply = tenderPHOS->GetPHOSTenderSupply();
if(badMapName !="defaultTenderBM") {
printf("Setting Tender-BadMap to private BM \n");
PHOSSupply->ForceUsingBadMap(pathToBadMap.Data());
} else printf("Running Tender with its default BadMap \n");
}
// ********** PHYSICS SELECTION ******************
if(usePhysicsSelection) {
gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
printf(" ********* AliPhysicsSelectionTask configured ********* ");
}
// Initialize Task
AliAnalysisTaskPHOSNeutralMeson *task = new AliAnalysisTaskPHOSNeutralMeson(taskName.Data());
// Set variables for Outputfile Name
if(usePHOSTender) {
task->SetSelectedSelectedTenderForOutputName("PHSTndr");
} else {
task->SetSelectedSelectedTenderForOutputName("noTndr");
}
if(usePhysicsSelection) {
task->SetSelectedPhysSelectionForOutputName("AliPhySl");
} else {
task->SetSelectedPhysSelectionForOutputName("noPhySl");
}
task->SetUsedBadmapForOutputName(badMapName);
// ******* SET BAD MAP ******************
task->SetApplyBadMapManually(applyBadMap_manually);
if(applyBadMap_manually) {
if (badMapName == "defaultTenderBM") AliError("Cannot apply default tender bad map in task, now applying empty bad map. Specify own bad map to fix it.");
else {
TFile *fBadMap = TFile::Open(pathToBadMap.Data());
if(fBadMap->IsOpen()){
printf("\n\n...Adding PHOS bad channel map (MANUALY) \n") ;
gROOT->cd();
Char_t key[55] ;
for(Int_t mod=1;mod<4; mod++){
sprintf(key,"PHOS_BadMap_mod%d",mod) ;
TH2I * h = (TH2I*)fBadMap->Get(key) ;
if(h)
task->SetPHOSBadMap(mod,h) ;
}
fBadMap->Close() ;
}
}
}
// ***** END OF SET BAD MAP ***************
//~~~~~~~ Geometry ~~~~~~~~~~~~~~
//task->SetEtaAccMinMax(-0.14, 0.14);
//task->SetPhiAccMinMax(-1.72568, -0.72635);
task->SetEtaAccMinMax(-0.13, 0.13); // Set Min and Max of eta for PHOS acceptance (MC)
Double_t phiMin = 260 * (TMath::Pi()/180);
Double_t phiMax = 320 * (TMath::Pi()/180);
task->SetPhiAccMinMax(phiMin,phiMax); //60 degrees (in rad)
//~~~~~~~~ MC related ~~~~~~~~~~~~~
task->SetfFillMCHistos(fillMCHistos);
task->SetAnalyseAddedSignals(analyseAddedSignals);
//task->SetFillFeedDownHistos(true);
task->SetAnalyseMCPi0OrEta(mcParticleToAnalyse); //pi0 eta both
task->SetExponentialParameters(expoPara1, expoPara2, expoPara3, expoPara4); //for weighing added signals
task->SetAdditionalFileNameString(additionalFileNameString); //String appears at the end of the filname.
task->SetFillClusterHitmapsAddedSignals(fillHitMapsAddedS);
task->SetFillDecayPhotonInfoAddedSig(fillDecayInfoAddedS);
task->SetFillNDaughtersVsPtAndR(kFALSE); //implement bool to list of arguments of AddTask if needed
task->SetFillMPtForSingleOrMultContrClus(kFALSE); //implement bool to list of arguments of AddTask if needed
// ~~~~~~ Event Cuts ~~~~~~~~~~~~~
task->SetUseOnlyCINT1events(kFALSE);
task->SetDoZvertexCut(kTRUE);
task->SetUseIsVertexSelected2013pA(useIsVertexSelected2013pA);
task->SetZvertexCut(zVertexCut); // 10.0
// ~~~~~~ Cluster Cuts ~~~~~~~~~~~
task->SetClusterMinCells(clusterMinCells); //3
task->SetClusterMinE(clusterMinE); //0.3 GeV
task->SetClusterMinM02(clusterMinM02); //0.2
task->SetDoTimingCut(doTimingCut); //for MC: false
task->SetTimingCutMinMax(timingCutMin, timingCutMax); //-0.10e-6,0.10e-6
task->SetDoDistToBadCellCut(DoDistToBadCell);
task->SetDistToBadCell(distToBadCell); // [cm]
task->SetDoDistToBadCellCutOnCellLevel(DoDistToBadCellOnCellLevel);
task->SetDistToBadCellOnCellLevel(distToBadCellOnCellLevel);
// ~~~~~~~~ Filling options ~~~~~~
task->SetFillCellIdVsE(false); //Neccessary for QA (BadMap) (increases Outputfile-size)
task->SetFillTimingHistos(true); //Neccessary to determine timing cut values.
task->SetFillClusterHitmaps(true); // To check the BadMaps and cluster distributions
if (mPtHistoMode != "nrmlMptHst") {
if (mPtHistoMode == "hMPTvsMod") task->SetFillhMassPtModules(true); // For module-wise pi0 analysis
else if (mPtHistoMode == "hMPTvsTim") task->SetFillhMassPtTiming(true); // For calculation of timing efficiency
else if (mPtHistoMode == "hMPTnewAsy") task->SetFillNewAsymmClasses(true);
else mPtHistoMode = "nrmlMptHst"; // if none of the implemented (above) modes is set, the string is set to default
}
task->SetFillNTupelClusterEnergy(false); //Neccesary to calculate module dependent energy recal factors
// ~~~~ recalibration options ~~~~
//task->SetDoClusterEnergyRecalibration(false);
task->SetRecalibrationOption(recalOption); // look in .cxx for possible options
task->SetRecalibrateModuleWise(false);
task->SetModuleWiseRecalibrationFactors(recalFactorMod1,recalFactorMod2,recalFactorMod3);
//task->SetModuleWiseRecalibrationFactors(0.9942,0.9822,1.0072); //pp
// SelectCollisionCandidates according to collisionCandidates set in Settings (line 14)
if(collisionCandidates == "kPHI7") {
task->SelectCollisionCandidates(AliVEvent::kPHI7);
task->SetSelectedCollCandidatesForOutputName("kPHI7");
}
if(collisionCandidates == "kINT7") {
task->SelectCollisionCandidates(AliVEvent::kINT7);
task->SetSelectedCollCandidatesForOutputName("kINT7");
}
if(collisionCandidates == "kAny") {
task->SelectCollisionCandidates(AliVEvent::kAny);
task->SetSelectedCollCandidatesForOutputName("kAny");
}
if(collisionCandidates == "kMB") {
task->SelectCollisionCandidates(AliVEvent::kMB);
task->SetSelectedCollCandidatesForOutputName("kMB");
}
if(collisionCandidates == "kERT1") {
task->SelectCollisionCandidates(AliVEvent::kERT1);
task->SetSelectedCollCandidatesForOutputName("kERT1");
}
// ********************* IMPORTANT: ****************************
// The OutputfileName cannot be to long!
// The Gridjobs crash in a ERROR_RE if it is too long
// It has been successfully tested with a filename length of 135 symbols
// *************************************************************
// make OutPutFileName after making all Settings
TString OutPutFileName = task->MakeOutputFileName();
mgr->AddTask(task);
AliAnalysisDataContainer *coutput0 = mgr->CreateContainer(Form("%s:%s", ContName.Data(),OutPutFileName.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:dirNeutralMeson", mgr->GetCommonFileName()));
mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
mgr->ConnectOutput(task,1,coutput0);
return task;
}
void CreateChain(const anaModes mode, TChain * chain){
//Fills chain with data
TString ocwd = gSystem->WorkingDirectory();
//-----------------------------------------------------------
//Analysis of CAF data locally and with PROOF
//-----------------------------------------------------------
if(mode ==mPROOF || mode ==mLocalCAF){
// Chain from CAF
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
// The second parameter is the number of input files in the chain
chain = CreateESDChain("ESD12001.txt", 5);
}
//---------------------------------------
//Local files analysis
//---------------------------------------
else if(mode == mLocal){
//If you want to add several ESD files sitting in a common directory INDIR
//Specify as environmental variables the directory (INDIR), the number of files
//to analyze (NFILES) and the pattern name of the directories with files (PATTERN)
if(gSystem->Getenv("INDIR"))
kInDir = gSystem->Getenv("INDIR") ;
else cout<<"INDIR not set, use default: "<<kInDir<<endl;
if(gSystem->Getenv("PATTERN"))
kPattern = gSystem->Getenv("PATTERN") ;
else cout<<"PATTERN not set, use default: "<<kPattern<<endl;
if(gSystem->Getenv("NFILES"))
kFile = atoi(gSystem->Getenv("NFILES")) ;
else cout<<"NFILES not set, use default: "<<kFile<<endl;
//Check if env variables are set and are correct
if ( kInDir && kFile) {
printf("Get %d files from directory %s\n",kFile,kInDir);
if ( ! gSystem->cd(kInDir) ) {//check if ESDs directory exist
printf("%s does not exist\n", kInDir) ;
return ;
}
cout<<"INDIR : "<<kInDir<<endl;
cout<<"NFILES : "<<kFile<<endl;
cout<<"PATTERN : " <<kPattern<<endl;
TString datafile="";
if(kInputData == "ESD") datafile = "AliESDs.root" ;
else if(kInputData == "AOD") datafile = "AliAOD.root" ;
else if(kInputData == "MC") datafile = "galice.root" ;
//Loop on ESD files, add them to chain
Int_t event =0;
Int_t skipped=0 ;
char file[120] ;
for (event = 0 ; event < kFile ; event++) {
sprintf(file, "%s/%s%d/%s", kInDir,kPattern,event,datafile.Data()) ;
TFile * fESD = 0 ;
//Check if file exists and add it, if not skip it
if ( fESD = TFile::Open(file)) {
if ( fESD->Get(kTreeName) ) {
printf("++++ Adding %s\n", file) ;
chain->AddFile(file);
}
}
else {
printf("---- Skipping %s\n", file) ;
skipped++ ;
}
}
printf("number of entries # %lld, skipped %d\n", chain->GetEntries(), skipped*100) ;
}
else {
TString input = "AliESDs.root" ;
cout<<">>>>>> No list added, take a single file <<<<<<<<< "<<input<<endl;
chain->AddFile(input);
}
}// local files analysis
//------------------------------
//GRID xml files
//-----------------------------
else if(mode == mGRID){
//Get colection file. It is specified by the environmental
//variable XML
if(gSystem->Getenv("XML") )
kXML = gSystem->Getenv("XML");
else
sprintf(kXML, "collection.xml") ;
if (!TFile::Open(kXML)) {
printf("No collection file with name -- %s -- was found\n",kXML);
return ;
}
else cout<<"XML file "<<kXML<<endl;
//Load necessary libraries and connect to the GRID
gSystem->Load("libNetx") ;
gSystem->Load("libRAliEn");
TGrid::Connect("alien://") ;
//Feed Grid with collection file
//TGridCollection * collection = (TGridCollection*)gROOT->ProcessLine(Form("TAlienCollection::Open(\"%s\", 0)", kXML));
TGridCollection * collection = (TGridCollection*) TAlienCollection::Open(kXML);
if (! collection) {
AliError(Form("%s not found", kXML)) ;
return kFALSE ;
}
TGridResult* result = collection->GetGridResult("",0 ,0);
// Makes the ESD chain
printf("*** Getting the Chain ***\n");
for (Int_t index = 0; index < result->GetEntries(); index++) {
TString alienURL = result->GetKey(index, "turl") ;
cout << "================== " << alienURL << endl ;
chain->Add(alienURL) ;
}
}// xml analysis
gSystem->ChangeDirectory(ocwd.Data());
}
//_____________________________________________________________________
/// Fills chain with data files paths.
//_____________________________________________________________________
void CreateChain(const anaModes mode, TChain * chain){//, TChain * chainxs){
//Fills chain with data
TString datafileName="";
if(kInputData == "ESD") datafileName = "AliESDs.root" ;
else if(kInputData == "AOD") datafileName = "AliAOD.root" ;
else if(kInputData == "MC") datafileName = "galice.root" ;
TString ocwd = gSystem->WorkingDirectory();
//---------------------------------------
// Local files analysis
//---------------------------------------
if(mode == mLocal)
{
//If you want to add several ESD files sitting in a common directory INDIR
//Specify as environmental variables the directory (INDIR), the number of files
//to analyze (NFILES) and the pattern name of the directories with files (PATTERN)
cout<<"INDIR : "<<kInDir<<endl;
cout<<"NFILES : "<<kFile<<endl;
cout<<"PATTERN: " <<kPattern<<endl;
//Loop on ESD files, add them to chain
TString FileName ;
for (Int_t iFile = 0 ; iFile < kFile ; iFile++) {
FileName = Form("%s/%s%d/%s", kInDir,kPattern,iFile,datafileName.Data()) ;
//cout << "FileName: " << FileName <<endl ;
TFile * dataFile = 0 ;
//Check if file exists and add it, if not skip it
if ( dataFile = TFile::Open(FileName.Data())) {
if ( dataFile->Get(kTreeName) ) {
Int_t nEventsPerFile = ((TTree*) dataFile->Get(kTreeName)) ->GetEntries();
printf(" ++++ Adding %s, with %d events \n", FileName.Data(), nEventsPerFile) ;
chain->AddFile(FileName);
}
}
}
printf("number of entries # %lld \n", chain->GetEntries()) ;
}// local files analysis
//------------------------------
//GRID xml files
//-----------------------------
else if(mode == mGRID)
{
//Load necessary libraries and connect to the GRID
gSystem->Load("libNetx") ;
gSystem->Load("libRAliEn");
TGrid::Connect("alien://") ;
//Feed Grid with collection file
//TGridCollection * collection = (TGridCollection*)gROOT->ProcessLine(Form("TAlienCollection::Open(\"%s\", 0)", kXML));
TGridCollection * collection = (TGridCollection*) TAlienCollection::Open(kXML);
if (! collection) {
AliError(Form("%s not found", kXML)) ;
return kFALSE ;
}
TGridResult* result = collection->GetGridResult("",0 ,0);
// Makes the ESD chain
printf("*** Getting the Chain ***\n");
Int_t nEventsPerFile = 0;
for (Int_t index = 0; index < result->GetEntries(); index++) {
TString alienURL = result->GetKey(index, "turl") ;
cout << "================== " << alienURL << endl ;
chain->Add(alienURL) ;
}
}// xml analysis
gSystem->ChangeDirectory(ocwd.Data());
}
