* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-const int c_array_size = 15;
+const int c_array_size = 29; // RRnewTOF c_array_size was increased to 27 in order to put a TOF PID cut on electrons
class AliAnalysisDataContainer;
class AliGammaConversionHistograms;
Bool_t kGCrunNeutralMeson = kTRUE;
Bool_t kGCrunJet = kFALSE;
Bool_t kGCrunChic = kFALSE;
+Bool_t kGCrunDalitz = kFALSE;
Bool_t kGCrunCF = kFALSE;
Bool_t kGCcalculateBackground = kTRUE;
Bool_t kGCdoNeutralMesonV0MCCheck =kFALSE;
Bool_t kGCrunOmegaMeson = kFALSE;
Bool_t kGCrunRES = kFALSE;
Bool_t kGCRecalculateV0ForGamma = kFALSE;
+Bool_t kGCUseTrackMultiplicityForBG = kTRUE;
+Bool_t kGCMoveParticlesAccordingToVertex = kFALSE;
+Bool_t kGCLowMemoryConsumption = kFALSE;
+Bool_t kGCApplyChi2Cut = kFALSE;
+
+Bool_t kGCUseRotationMethodInBG=kTRUE;
+Int_t kGCnDegreeRotationPMForBG=15;
+Int_t kGCnumberOfRotationEventsForBG=15;
+Bool_t kGCdoBGProbability=kFALSE;
//Svein
Bool_t kGCRunGammaJetTask = kFALSE;
/** ---------------------------------- define cuts here ------------------------------------*/
-TString kGCAnalysisCutSelectionId="900356200010030"; // do not change here, use -set-cut-selection in argument instead
+TString kGCAnalysisCutSelectionId="90035620401003321022000000090"; // do not change here, use -set-cut-selection in argument instead
-Int_t kGCNEventsForBGCalculation=10;
+Int_t kGCNEventsForBGCalculation=20;
Int_t kGCpidOfNegativeTrack=11;
Int_t kGCpidOfPositiveTrack=-11;
Double_t kGCmaxVertexZ = 10.;
Double_t kGCmaxRCut = 180.;
+Double_t kGCminRCut = 2.8;
Double_t kGCetaCut = 0.9;
Double_t kGCptCut = 0.02;
Double_t kGCsingleptCut = 0.02;
Double_t kGCmaxZCut = 240.;
Double_t kGCminClsTPCCut= 0.;
+Double_t kGCminClsTPCCutToF= 0.;
Double_t kGCchi2CutConversion = 30.;
Double_t kGCchi2CutMeson = 50.;
Double_t kGCalphaCutMeson = 0.7;
Double_t kGCalphaMinCutMeson = 0.0;
+Double_t kGCrapidityCutMeson = 0.9;
Double_t kGCLineCutZRSlope = tan(2*atan(exp(-kGCetaCut)));
Double_t kGCLineCutZValue = 7.;
Double_t kGCminOpeningAngleGhostCut = 0.005;
+Bool_t kGCRemovePileUp = kFALSE;
+
+Bool_t kGCSelectV0AND = kFALSE;
+Bool_t kGCUseMultiplicity = kFALSE;
+Int_t kGCUseMultiplicityBin=0;
+
+Int_t kGCIsHeavyIon = 0;
+Int_t kGCUseCentrality = 0;
+Int_t kGCUseCentralityBin = 0;
+Int_t kGCUseCorrectedTPCClsInfo = 0;
+Int_t kGCUseMCPSmearing=0;
+
+Double_t kGCPBremSmearing=1.;
+Double_t kGCPSigSmearing=0.;
+Double_t kGCPSigSmearingCte=0.;
+
+/** ---------------------------------- define pi0 dalitz cuts here ------------------------------------*/
+
+Bool_t kGCRunStandalone = kTRUE;
+Bool_t kGCUseBayesPID = kFALSE;
+Bool_t kGCUseTrackIndexCut = kTRUE;
+Bool_t kGCUsePsiPairCut = kTRUE;
+Bool_t kGCUseMassCut = kFALSE;
+Bool_t kGCUseGammaCut = kFALSE;
+Bool_t kGCReadMagFieldSign = kTRUE;
+Bool_t kGCUseAliKF = kFALSE;
+
+Double_t kGCPsiPairCut = 0.45;
+Double_t kGCDeltaPhiCutMin = 0.;
+Double_t kGCDeltaPhiCutMax = 0.12;
+Double_t kGCMassCutMin = 0.;
+Double_t kGCMassCutMax = 0.1;
+Double_t kGCNSigmaBelowElecTPCbethe = -2.;
+Double_t kGCNSigmaAboveElecTPCbethe = 3.;
+Double_t kGCNSigmaAbovePionTPCbethe = 2.;
+Double_t kGCNSigmaAboveKaonTPCbethe = 2.;
+Double_t kGCNSigmaAboveProtonTPCbethe = 2.;
+
+Int_t kGCTrkSelectionCriteria = 1; // kITSsaTrack=0, kGlobalTrack=1, kITSsaGlobalTrack=2
+// NOTE: for details in the track cuts and defined histograms see AddGammaConvDalitz.C
+
/** ----------------------------------end define cuts here----------------------------------*/
/** -------------------------------- Phi/R Mapping ---------------------------------------*/
/** ------------------------------- end Phi/R Mapping ------------------------------------*/
Bool_t kGCdoOwnXYZCalculation = kFALSE;
+Bool_t kGCdoConstructGamma = kFALSE;
/** -------------AOD stuff ---------------------------------------------------------------*/
TString kGCDeltaAODFilename = "AliAODGammaConversion.root"; //If empty, writes to standard common aod file.
-Bool_t kGCWriteAOD =kTRUE;
+Bool_t kGCWriteAOD =kTRUE; // Turn on AOD
+Bool_t kGCForceAOD = kFALSE; // Call AliAnalysisManager::SetFillAOD(kTRUE) every ESD event.
+
/** ------------------- define which histograms to plot here --------------------------------*/
/** NB: to change the bin numbers, see below the histogram flags */
+Bool_t kGCplotEventQuality = kTRUE;
+
+
+// MC GAMMA DECAY PLOTS
+Bool_t kGCplotMCGammaFromDecay = kTRUE;
// NEUTRAL MESON PLOTS
Bool_t kGCplotMCConversionR = kTRUE;
Bool_t kGCplotMCConversionZR = kTRUE;
Bool_t kGCplotMCMotherPtvsRapidConvGammaWithinAcceptance = kTRUE;
Bool_t kGCplotMCMotherSpectra = kTRUE;
+Bool_t kGCplotMCPhysicalPrimaryChargedPt = kTRUE;
+
Bool_t kGCplotMCPi0Eta = kTRUE;
Bool_t kGCplotMCPi0Rapid = kTRUE;
+Bool_t kGCplotMCPi0PtvsRapid = kTRUE;
Bool_t kGCplotMCPi0Phi = kTRUE;
Bool_t kGCplotMCPi0Pt = kTRUE;
Bool_t kGCplotMCPi0PtFiducial = kTRUE;
Bool_t kGCplotMCPi0Energy = kFALSE;
Bool_t kGCplotMCPi0Mass = kTRUE;
Bool_t kGCplotMCPi0Alpha = kTRUE;
+Bool_t kGCplotMCEtaAlpha = kTRUE;
Bool_t kGCplotMCPi0OpeningAngle = kTRUE;
Bool_t kGCplotMCPi0R = kTRUE;
Bool_t kGCplotMCPi0ZR = kFALSE;
Bool_t kGCplotMCEtaEta = kTRUE;
Bool_t kGCplotMCEtaRapid = kTRUE;
+Bool_t kGCplotMCEtaPtvsRapid = kTRUE;
Bool_t kGCplotMCEtaPhi = kTRUE;
Bool_t kGCplotMCEtaPt = kTRUE;
Bool_t kGCplotMCEtaEnergy = kFALSE;
Bool_t kGCplotESDConversionR = kTRUE;
Bool_t kGCplotESDConversionZR = kTRUE;
Bool_t kGCplotESDConversionXY = kTRUE;
+Bool_t kGCplotESDConversionXYBeamPipe = kTRUE;
+Bool_t kGCplotESDConversionRPhiBeamPipe = kTRUE;
Bool_t kGCplotESDConversionOpeningAngle = kTRUE;
Bool_t kGCplotESDConvGammaCosPointingAngle = kTRUE;
Bool_t kGCplotESDConvGammaDcaDaugthers = kTRUE;
Bool_t kGCplotESDEPhi = kTRUE;
Bool_t kGCplotESDENTPCClusters = kTRUE;
Bool_t kGCplotESDENITSClusters = kTRUE;
+Bool_t kGCplotESDENTPCClustersToFP = kTRUE;
+Bool_t kGCplotESDENTPCClustersToFR = kTRUE;
+Bool_t kGCplotESDETPCchi2 = kTRUE;
Bool_t kGCplotESDPEnergy = kFALSE;
Bool_t kGCplotESDPPt = kTRUE;
Bool_t kGCplotESDPEta = kTRUE;
Bool_t kGCplotESDPPhi = kTRUE;
-Bool_t kGCplotESDPNTPCClusters = kTRUE;
+Bool_t kGCplotESDPNTPCClusters = kTRUE;
Bool_t kGCplotESDPNITSClusters = kTRUE;
+Bool_t kGCplotESDPNTPCClustersToFP = kTRUE;
+Bool_t kGCplotESDPNTPCClustersToFR = kTRUE;
+Bool_t kGCplotESDPTPCchi2 = kTRUE;
Bool_t kGCplotESDConvGammaEnergy = kFALSE;
Bool_t kGCplotESDConvGammaPt = kTRUE;
Bool_t kGCplotESDConvGammaPtvsEta = kTRUE;
Bool_t kGCplotESDConvGammaPtvsChi2 = kTRUE;
Bool_t kGCplotESDConvGammaEtavsChi2 = kTRUE;
+Bool_t kGCplotESDConvGammaPtvsTOF = kTRUE;
Bool_t kGCplotESDTrueDalitzContaminationR = kTRUE;
+Bool_t kGCplotESDTruePi0DalitzContaminationR = kTRUE;
+Bool_t kGCplotESDTrueEtaDalitzContaminationR = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialContaminationR = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialElecContaminationR = kTRUE;
+Bool_t kGCplotESDTrueHadronicContaminationR = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialContaminationPt = kTRUE;
+Bool_t kGCplotESDTrueCombinatorialElecContaminationPt = kTRUE;
+Bool_t kGCplotESDTrueHadronicContaminationPt = kTRUE;
+
+
+Bool_t kGCplotESDTrueBackground = kTRUE;
Bool_t kGCplotESDTrueConvGammaEnergy = kFALSE;
Bool_t kGCplotESDTrueConvGammaPt = kTRUE;
Bool_t kGCplotESDTrueConvGammaEta = kTRUE;
Bool_t kGCplotESDTrueConversionMCZR = kFALSE;
Bool_t kGCplotESDTrueConversionMCXY = kFALSE;
+Bool_t kGCplotESDNoCutAllV0Pt = kTRUE;
Bool_t kGCplotESDNoCutConvGammaEnergy = kFALSE;
Bool_t kGCplotESDNoCutConvGammaPt = kTRUE;
Bool_t kGCplotESDNoCutConvGammaEta = kTRUE;
Bool_t kGCplotESDCutKaonRejectionLowP =kTRUE;
Bool_t kGCplotESDCutQtGammaSelection=kTRUE;
Bool_t kGCplotESDCutR = kTRUE;
+Bool_t kGCplotESDCutMinR = kTRUE;
Bool_t kGCplotESDCutLine = kTRUE;
Bool_t kGCplotESDCutZ = kTRUE;
Bool_t kGCplotESDCutMinClsTPC = kTRUE;
+Bool_t kGCplotESDCutMinClsTPCToF = kTRUE;
+Bool_t kGCplotESDCutPhotonAsymmetry = kTRUE;
Bool_t kGCplotESDGoodV0s = kTRUE;
Bool_t kGCplotESDAllV0s = kTRUE;
Bool_t kGCplotESDAllV0sCurrentFinder = kTRUE;
/** ----------- Define the binning for the different plot types here -------------------------*/
+// Number of V0s-plot
+Int_t kGCnXBinsNV0 = 1000;
+Double_t kGCfirstXBinNV0 = -0.5;
+Double_t kGClastXBinNV0 = 999.5;
+
+
+// Number of ESD track-Plot
+Int_t kGCnXBinsESDtrk = 10000;
+Double_t kGCfirstXBinESDtrk= -0.5;
+Double_t kGClastXBinESDtrk = 9999.5;
+
+
+//EventQuality-plot
+Int_t kGCnXBinsEvtQ= 9;
+Double_t kGCfirstXBinEvtQ=-1.5;
+Double_t kGClastXBinEvtQ=7.5;
+
//R-plots
Int_t kGCnXBinsR = 400;
Double_t kGCfirstXBinR = 0.;
Double_t kGCfirstYBinXY = -200.;
Double_t kGClastYBinXY = 200.;
+//XY-plots-BeamPipe
+Int_t kGCnXBinsXYBP = 200;
+Double_t kGCfirstXBinXYBP = -10.;
+Double_t kGClastXBinXYBP = 10.;
+Int_t kGCnYBinsXYBP = 200;
+Double_t kGCfirstYBinXYBP = -10.;
+Double_t kGClastYBinXYBP = 10.;
+
+//Rphi-plots-BeamPipe
+Int_t kGCnXBinsRPhiBP = 200;
+Double_t kGCfirstXBinRPhiBP = -TMath::Pi();
+Double_t kGClastXBinRPhiBP = TMath::Pi();
+Int_t kGCnYBinsRPhiBP = 200;
+Double_t kGCfirstYBinRPhiBP = 0.;
+Double_t kGClastYBinRPhiBP = 10.;
+
+
+
//OpenAngle-plots
Int_t kGCnXBinsOpeningAngle = 400;
Double_t kGCfirstXBinOpeningAngle = 0.;
Double_t kGCfirstXBinPt = 0.;
Double_t kGClastXBinPt = 50.;
+//TOF-plots RRnewTOF start /////////////////////////////////////////
+Int_t kGCnXBinsTOFsignal = 500;
+Double_t kGCfirstXBinTOFsignal = -10000.;
+Double_t kGClastXBinTOFsignal = 40000.;
+// end RRnewTOF ////////////////////////////////////////////////////
+
//Eta-plots
Int_t kGCnXBinsEta = 40;
Double_t kGCfirstXBinEta = -2.;
Double_t kGCfirstXBinNITSClusters = -0.5;
Double_t kGClastXBinNITSClusters = 6.5;
+//TPCcluster to Findable-plots
+Int_t kGCnYBinsClsToF = 200;
+Double_t kGCfirstYBinClsToF = 0.;
+Double_t kGClastYBinClsToF = 2.0;
+
+//TPCchi2 -plots
+Int_t kGCnXBinsTPCchi2 = 100;
+Double_t kGCfirstXBinTPCchi2 = 0.;
+Double_t kGClastXBinTPCchi2 = 10;
//Mapping-plots
Double_t kGClastXBinGammaNDF = 10.;
//Spectra-plots
-Int_t kGCnXBinsSpectra = 1000;
+Int_t kGCnXBinsSpectra = 500;
Double_t kGCfirstXBinSpectra = 0.;
Double_t kGClastXBinSpectra = 1.;
Int_t kGCnYBinsSpectra = 250;
Double_t kGCfirstXBinTrackLength = 0;
Double_t kGClastXBinTrackLength = 500;
+/////////Pi0 Dalitz decay AnalysisTask ///////////////////////////////////
+
+Int_t kGCnXBinsDalitzMass = 4000;
+Double_t kGCfirstXBinDalitzMass = 0.;
+Double_t kGClastXBinDalitzMass = 4.;
+
+Int_t kGCnXBinsPi0DalitzMass = 4000;
+Double_t kGCfirstXBinPi0DalitzMass = 0.;
+Double_t kGClastXBinPi0DalitzMass = 4.;
+
/////////Chic_Analysis///////////////////////////////////
Int_t kGCnXBinsEPt = 1000;
Double_t kGCfirstXBinEPt = 0.;
Double_t kGCPIDnSigmaAbovePionLine=0;
Double_t kGCPIDMinPnSigmaAbovePionLine=1.;
Double_t kGCPIDMaxPnSigmaAbovePionLine=3.;
+Double_t kGCPIDnSigmaAbovePionLineHighPt=0;
+
+Bool_t kGCuseTOFpid = kFALSE; // RRnewTOF start //////////
+Double_t kGCtofPIDnSigmaBelowElectronLine=-100;
+Double_t kGCtofPIDnSigmaAboveElectronLine=100; // RRnewTOF end
/**------- Flag to apply rejection at LowP of Kaons, protons , pions------------*/
Bool_t kGCdoPionRejectionLowP=kTRUE;
Bool_t kGCdoQtGammaSelection=kTRUE;
Double_t kGCQtMax=100.;
+Bool_t kGCdoHighPtQtGammaSelection=kFALSE; // RRnew
+Double_t kGCHighPtQtMax=100.; // RRnew
+Double_t kGCPtBorderForQt=100.; // RRnew
+/**----Flag to apply cut on the photon asymmetry -----*/
+Bool_t kGCdoPhotonAsymmetryCut= kTRUE;
+Double_t kGCMinPPhotonAsymmetryCut=100.;
+Double_t kGCMinPhotonAsymmetry=0.;
Bool_t scanArguments(TString arguments){
else if (argument.CompareTo("-bg-off") == 0){
kGCcalculateBackground =kFALSE;
}
+ else if (argument.CompareTo("-bg-prob-off") == 0){
+ kGCdoBGProbability = kFALSE;
+ }
+ else if (argument.CompareTo("-bg-prob-on") == 0){
+ kGCdoBGProbability = kTRUE;
+ }
+ else if (argument.CompareTo("-bg-rotation-off") == 0){
+ kGCUseRotationMethodInBG = kFALSE;
+ }
+ else if (argument.CompareTo("-use-v0-multiplicity") == 0){
+ kGCUseTrackMultiplicityForBG = kFALSE;
+ }
+ else if (argument.CompareTo("-apply-chi2-cut") == 0){
+ kGCApplyChi2Cut = kTRUE;
+ }
+ else if(argument.CompareTo("-set-number-of-rotations") == 0){
+ if((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ kGCnumberOfRotationEventsForBG = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+ }
+ else if(argument.CompareTo("-set-number-of-degrees") == 0){
+ if((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ kGCnDegreeRotationPMForBG = ((TObjString*)pTokens->At(i))->GetString().Atoi();
+ }
+ else if (argument.CompareTo("-low-memory") == 0){
+ kGCLowMemoryConsumption = kTRUE;
+ }
+ else if (argument.CompareTo("-move-bg-vertex") == 0){
+ kGCMoveParticlesAccordingToVertex = kTRUE;
+ }
else if (argument.CompareTo("-check-neutralmeson-pi0s") == 0){
kGCdoNeutralMesonV0MCCheck=kTRUE;
}
cout<<"Running Chi_c analysis"<<endl;
kGCrunChic = kTRUE;
}
+ else if (argument.CompareTo("-run-dalitz") == 0){
+ cout<<"Running Dalitz analysis"<<endl;
+ kGCrunDalitz = kTRUE;
+ }
else if (argument.CompareTo("-run-cf") == 0){
cout<<"Running CF"<<endl;
kGCrunCF = kTRUE;
cout<<"Switching on use own xyz calculation"<<endl;
kGCdoOwnXYZCalculation = kTRUE;
}
+ else if (argument.CompareTo("-use-ConstructGamma") == 0){
+ cout<<"Switching on use ConstructGamma and OFF own xyz calculation"<<endl;
+ kGCdoOwnXYZCalculation = kFALSE;
+ kGCdoConstructGamma = kTRUE;
+ }
else if (argument.CompareTo("-no-aod") == 0){
cout<<"Turning off AOD"<<endl;
kGCWriteAOD = kFALSE;
}
+ else if (argument.CompareTo("-force-aod") == 0){
+ cout<<"Turning on FillAOD = kTRUE every event; If running in common train this should probably not be done!!!"<<endl;
+ kGCForceAOD = kTRUE;
+ }
else if (argument.CompareTo("-standard-aod") == 0){
cout<<"Writing to standard AOD, will only work on train"<<endl;
kGCDeltaAODFilename = "";
cout<<"Number Of files to analyze: "<<kGCnumberOfFilesToAnalyze<<endl;
build();//build (if necessary) and load the libraries needed
-
+ LoadLibraries();
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C"); // load the CreateChain macro
}
if(!SetAnalysisCutSelection(kGCAnalysisCutSelectionId)){
+ cout<<"Error in analysis cut selection"<<endl;
return 0;
}
v0Reader->SetNegativeTrackPID(kGCpidOfNegativeTrack);
v0Reader->SetPositiveTrackPID(kGCpidOfPositiveTrack);
v0Reader->SetMaxRCut(kGCmaxRCut);
+ v0Reader->SetMinRCut(kGCminRCut);
v0Reader->SetEtaCut(kGCetaCut);
+ v0Reader->SetRapidityMesonCut(kGCrapidityCutMeson);
v0Reader->SetPtCut(kGCptCut);
v0Reader->SetSinglePtCut(kGCsingleptCut);
v0Reader->SetLineCutZRSlope(kGCLineCutZRSlope);
v0Reader->SetLineCutZValue(kGCLineCutZValue);
v0Reader->SetMaxZCut(kGCmaxZCut);
v0Reader->SetMinClsTPCCut(kGCminClsTPCCut);
+ v0Reader->SetMinClsTPCCutToF(kGCminClsTPCCutToF);
v0Reader->SetChi2CutConversion(kGCchi2CutConversion);
v0Reader->SetChi2CutMeson(kGCchi2CutMeson);
v0Reader->SetAlphaCutMeson(kGCalphaCutMeson);
v0Reader->SetUseImprovedVertex(kGCuseImprovedVertex);
v0Reader->SetDoMCTruth(kGCdoMCTruth);
v0Reader->SetUseOwnXYZCalculation(kGCdoOwnXYZCalculation);
-
+ v0Reader->SetUseChargedTracksMultiplicityForBG(kGCUseTrackMultiplicityForBG);
// for CF
v0Reader->SetCFManager(man);
v0Reader->SetPIDnSigmaAboveElectronLine(kGCPIDnSigmaAboveElectronLine);
v0Reader->SetPIDnSigmaBelowElectronLine(kGCPIDnSigmaBelowElectronLine);
v0Reader->SetPIDnSigmaAbovePionLine(kGCPIDnSigmaAbovePionLine);
+ v0Reader->SetPIDnSigmaAbovePionLineHighPt(kGCPIDnSigmaAbovePionLineHighPt);
v0Reader->SetPIDMinPnSigmaAbovePionLine(kGCPIDMinPnSigmaAbovePionLine);
v0Reader->SetPIDMaxPnSigmaAbovePionLine(kGCPIDMaxPnSigmaAbovePionLine);
v0Reader->SetOnFlyFlag(kGCUseOnFlyV0Finder);
v0Reader->SetCalculateBackground(kGCcalculateBackground);
+ v0Reader->SetDoTOFsigmaCut(kGCuseTOFpid); // RRnewTOF
+ v0Reader->SetTofPIDnSigmaAboveElectronLine(kGCtofPIDnSigmaAboveElectronLine); // RRnewTOF
+ v0Reader->SetTofPIDnSigmaBelowElectronLine(kGCtofPIDnSigmaBelowElectronLine); // RRnewTOF
+
// for the rejection at LowP based on Dedx signal
v0Reader->SetDoKaonRejectionLowP(kGCdoKaonRejectionLowP);
v0Reader->SetPIDMinPProtonRejectionLowP(kGCPIDMinPProtonRejectionLowP);
v0Reader->SetPIDMinPPionRejectionLowP(kGCPIDMinPPionRejectionLowP);
v0Reader->SetDoQtGammaSelection(kGCdoQtGammaSelection);
+ v0Reader->SetDoHighPtQtGammaSelection(kGCdoHighPtQtGammaSelection); // RRnew
v0Reader->SetQtMax(kGCQtMax);
+ v0Reader->SetHighPtQtMax(kGCHighPtQtMax); // RRnew
+ v0Reader->SetPtBorderForQt(kGCPtBorderForQt); // RRnew
+
+ v0Reader->SetDoPhotonAsymmetryCut(kGCdoPhotonAsymmetryCut);
+ v0Reader->SetMinPPhotonAsymmetryCut(kGCMinPPhotonAsymmetryCut);
+ v0Reader->SetMinPhotonAsymmetry(kGCMinPhotonAsymmetry);
+
+
+ kGCNEventsForBGCalculation= kGCnumberOfRotationEventsForBG;
+ cout<< "number of Events used for mixing::"<<kGCNEventsForBGCalculation<<endl;
v0Reader->SetNEventsForBG(kGCNEventsForBGCalculation);
// Create the GammaConversionTask
gammaconversion->SetEtaWidth(kGCetaWidth);
gammaconversion->SetMinOpeningAngleGhostCut(kGCminOpeningAngleGhostCut);
+
Double_t lowPtMapping=0.4;
Double_t highPtMapping=1.5;
gammaconversion->SetDoChic(kGCrunChic);
gammaconversion->SetDoOmegaMeson(kGCrunOmegaMeson);
gammaconversion->SetRecalculateV0ForGamma(kGCRecalculateV0ForGamma);
+ gammaconversion->SetUseChargedTracksMultiplicityForBG(kGCUseTrackMultiplicityForBG);
+ gammaconversion->SetMoveParticleAccordingToVertex(kGCMoveParticlesAccordingToVertex);
+ gammaconversion->SetApplyChi2Cut(kGCApplyChi2Cut);
+ cout<<"NumberOfDegrees in rotatation method set to: "<<kGCnDegreeRotationPMForBG<<endl;
+ gammaconversion->SetPMDegreesBG(kGCnDegreeRotationPMForBG);
+ if(kGCUseRotationMethodInBG){
+ cout<<"Using rotation method for bg."<<endl;
+ }
+ else{
+ cout<<"Using mixed event for bg."<<endl;
+ }
+ if(kGCUseTrackMultiplicityForBG){
+ cout<<"Using track multiplicity for bck"<<endl;
+ }else{
+ cout<<"Using V0 multiplicity for bck"<<endl;
+ }
+ gammaconversion->SetDoRotation(kGCUseRotationMethodInBG);
+ cout<<"Using :"<<kGCnumberOfRotationEventsForBG<<" rotations in bg calculation"<<endl;
+ gammaconversion->SetNumberOfRotationsBG(kGCnumberOfRotationEventsForBG);
+ gammaconversion->SetCheckBGProbability(kGCdoBGProbability);
+
+ gammaconversion->SetRemovePileUp(kGCRemovePileUp);
+ gammaconversion->SetSelectV0AND(kGCSelectV0AND);
+ gammaconversion->SetUseMultiplicity(kGCUseMultiplicity);
+ gammaconversion->SetUseMultiplicityBin(kGCUseMultiplicityBin);
+
+ v0Reader->SetIsHeavyIon(kGCIsHeavyIon);
+ v0Reader->SetUseCorrectedTPCClsInfo(kGCUseCorrectedTPCClsInfo);
+ gammaconversion->SetUseCentrality(kGCUseCentrality);
+ if(kGCUseCentrality){
+ gammaconversion->SetUseCentralityBin(kGCUseCentralityBin);
+ }
+ v0Reader->SetUseMCPSmearing(kGCUseMCPSmearing);
+ v0Reader->SetPBremSmearing(kGCPBremSmearing);
+ v0Reader->SetPSigSmearing(kGCPSigSmearing);
+ v0Reader->SetPSigSmearingCte(kGCPSigSmearingCte);
+
+
// for CF
gammaconversion->SetCFManager(man);
gammaconversion->SetDoCF(kGCrunCF);
v0Reader->SetDoCF(kGCrunCF);
+ // Add task to the manager
+ mgr->AddTask(gammaconversion);
+
+
// Define Output Event Handler and add
if(kGCWriteAOD){
+ gammaconversion->SetForceAOD(kGCForceAOD);
+ gammaconversion->SetAODBranchName(Form("GammaConv_%s", kGCAnalysisCutSelectionId.Data()));
- cout << "Delta AOD file name : " << kGCDeltaAODFilename << endl;
-
- if( kGCrunOnTrain && !kGCrunOnGsiTrain ) {
+ if( kGCrunOnTrain ) {
+
AliAODHandler * aodHandler = dynamic_cast<AliAODHandler*>(mgr->GetOutputEventHandler());
+ if(!aodHandler) {
+ ::Error("This task requires an AOD handler");
+ return NULL;
+ }
+
gammaconversion->SetDeltaAODFileName(kGCDeltaAODFilename);
if(kGCDeltaAODFilename.Length() > 0) {
} else {
if(kGCDeltaAODFilename.Length() == 0 ) {
cout << "Error:: Need a file name for the AOD"<<endl;
- return;
+ return NULL;
}
AliAODHandler* aodHandler = new AliAODHandler();
aodHandler->SetOutputFileName(kGCDeltaAODFilename);
aodHandler->SetCreateNonStandardAOD();
mgr->SetOutputEventHandler(aodHandler);
}
+ } else {
+ gammaconversion->SetCreateAOD(kFALSE);
}
-
- // Add task to the manager
- mgr->AddTask(gammaconversion);
-
// Connect I/O to the task
mgr->ConnectInput (gammaconversion, 0, cinput1);
+ if(mgr->GetCommonOutputContainer())
+ mgr->ConnectOutput(gammaconversion, 0, mgr->GetCommonOutputContainer());
-
- // CKB Output slot 0 is NOT connected if WriteStandardAOD is false?
- if( kGCWriteAOD ){
- mgr->ConnectOutput(gammaconversion, 0, coutput1);
- }
mgr->ConnectOutput(gammaconversion, 1, coutput2);
mgr->ConnectOutput(gammaconversion, 2, coutput3);
-
+
if(kGCRunGammaJetTask) {
AliAnalysisTaskGammaJet * gammaJetTask = new AliAnalysisTaskGammaJet("GammaJetTask");
if(kGCrunOnTrain) {
}
+ if( kGCrunDalitz ){
+
+ gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskGammaConvDalitz.C");
+ AddTaskGammaConvDalitz( v0Reader, kGCcalculateBackground, kGCRunStandalone );
+
+ }
if(kGCrunOnTrain == kFALSE){
if(kGCdataList.IsNull()){
return gammaconversion;
}
+void LoadLibraries() {
+
+ TStopwatch timer;
+ timer.Start();
+ gSystem->Load("libTree.so");
+ gSystem->Load("libGeom");
+
+ gSystem->Load("libSTEERBase.so");
+ gSystem->Load("libVMC.so");
+ gSystem->Load("libESD.so");
+ gSystem->Load("libAOD.so");
+ gSystem->Load("libANALYSIS.so");
+ gSystem->Load("libANALYSISalice.so");
+ gSystem->Load("libCORRFW.so");
+ gSystem->Load("libPWG4GammaConv.so");
+
+ // gSystem->ChangeDirectory(pwd.Data());
+
+}
void build() {
TStopwatch timer;
gSystem->Load("libTree.so");
gSystem->Load("libGeom");
- ////
- //Setting up ESD.par//
- ////
- cout<<"compiling ESD"<<endl;
- setupPar("ESD");
- gSystem->Load("libVMC.so");
- gSystem->Load("libESD.so");
+ TString pwd = gSystem->WorkingDirectory();
- ////
////
//Setting up STEERBase.par//
////
cout<<"compiling STEERBase"<<endl;
setupPar("STEERBase");
gSystem->Load("libSTEERBase.so");
+
+
+ ////
+ //Setting up ESD.par//
+ ////
+ cout<<"compiling ESD"<<endl;
+ setupPar("ESD");
+ gSystem->Load("libVMC.so");
+ gSystem->Load("libESD.so");
+
////
//Setting up AOD.par//
cout<<"compiling PWG4GammaConv"<<endl;
setupPar("PWG4GammaConv");
gSystem->Load("libPWG4GammaConv.so");
+
+ gSystem->ChangeDirectory(pwd.Data());
}
Int_t setupPar(const char* pararchivename) {
}// end kGCrunChic
+
+ //---------------------------------------------- Gamma from Decay ----------------------------------------------------
+ if(kGCplotMCGammaFromDecay == kTRUE && kGCdoMCTruth == kTRUE){
+ histograms->AddHistogram("MC_DecayPi0Gamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("MC_DecayRho0Gamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("MC_DecayEtaGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("MC_DecayOmegaGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("MC_DecayK0sGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("MC_DecayEtapGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("MC_DecayPhiGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("MC_DecayAllGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ }
+
//---------------------------------------------- Neutral Meson ---------------------------------------------------------
if(kGCrunNeutralMeson){
if(kGCplotESDEPhi == kTRUE){ histograms->AddHistogram("ESD_E_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotESDENTPCClusters == kTRUE){ histograms->AddHistogram("ESD_E_nTPCClusters" ,"" , kGCnXBinsNTPCClusters, kGCfirstXBinNTPCClusters, kGClastXBinNTPCClusters, "", "");}
if(kGCplotESDENITSClusters == kTRUE){ histograms->AddHistogram("ESD_E_nITSClusters" ,"" , kGCnXBinsNITSClusters, kGCfirstXBinNITSClusters, kGClastXBinNITSClusters, "", "");}
+ if(kGCplotESDENTPCClustersToFP== kTRUE){ histograms->AddHistogram("ESD_E_nTPCClustersToFP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+ if(kGCplotESDENTPCClustersToFR== kTRUE){ histograms->AddHistogram("ESD_E_nTPCClustersToFR" ,"" ,kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+ if(kGCplotESDENTPCClustersToFR== kTRUE){ histograms->AddHistogram("ESD_TrueConversion_E_nTPCClustersToFR" ,"" ,kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+ if(kGCplotESDETPCchi2 == kTRUE){ histograms->AddHistogram("ESD_E_TPCchi2" ,"" , kGCnXBinsTPCchi2, kGCfirstXBinTPCchi2, kGClastXBinTPCchi2, "", "");}
+
if(kGCplotESDPEnergy == kTRUE){ histograms->AddHistogram("ESD_P_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDPPt == kTRUE){ histograms->AddHistogram("ESD_P_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDPPhi == kTRUE){ histograms->AddHistogram("ESD_P_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotESDPNTPCClusters == kTRUE){ histograms->AddHistogram("ESD_P_nTPCClusters" ,"" , kGCnXBinsNTPCClusters, kGCfirstXBinNTPCClusters, kGClastXBinNTPCClusters, "", "");}
if(kGCplotESDPNITSClusters == kTRUE){ histograms->AddHistogram("ESD_P_nITSClusters" ,"" , kGCnXBinsNITSClusters, kGCfirstXBinNITSClusters, kGClastXBinNITSClusters, "", "");}
-
+ if(kGCplotESDPNTPCClustersToFP== kTRUE){ histograms->AddHistogram("ESD_P_nTPCClustersToFP" ,"" ,kGCnXBinsP, kGCfirstXBinP, kGClastXBinP,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+ if(kGCplotESDPNTPCClustersToFR== kTRUE){ histograms->AddHistogram("ESD_P_nTPCClustersToFR" ,"" ,kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+ if(kGCplotESDPNTPCClustersToFR== kTRUE){ histograms->AddHistogram("ESD_TrueConversion_P_nTPCClustersToFR" ,"" ,kGCnXBinsR, kGCfirstXBinR, kGClastXBinR,kGCnYBinsClsToF, kGCfirstYBinClsToF, kGClastYBinClsToF,"", "",0);}
+ if(kGCplotESDPTPCchi2 == kTRUE){ histograms->AddHistogram("ESD_P_TPCchi2" ,"" , kGCnXBinsTPCchi2, kGCfirstXBinTPCchi2, kGClastXBinTPCchi2, "", "");}
+
if(kGCplotESDConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt_Eta","", kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta,"","" );}
if(kGCplotESDConvGammaPtvsChi2 == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Pt_Chi2" ,"" ,kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
if(kGCplotESDConvGammaEtavsChi2 == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_Eta_Chi2" ,"" ,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
-
+ histograms->AddHistogram("ESD_ConvGamma_EandP_P_dT" ,"" , kGCnXBinsP, kGCfirstXBinP, kGClastXBinP, kGCnXBinsTOFsignal, kGCfirstXBinTOFsignal, kGClastXBinTOFsignal, "", "",0); // RRnewTOF
if(kGCplotESDConversionR == kTRUE){ histograms->AddHistogram("ESD_Conversion_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
if(kGCplotESDConversionZR == kTRUE){ histograms->AddHistogram("ESD_Conversion_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDConversionXY == kTRUE){ histograms->AddHistogram("ESD_Conversion_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
+ if(kGCplotESDConversionXYBeamPipe == kTRUE && kGCLowMemoryConsumption == kFALSE){ histograms->AddHistogram("ESD_Conversion_XY_BeamPipe" ,"" , kGCnXBinsXYBP, kGCfirstXBinXYBP, kGClastXBinXYBP, kGCnYBinsXYBP, kGCfirstYBinXYBP, kGClastYBinXYBP, "", "");}
+ if(kGCplotESDConversionRPhiBeamPipe == kTRUE && kGCLowMemoryConsumption == kFALSE){ histograms->AddHistogram("ESD_Conversion_RPhi_BeamPipe" ,"" , kGCnXBinsRPhiBP, kGCfirstXBinRPhiBP, kGClastXBinRPhiBP, kGCnYBinsRPhiBP, kGCfirstYBinRPhiBP, kGClastYBinRPhiBP, "", "");}
if(kGCplotESDConversionOpeningAngle == kTRUE){ histograms->AddHistogram("ESD_Conversion_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
if(kGCplotESDConvGammaCosPointingAngle == kTRUE){ histograms->AddHistogram("ESD_ConvGamma_CosPointingAngle" ,"" , kGCnXBinsCosPointingAngle, kGCfirstXBinCosPointingAngle, kGClastXBinCosPointingAngle, "", "");}
if(kGCplotESDTrueDalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueDalitzContamination_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
-
+ if(kGCplotESDTruePi0DalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvDalitzPi0_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+ if(kGCplotESDTrueEtaDalitzContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvDalitzEta_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+ if(kGCplotESDTrueCombinatorialContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorial_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+ if(kGCplotESDTrueCombinatorialElecContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorialElec_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+ if(kGCplotESDTrueHadronicContaminationR == kTRUE){ histograms->AddHistogram("ESD_TrueConvHadronicBck_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
+ if(kGCplotESDTrueCombinatorialContaminationPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorial_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotESDTrueCombinatorialElecContaminationPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvCombinatorialElec_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotESDTrueHadronicContaminationPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvHadronicBck_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
+
+ if(kGCplotESDTrueBackground){
+ histograms->AddHistogram("ESD_TrueConvCombinatorialDaughter_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConvHadronicBckDaughter_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConvCombinatorialPiDaughter_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConvCombinatorialPiPDaughter_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");
+
+ histograms->AddHistogram("ESD_TrueConvCombinatorialPi_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConvCombinatorialPi_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ histograms->AddHistogram("ESD_TrueConvCombinatorialPiP_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConvCombinatorialPiP_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ histograms->AddHistogram("ESD_TrueConvCombinatorialElecPi_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConvCombinatorialElecPi_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ histograms->AddHistogram("ESD_TrueConvMeson_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConvMeson_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ histograms->AddHistogram("ESD_TrueConvLambda_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConvLambda_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ }
+
+ histograms->AddHistogram("ESD_TrueConvDalitzPi0_SinglePos_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ histograms->AddHistogram("ESD_TrueConvDalitzPi0_SingleNeg_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ histograms->AddHistogram("ESD_TrueConvDalitzPi0_SinglePos_kFirst_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ histograms->AddHistogram("ESD_TrueConvDalitzPi0_SingleNeg_kFirst_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");
+ histograms->AddHistogram("ESD_TrueConversion_SinglePos_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,"", "");
+ histograms->AddHistogram("ESD_TrueConversion_SingleNeg_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConversion_SinglePos_kFirst_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+ histograms->AddHistogram("ESD_TrueConversion_SingleNeg_kFirst_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");
+
+
if(kGCplotESDTrueConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDTrueConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDTrueConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDTrueConvGammaNDF == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_NDF" ,"" , kGCnXBinsGammaNDF, kGCfirstXBinGammaNDF, kGClastXBinGammaNDF, "", "");}
if(kGCplotESDTrueConvGammaRapid == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotESDTrueConvGammaPtvsEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt_Eta" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
+
if(kGCplotESDTrueConvGammaPtvsChi2 == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Pt_Chi2" ,"" ,kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
if(kGCplotESDTrueConvGammaEtavsChi2 == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_Eta_Chi2" ,"" ,kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, kGCnXBinsGammaChi2, kGCfirstXBinGammaChi2, kGClastXBinGammaChi2, "", "");}
if(kGCplotESDTrueConvGammaMCPtEta == kTRUE){ histograms->AddHistogram("ESD_TrueConvGamma_MC_Pt_Eta" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotESDTrueConversionMCZR == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_MC_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotESDTrueConversionMCXY == kTRUE){ histograms->AddHistogram("ESD_TrueConversion_MC_XY" ,"" , kGCnXBinsXY, kGCfirstXBinXY, kGClastXBinXY, kGCnYBinsXY, kGCfirstYBinXY, kGClastYBinXY, "", "");}
-
-
-
+ histograms->AddHistogram("ESD_TrueConvGamma_EandP_P_dT" ,"" , kGCnXBinsP, kGCfirstXBinP, kGClastXBinP, kGCnXBinsTOFsignal, kGCfirstXBinTOFsignal, kGClastXBinTOFsignal, "", "",0); // RRnewTOF
+ histograms->AddHistogram("ESD_TrueConvCombinatorial_DaughtersNotElec_P_dT" ,"" , kGCnXBinsP, kGCfirstXBinP, kGClastXBinP, kGCnXBinsTOFsignal, kGCfirstXBinTOFsignal, kGClastXBinTOFsignal, "", "",0); // RRnewTOF
+ histograms->AddHistogram("ESD_TrueConvHadronicBck_Daughters_P_dT" ,"" , kGCnXBinsP, kGCfirstXBinP, kGClastXBinP, kGCnXBinsTOFsignal, kGCfirstXBinTOFsignal, kGClastXBinTOFsignal, "", "",0); // RRnewTOF
+
+ histograms->AddHistogram("ESD_NoCutConvGamma_EandP_P_dT" ,"" , kGCnXBinsP, kGCfirstXBinP, kGClastXBinP, kGCnXBinsTOFsignal, kGCfirstXBinTOFsignal, kGClastXBinTOFsignal, "", "",0); // RRnewTOF
+ if(kGCplotESDNoCutAllV0Pt == kTRUE){ histograms->AddHistogram("ESD_NoCutAllV0_Pt" ,"" , kGCnXBinsPt,kGCfirstXBinPt , kGClastXBinPt, "", "");}
if(kGCplotESDNoCutConvGammaEnergy == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotESDNoCutConvGammaPt == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotESDNoCutConvGammaEta == kTRUE){ histograms->AddHistogram("ESD_NoCutConvGamma_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
// ___________________________________________________________________________________________________________________________________________________
- if(kGCplotESDNumberOfV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfV0s","Number of v0s",100, -0.5, 99.5,"","");}
- if(kGCplotESDNumberOfSurvivingV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfSurvivingV0s","Number of surviving v0s",100, -0.5, 99.5,"","");}
- if(kGCplotESDNumberOfContributorsVtx == kTRUE){histograms->AddHistogram("ESD_NumberOfContributorsVtx","Number of contributors to vertex",100, -0.5, 99.5,"","");}
- if(kGCplotESDNumberOfGoodESDTracks == kTRUE){histograms->AddHistogram("ESD_NumberOfGoodESDTracks","Number of Good ESD tracks",100, -0.5, 99.5,"","");}
- if(kGCplotESDNumberOfGoodESDTracks == kTRUE){histograms->AddHistogram("ESD_NumberOfGoodESDTracksVtx","Number of Good ESD tracks",100, -0.5, 99.5,"","");}
+ if(kGCplotEventQuality == kTRUE){histograms->AddHistogram("ESD_EventQuality","ESD_EventQuality",kGCnXBinsEvtQ,kGCfirstXBinEvtQ,kGClastXBinEvtQ,"","");}
+ if(kGCplotESDNumberOfV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfV0s","Number of v0s",kGCnXBinsNV0,kGCfirstXBinNV0 ,kGClastXBinNV0 ,"","");}
+ if(kGCplotESDNumberOfSurvivingV0s == kTRUE){histograms->AddHistogram("ESD_NumberOfSurvivingV0s","Number of surviving v0s",kGCnXBinsNV0, kGCfirstXBinNV0 , kGClastXBinNV0,"","");}
+ if(kGCplotESDNumberOfContributorsVtx == kTRUE){histograms->AddHistogram("ESD_NumberOfContributorsVtx","Number of contributors to vertex",kGCnXBinsESDtrk, kGCfirstXBinESDtrk, kGClastXBinESDtrk,"","");}
+ if(kGCplotESDNumberOfGoodESDTracks == kTRUE){histograms->AddHistogram("ESD_NumberOfGoodESDTracks","Number of Good ESD tracks",kGCnXBinsESDtrk, kGCfirstXBinESDtrk, kGClastXBinESDtrk,"","");}
+ if(kGCplotESDNumberOfGoodESDTracks == kTRUE){histograms->AddHistogram("ESD_NumberOfGoodESDTracksVtx","Number of Good ESD tracks",kGCnXBinsESDtrk, kGCfirstXBinESDtrk, kGClastXBinESDtrk,"","");}
// debug histograms
if(kGCplotESDCutGetOnFly == kTRUE){histograms->AddHistogram("ESD_CutGetOnFly_InvMass" ,"Not GetOnFly" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutPionRejectionLowP==kTRUE){histograms->AddHistogram("ESD_CutPionRejectionLowP_InvMass" ,"dedx PionRejection LowP" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutKaonRejectionLowP==kTRUE){histograms->AddHistogram("ESD_CutKaonRejectionLowP_InvMass" ,"dedx KaonRejection LowP" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutQtGammaSelection==kTRUE){histograms->AddHistogram("ESD_CutQt_InvMass","ESD_CutQt_InvMass",kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+ histograms->AddHistogram("ESD_CutTOFsigmaElec_InvMass", "ESD_CutTOFsigmaElec_InvMass",kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"",""); // RRnewTOF
if(kGCplotESDCutProtonRejectionLowP==kTRUE){histograms->AddHistogram("ESD_CutProtonRejectionLowP_InvMass" ,"dedx ProtonRejection LowP" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutR == kTRUE){histograms->AddHistogram("ESD_CutR_InvMass" ,"Above RMax" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+ if(kGCplotESDCutMinR == kTRUE){histograms->AddHistogram("ESD_CutMinR_InvMass" ,"Above RMax" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutNDF == kTRUE){histograms->AddHistogram("ESD_CutNDF_InvMass" ,"NDF <= 0" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutChi2 == kTRUE){histograms->AddHistogram("ESD_CutChi2_InvMass" ,"#chi^{2} > Max" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutEta == kTRUE){histograms->AddHistogram("ESD_CutEta_InvMass" ,"Above #eta max" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutLine == kTRUE){histograms->AddHistogram("ESD_CutLine_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutZ == kTRUE){histograms->AddHistogram("ESD_CutZ_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDCutMinClsTPC == kTRUE){histograms->AddHistogram("ESD_CutMinNClsTPC_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+ if(kGCplotESDCutMinClsTPCToF == kTRUE){histograms->AddHistogram("ESD_CutMinNClsTPCToF_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
+ if(kGCplotESDCutPhotonAsymmetry== kTRUE){histograms->AddHistogram("ESD_CutPhotonAsymmetry_InvMass" ,"Out of reconstruction area" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDGoodV0s == kTRUE){histograms->AddHistogram("ESD_GoodV0s_InvMass" ,"Good V0s" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDAllV0s == kTRUE){histograms->AddHistogram("ESD_AllV0s_InvMass" ,"All V0s" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDAllV0sCurrentFinder == kTRUE){histograms->AddHistogram("ESD_AllV0sCurrentFinder_InvMass" ,"All V0s Current Finder" , kGCnXBinsGammaMass, kGCfirstXBinGammaMass, kGClastXBinGammaMass,"","");}
if(kGCplotESDAllV0sCurrentFinderQtAlfa== kTRUE){ histograms->AddHistogram("ESD_AllV0sCurrentFinder_alfa_qt" ,"" ,kGCnXBinsP, kGCfirstXBinAlphaG, kGClastXBinAlpha,kGCnYBinsQt, kGCfirstYBinQt, kGClastYBinQt,"", "");}
+ if(kGCplotESDAllV0sCurrentFinderQtAlfa== kTRUE){ histograms->AddHistogram("ESD_AllV0sCurrentFinder_goodtracks_alfa_qt" ,"" ,kGCnXBinsP, kGCfirstXBinAlphaG, kGClastXBinAlpha,kGCnYBinsQt, kGCfirstYBinQt, kGClastYBinQt,"", "");}
if(kGCplotESDTrueConvGammaTrackLength == kTRUE){histograms->AddHistogram("ESD_TrueConvGamma_TrackLength","Track length of TrueConvGamma",kGCnXBinsTrackLength,kGCfirstXBinTrackLength,kGClastXBinTrackLength,"","");}
if(kGCplotESDTrueConvGammaTrackLengthVSInvMass == kTRUE){histograms->AddHistogram("ESD_TrueConvGamma_TrackLengthVSInvMass","Track length of TrueConvGamma vs Inv mass",kGCnXBinsTrackLength,kGCfirstXBinTrackLength,kGClastXBinTrackLength,kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt,"","");}
if(kGCplotPi0Spectra == kTRUE){
histograms->AddHistogram("ESD_Mother_alfa","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
-
+ histograms->AddHistogram("ESD_Mother_alfa_Pi0","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+ histograms->AddHistogram("ESD_Mother_alfa_Eta","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+ histograms->AddHistogram("ESD_Background_alfa_Pi0","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+ histograms->AddHistogram("ESD_Background_alfa_Eta","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinAlpha, kGClastXBinAlpha,"#alpha","Counts");
+ // histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_alpha" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_alpha" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ histograms->AddHistogram("ESD_Mother_InvMass_vs_E_alpha" ,"Invariant Mass vs E" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","E [GeV]");
histograms->AddHistogram("ESD_Mother_InvMass","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
histograms->AddHistogram("ESD_Mother_InvMass_1212","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
histograms->AddHistogram("ESD_Mother_InvMass_0912","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt0912" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt0909" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ if(kGCLowMemoryConsumption == kFALSE){
+ histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+ histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvPHOS" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanLow","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+ histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanHigh","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
- histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
- histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvPHOS" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
- histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanLow","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
- histograms->AddHistogram("ESD_Mother_InvMass_GammaConvPHOS_OpanHigh","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-
- histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
- histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_Bck","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-
- histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
- histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL_Bck" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-
-
- histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanLow","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
- histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanHigh","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
-
+ histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+ histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_Bck","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+
+ histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_GammaConvEMCAL_Bck" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+
+ histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanLow","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+ histograms->AddHistogram("ESD_Mother_InvMass_GammaConvEMCAL_OpanHigh","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
+ }
// if(kGCdoNeutralMesonV0MCCheck == kTRUE){
+ histograms->AddHistogram("ESD_TrueBckGG_InvMass_vs_Pt","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Counts");
+ histograms->AddHistogram("ESD_TrueBckCont_InvMass_vs_Pt","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Counts");
+ histograms->AddHistogram("ESD_TruePi0Sec_InvMass_vs_Pt","Invariant mass vs Pt",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Counts");
+ histograms->AddHistogram("ESD_TruePi0DalitzCont_InvMass_vs_Pt","Invariant mass vs Pt",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Counts");
histograms->AddHistogram("ESD_TruePi0_InvMass","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
histograms->AddHistogram("ESD_TruePi0_InvMass_1212","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
histograms->AddHistogram("ESD_TruePi0_InvMass_0912","Invariant mass",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
histograms->AddHistogram("ESD_TruePi0_OpeningAngle_0912" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");
histograms->AddHistogram("ESD_TruePi0_OpeningAngle_0909" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");
histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
- histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt1212" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
- histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt0912" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
- histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt0909" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt_alpha" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+
+ if(kGCLowMemoryConsumption == kFALSE){
+ histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt1212" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt0912" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ histograms->AddHistogram("ESD_TruePi0_InvMass_vs_Pt0909" ,"Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+
//}
- histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_Fiducial" ,"Invariant Mass vs Pt |eta|<0.9" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ histograms->AddHistogram("ESD_Mother_InvMass_vs_Pt_Fiducial" ,"Invariant Mass vs Pt |eta|<0.9" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+ }
histograms->AddHistogram("ESD_Mother_InvMass_Fiducial","Invariant mass |eta|<0.9",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass [GeV]","Counts");
}
for(Int_t z=0;z<8;z++){
for(Int_t m=0;m<6;m++){
+ histograms->AddHistogram(Form("%d%dESD_Mother_InvMass_vs_Pt",z,m) ,"ESD Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
+
histograms->AddHistogram(Form("%d%dESD_Background_InvMass_vs_Pt",z,m) ,"Background Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
histograms->AddHistogram("ESD_Background_InvMass_vs_Pt" ,"Background Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
histograms->AddHistogram("ESD_Background_InvMass_vs_Pt_alpha" ,"Background Invariant Mass vs Pt" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
-
+ histograms->AddHistogram("ESD_Background_InvMass_vs_E_alpha" ,"Background Invariant Mass vs E" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","E [GeV]");
+
histograms->AddHistogram("ESD_Background_InvMass","Invariant mass background",kGCnXBinsSpectra,kGCfirstXBinSpectra, kGClastXBinSpectra,"InvMass BG [GeV]","Counts");
histograms->AddHistogram("ESD_Background_InvMass_vs_Pt_Fiducial" ,"Background Invariant Mass vs Pt |eta|<0.9" , kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra,kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra,"InvMass [GeV]","Pt [GeV]");
histograms->AddHistogram("MC_Mother_InvMass_vs_Pt_ConvGamma_withinAcceptance" ,"" ,kGCnXBinsSpectra, kGCfirstXBinSpectra, kGClastXBinSpectra, kGCnYBinsSpectra, kGCfirstYBinSpectra, kGClastYBinSpectra, "", "");
}
-
+ if(kGCplotMCPhysicalPrimaryChargedPt == kTRUE){ histograms->AddHistogram("MC_PhysicalPrimaryCharged_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCPi0Eta == kTRUE){ histograms->AddHistogram("MC_Pi0_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCPi0Rapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
+ if(kGCplotMCPi0PtvsRapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_vs_Rapid" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
+ if(kGCplotMCPi0PtvsRapid == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_vs_Rapid_allDaughters" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");} // RR primary Pi0 debug
if(kGCplotMCPi0Phi == kTRUE){ histograms->AddHistogram("MC_Pi0_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ1_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ2_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ3_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ4_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_SD_EvtQ5_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ1_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ2_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ3_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ4_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_DD_EvtQ5_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
+
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ1_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ2_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ3_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ4_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+ if(kGCplotMCPi0Pt == kTRUE){ histograms->AddHistogram("MC_ND_EvtQ5_Pi0_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
+
if(kGCplotMCPi0PtFiducial == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_Fiducial" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCPi0PtWithinAcceptanceFiducial == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_withinAcceptance_Fiducial" ,"" , kGCnXBinsPt,kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCPi0PtConvGammaWithinAcceptanceFiducial == kTRUE){ histograms->AddHistogram("MC_Pi0_Pt_ConvGamma_withinAcceptance_Fiducial","" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCPi0Energy == kTRUE){ histograms->AddHistogram("MC_Pi0_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
if(kGCplotMCPi0Mass == kTRUE){ histograms->AddHistogram("MC_Pi0_Mass" ,"" , kGCnXBinsPi0Mass, kGCfirstXBinPi0Mass, kGClastXBinPi0Mass, "", "");}
if(kGCplotMCPi0Alpha == kTRUE){ histograms->AddHistogram("MC_Pi0_alpha" ,"" , kGCnXBinsPi0Mass, kGCfirstXBinPi0Alpha, kGClastXBinPi0Alpha, "", "");}
-
+ if(kGCplotMCEtaAlpha == kTRUE){ histograms->AddHistogram("MC_Eta_alpha" ,"" , kGCnXBinsPi0Mass, kGCfirstXBinPi0Alpha, kGClastXBinPi0Alpha, "", "");}
if(kGCplotMCPi0OpeningAngle == kTRUE){ histograms->AddHistogram("MC_Pi0_GammaDaughter_OpeningAngle" ,"" , kGCnXBinsOpeningAngle, kGCfirstXBinOpeningAngle, kGClastXBinOpeningAngle, "", "");}
if(kGCplotMCPi0R == kTRUE){ histograms->AddHistogram("MC_Pi0_R" ,"" , kGCnXBinsR, kGCfirstXBinR, kGClastXBinR, "", "");}
if(kGCplotMCPi0ZR == kTRUE){ histograms->AddHistogram("MC_Pi0_ZR" ,"" , kGCnXBinsZR, kGCfirstXBinZR, kGClastXBinZR, kGCnYBinsZR, kGCfirstYBinZR, kGClastYBinZR, "", "");}
if(kGCplotMCEtaEta == kTRUE){ histograms->AddHistogram("MC_Eta_Eta" ,"" , kGCnXBinsEta, kGCfirstXBinEta, kGClastXBinEta, "", "");}
if(kGCplotMCEtaRapid == kTRUE){ histograms->AddHistogram("MC_Eta_Rapid" ,"" , kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
+ if(kGCplotMCEtaPtvsRapid == kTRUE){ histograms->AddHistogram("MC_Eta_Pt_vs_Rapid" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, kGCnXBinsRapid, kGCfirstXBinRapid, kGClastXBinRapid, "", "");}
if(kGCplotMCEtaPhi == kTRUE){ histograms->AddHistogram("MC_Eta_Phi" ,"" , kGCnXBinsPhi, kGCfirstXBinPhi, kGClastXBinPhi, "", "");}
if(kGCplotMCEtaPt == kTRUE){ histograms->AddHistogram("MC_Eta_Pt" ,"" , kGCnXBinsPt, kGCfirstXBinPt, kGClastXBinPt, "", "");}
if(kGCplotMCEtaEnergy == kTRUE){ histograms->AddHistogram("MC_Eta_Energy" ,"" , kGCnXBinsEnergy, kGCfirstXBinEnergy, kGClastXBinEnergy, "", "");}
//--------------------------------------------------- 2 gamma Background -------------------------------------------------------
if(kGCcalculateBackground==kTRUE){
+ histograms->AddHistogram("ESD_GlobalPrimaryVtxZ","Z primary vertex Global",300, -15., 15.,"Z[cm]","counts");
+ histograms->AddHistogram("ESD_SPDPrimaryVtxZ","Z primary vertex SPD",300, -15., 15.,"Z[cm]","counts");
histograms->AddHistogram("ESD_Z_distribution" ,"Z primary vertex" , 2000, -30, 30,"Z[cm]","counts");
histograms->AddHistogram("ESD_multiplicity_distribution" ,"multiplicity distribution" , 200, 0, 200,"counts","Multiplicity");
histograms->AddHistogram("ESD_ZvsMultiplicity" ,"Z vs Multiplicity" , 1000, -10, 10,200,0,200,"Z[cm]","Multiplicity");
Int_t QtMaxCut=array[12];
Int_t piMaxMomdedxSigmaCut=array[13];
Int_t alphaMesonCut=array[14];
-
- cout<<"alphaMesonCut"<<alphaMesonCut<<endl;
+ Int_t minRCut=array[15];
+ Int_t RapidityMesonCut=array[16];
+ Int_t BackgroundScheme=array[17];
+ Int_t DegreesForRotationMethod=array[18];
+ Int_t NumberOfRotations=array[19];
+ Int_t removePileUp=array[20];
+ Int_t selectV0AND=array[21];
+ Int_t multiplicityBin=array[22];
+ Int_t isHeavyIon=array[23];
+ Int_t useCentrality=array[24];
+ Int_t centralityBin=array[25];
+ Int_t TOFelectronPID=array[26]; // RRnewTOF
+ Int_t useMCPSmearing=array[27];
+ Int_t doPhotonAsymmetryCut=array[28];
+
+ cout<<"doPhotonAsymmetryCut::"<<doPhotonAsymmetryCut<<endl;
+ cout<<"useMCPSmearing::"<<useMCPSmearing<<endl;
+ cout<<"TOFelectronPID: "<<TOFelectronPID<<endl; // RRnewTOF
+ cout<<"CentralityBin::"<< centralityBin <<endl;
+ cout<<"Use Centrality::"<< useCentrality <<endl;
+ cout<<"Heavy Ion::"<< isHeavyIon<<endl;
+ cout<<"Multiplicity Bin::"<< multiplicityBin<<endl;
+ cout<<"Select V0AND::"<< selectV0AND<<endl;
+ cout<<"Remove PileUp::"<< removePileUp<<endl;
+ cout<<"NumberOfRotations::"<<NumberOfRotations<<endl;
+ cout<<"DegreesForRotationMethod::"<<DegreesForRotationMethod<<endl;
+ cout<<"BackgroundScheme::"<<BackgroundScheme<<endl;
+ cout<<"RapidityMesonCut::"<<RapidityMesonCut<<endl;
+ cout<<"minRCut::"<<minRCut<<endl;
+ cout<<"alphaMesonCut::"<<alphaMesonCut<<endl;
cout<<"piMaxMomdedxSigmaCut::"<<piMaxMomdedxSigmaCut<<endl;
cout<<"QtMaxCut:"<<QtMaxCut<<endl;
cout<<"LowPRejectionSigmaCut:"<<LowPRejectionSigmaCut<<endl;
cout<<"v0FinderType: "<<v0FinderType <<endl;
cout<<"goodId: "<<goodId <<endl;
+
if(goodId !=9){
cout<<"Analysis Cut Selection too short or does not start with 9"<<endl;
return iResult;
switch(pidedxSigmaCut){
case 0: // -10
kGCPIDnSigmaAbovePionLine=-10;
+ kGCPIDnSigmaAbovePionLineHighPt=-10;
break;
case 1: // 0
kGCPIDnSigmaAbovePionLine=0;
+ kGCPIDnSigmaAbovePionLineHighPt=-10;
break;
case 2: // 1
kGCPIDnSigmaAbovePionLine=1;
+ kGCPIDnSigmaAbovePionLineHighPt=-10;
break;
case 3: // 1
kGCPIDnSigmaAbovePionLine=-1;
+ kGCPIDnSigmaAbovePionLineHighPt=-10;
break;
case 4: // 1
kGCPIDnSigmaAbovePionLine=-1.5;
+ kGCPIDnSigmaAbovePionLineHighPt=-10;
break;
case 5: // 1
kGCPIDnSigmaAbovePionLine=2.;
+ kGCPIDnSigmaAbovePionLineHighPt=-10;
+ break;
+ case 6: // 1
+ kGCPIDnSigmaAbovePionLine=2.;
+ kGCPIDnSigmaAbovePionLineHighPt=0.5;
+ break;
+ case 7: // 1
+ kGCPIDnSigmaAbovePionLine=3.5;
+ kGCPIDnSigmaAbovePionLineHighPt=-10;
+ break;
+ case 8: // 1
+ kGCPIDnSigmaAbovePionLine=2.;
+ kGCPIDnSigmaAbovePionLineHighPt=1.;
break;
-
default:
return iResult;
}
case 5: // 0.3 GeV
kGCPIDMinPnSigmaAbovePionLine=0.3;
break;
- case 6: // 0.3 GeV
+ case 6: // 0.25 GeV // RRnew label was wrong in comment
kGCPIDMinPnSigmaAbovePionLine=0.25;
break;
+ case 7: // 0.4 GeV
+ kGCPIDMinPnSigmaAbovePionLine=0.4;
+ break;
default:
return iResult;
}
case 7:
kGCchi2CutConversion = 10.;
break;
+ case 8:
+ kGCchi2CutConversion = 20.;
+ break;
+ case 9:
+ kGCchi2CutConversion = 15.;
+ break;
default:
return iResult;
}
case 3: // 0.200 GeV
kGCsingleptCut = 0.200;
break;
+ case 4: // 0.075 GeV
+ kGCsingleptCut = 0.075;
+ break;
+ case 5: // 0.125 GeV
+ kGCsingleptCut = 0.125;
+ break;
default:
return iResult;
}
case 3: // 100
kGCminClsTPCCut= 100.;
break;
+ case 4: // 60% of findable clusters
+ kGCminClsTPCCutToF= 0.6;
+ kGCUseCorrectedTPCClsInfo=0;
+ break;
+ case 5: // 0% of findable clusters
+ kGCminClsTPCCutToF= 0.0;
+ kGCUseCorrectedTPCClsInfo=1;
+ break;
+ case 6: // 0% of findable clusters
+ kGCminClsTPCCutToF= 0.7;
+ kGCUseCorrectedTPCClsInfo=0;
+ break;
+ case 7: // 0% of findable clusters
+ kGCminClsTPCCutToF= 0.35;
+ kGCUseCorrectedTPCClsInfo=0;
+ break;
+ case 8:
+ kGCminClsTPCCutToF= 0.35;
+ kGCUseCorrectedTPCClsInfo=1;
+ break;
+ case 9:
+ kGCminClsTPCCutToF= 0.6;
+ kGCUseCorrectedTPCClsInfo=1;
+ break;
default:
return iResult;
}
kGCPIDnSigmaAtLowPAroundProtonLine=0.;
kGCPIDnSigmaAtLowPAroundPionLine=2.;
break;
-
default:
return iResult;
}
switch(QtMaxCut){
case 0: //
kGCQtMax=1.;
+ kGCdoHighPtQtGammaSelection=kFALSE; // RRnew
+ kGCHighPtQtMax=100.; // RRnew
+ kGCPtBorderForQt=100.; // RRnew
break;
case 1:
kGCQtMax=0.1;
+ kGCdoHighPtQtGammaSelection=kFALSE; // RRnew
+ kGCHighPtQtMax=100.; // RRnew
+ kGCPtBorderForQt=100.; // RRnew
break;
case 2:
kGCQtMax=0.07;
+ kGCdoHighPtQtGammaSelection=kFALSE; // RRnew
+ kGCHighPtQtMax=100.; // RRnew
+ kGCPtBorderForQt=100.; // RRnew
break;
case 3:
kGCQtMax=0.05;
+ kGCdoHighPtQtGammaSelection=kFALSE; // RRnew
+ kGCHighPtQtMax=100.; // RRnew
+ kGCPtBorderForQt=100.; // RRnew
break;
case 4:
kGCQtMax=0.03;
+ kGCdoHighPtQtGammaSelection=kFALSE; // RRnew
+ kGCHighPtQtMax=100.; // RRnew
+ kGCPtBorderForQt=100.; // RRnew
+ break;
+ case 5: // RR try to improve (get rid of) low InvMass peak in PbPb
+ kGCQtMax=0.02;
+ kGCdoHighPtQtGammaSelection=kFALSE; // RRnew
+ kGCHighPtQtMax=100.; // RRnew
+ kGCPtBorderForQt=100.; // RRnew
+ break; // end RR ///////////////////////////////////////////////
+ case 6: // RRnew start: pT dependent qT cut
+ kGCQtMax=0.02;
+ kGCdoHighPtQtGammaSelection=kTRUE;
+ kGCHighPtQtMax=0.06;
+ kGCPtBorderForQt=2.5;
+ break; // RRnew end ////////////////////////////////////////////
+ case 7:
+ kGCQtMax=0.15;
+ kGCdoHighPtQtGammaSelection=kFALSE; // RRnew
+ kGCHighPtQtMax=100.; // RRnew
+ kGCPtBorderForQt=100.; // RRnew
break;
default:
return iResult;
kGCalphaMinCutMeson = 0.5;
kGCalphaCutMeson = 1.;
break;
+ case 3: // 0.0-1
+ kGCalphaMinCutMeson = 0.0;
+ kGCalphaCutMeson = 1.;
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(minRCut){
+ case 0:
+ kGCminRCut=0;
+ kGCmaxRCut = 180.;
+ break;
+ case 1:
+ kGCminRCut=2.8;
+ kGCmaxRCut = 180.;
+ break;
+ case 2:
+ kGCminRCut=5.;
+ kGCmaxRCut = 180.;
+ break;
+ case 3:
+ kGCmaxRCut = 70.;
+ kGCminRCut = 10.;
+ break;
+ case 4:
+ kGCmaxRCut = 70.;
+ kGCminRCut = 5.;
+ break;
+ case 5:
+ kGCmaxRCut = 180.;
+ kGCminRCut = 10.;
+ break;
+
+ default:
+ return iResult;
+ }
+
+ switch(RapidityMesonCut){
+ case 0: //
+ kGCrapidityCutMeson = 0.9;
+ break;
+ case 1: //
+ kGCrapidityCutMeson = 0.8;
+ break;
+ case 2: //
+ kGCrapidityCutMeson = 0.7;
+ break;
+
+ default:
+ return iResult;
+ }
+ switch(BackgroundScheme){
+ case 0: //Rotation
+ kGCUseRotationMethodInBG=kTRUE;
+ kGCdoBGProbability=kFALSE;
+ break;
+ case 1: // mixed event with track multiplicity
+ kGCUseRotationMethodInBG=kFALSE;
+ kGCUseTrackMultiplicityForBG=kFALSE;
+ kGCdoBGProbability=kFALSE;
+ break;
+ case 2: // mixed event with V0 multiplicity
+ kGCUseRotationMethodInBG=kFALSE;
+ kGCUseTrackMultiplicityForBG=kTRUE;
+ kGCdoBGProbability=kFALSE;
+ break;
+ case 3: //Rotation
+ kGCUseRotationMethodInBG=kTRUE;
+ kGCdoBGProbability=kTRUE;
+ break;
default:
return iResult;
}
-
- iResult=1;
+ switch(DegreesForRotationMethod){
+ case 0:
+ kGCnDegreeRotationPMForBG = 5;
+ break;
+ case 1:
+ kGCnDegreeRotationPMForBG = 10;
+ break;
+ case 2:
+ kGCnDegreeRotationPMForBG = 15;
+ break;
+ case 3:
+ kGCnDegreeRotationPMForBG = 20;
+ break;
+
+ default:
+ return iResult;
+ }
+
+ switch(NumberOfRotations){
+ case 0:
+ kGCnumberOfRotationEventsForBG = 5;
+ break;
+ case 1:
+ kGCnumberOfRotationEventsForBG = 10;
+ break;
+ case 2:
+ kGCnumberOfRotationEventsForBG = 15;
+ break;
+ case 3:
+ kGCnumberOfRotationEventsForBG = 20;
+ break;
+ case 4:
+ kGCnumberOfRotationEventsForBG = 2;
+ break;
+ case 5:
+ kGCnumberOfRotationEventsForBG = 50;
+ break;
+ case 6:
+ kGCnumberOfRotationEventsForBG = 80;
+ break;
+ case 7:
+ kGCnumberOfRotationEventsForBG = 100;
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(removePileUp){
+ case 0:
+ kGCRemovePileUp=kFALSE;
+ break;
+ case 1:
+ kGCRemovePileUp=kTRUE;
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(selectV0AND){
+ case 0:
+ kGCSelectV0AND=kFALSE;
+ break;
+ case 1:
+ kGCSelectV0AND=kTRUE;
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(multiplicityBin){
+ case 0:
+ kGCUseMultiplicity=kFALSE;
+ kGCUseMultiplicityBin=0;
+ break;
+ case 1:
+ kGCUseMultiplicity=kTRUE;
+ kGCUseMultiplicityBin=1;
+ break;
+ case 2:
+ kGCUseMultiplicity=kTRUE;
+ kGCUseMultiplicityBin=2;
+ break;
+ case 3:
+ kGCUseMultiplicity=kTRUE;
+ kGCUseMultiplicityBin=3;
+ break;
+ case 4:
+ kGCUseMultiplicity=kTRUE;
+ kGCUseMultiplicityBin=4;
+ break;
+ case 5:
+ kGCUseMultiplicity=kTRUE;
+ kGCUseMultiplicityBin=5;
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(isHeavyIon){
+ case 0:
+ kGCIsHeavyIon=0;
+ break;
+ case 1:
+ kGCIsHeavyIon=1;
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(useCentrality){
+ case 0:
+ kGCUseCentrality=0;
+ break;
+ case 1:
+ kGCUseCentrality=1;// GetCentralityClass10("V0M")
+ break;
+ case 2:
+ kGCUseCentrality=2; // GetCentralityClass10("CL1")
+ break;
+ case 3://////////////// RRnew start //////////////////////////////////////////////////////////////////////////////////////////////////////
+ kGCUseCentrality=3;// GetCentralityClass10("V0M") but with merged bins: see AliAnalysisTaskGammaConversion.cxx
+ break;
+ case 4:
+ kGCUseCentrality=4;// GetCentralityClass10("CL1") but with merged bins: see AliAnalysisTaskGammaConversion.cxx
+ break;/////////////// RRnew end ////////////////////////////////////////////////////////////////////////////////////////////////////////
+ default:
+ return iResult;
+ }
+
+ switch(centralityBin){
+ case 0:
+ kGCUseCentralityBin=0;
+ break;
+ case 1:
+ kGCUseCentralityBin=1;
+ break;
+ case 2:
+ kGCUseCentralityBin=2;
+ break;
+ case 3:
+ kGCUseCentralityBin=3;
+ break;
+ case 4:
+ kGCUseCentralityBin=4;
+ break;
+ case 5:
+ kGCUseCentralityBin=5;
+ break;
+ case 6:
+ kGCUseCentralityBin=6;
+ break;
+ case 7:
+ kGCUseCentralityBin=7;
+ break;
+ case 8:
+ kGCUseCentralityBin=8;
+ break;
+ case 9:
+ kGCUseCentralityBin=9;
+ break;
+ default:
+ return iResult;
+ }
+
+ switch(TOFelectronPID){ // RRnewTOF start //////////////////////////////////////////////////////////////////////////
+ case 0: // no cut
+ kGCuseTOFpid = kFALSE;
+ kGCtofPIDnSigmaBelowElectronLine=-100;
+ kGCtofPIDnSigmaAboveElectronLine=100;
+ break;
+ case 1: // -7,7
+ kGCuseTOFpid = kTRUE;
+ kGCtofPIDnSigmaBelowElectronLine=-7;
+ kGCtofPIDnSigmaAboveElectronLine=7;
+ break;
+ case 2: // -5,5
+ kGCuseTOFpid = kTRUE;
+ kGCtofPIDnSigmaBelowElectronLine=-5;
+ kGCtofPIDnSigmaAboveElectronLine=5;
+ break;
+ case 3: // -3,5
+ kGCuseTOFpid = kTRUE;
+ kGCtofPIDnSigmaBelowElectronLine=-3;
+ kGCtofPIDnSigmaAboveElectronLine=5;
+ break;
+ case 4: // -2,3
+ kGCuseTOFpid = kTRUE;
+ kGCtofPIDnSigmaBelowElectronLine=-2;
+ kGCtofPIDnSigmaAboveElectronLine=3;
+ break;
+ default:
+ return iResult;
+ } //////////////////////// RRnewTOF end //////////////////////////////////////////////////////////////////////////
+
+ switch(useMCPSmearing){
+ case 0:
+ kGCUseMCPSmearing=0;
+ kGCPBremSmearing=1.;
+ kGCPSigSmearing=0.;
+ kGCPSigSmearingCte=0.;
+ break;
+ case 1:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.0e-14;
+ kGCPSigSmearing=0.;
+ kGCPSigSmearingCte=0.;
+ break;
+ case 2:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.0e-15;
+ kGCPSigSmearing=0.0;
+ kGCPSigSmearingCte=0.;
+ break;
+ case 3:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.;
+ kGCPSigSmearing=0.003;
+ kGCPSigSmearingCte=0.002;
+ break;
+ case 4:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.;
+ kGCPSigSmearing=0.003;
+ kGCPSigSmearingCte=0.007;
+ break;
+ case 5:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.;
+ kGCPSigSmearing=0.003;
+ kGCPSigSmearingCte=0.016;
+ break;
+ case 6:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.;
+ kGCPSigSmearing=0.007;
+ kGCPSigSmearingCte=0.016;
+ break;
+ case 7:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.0e-16;
+ kGCPSigSmearing=0.0;
+ kGCPSigSmearingCte=0.;
+ break;
+ case 8:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.;
+ kGCPSigSmearing=0.007;
+ kGCPSigSmearingCte=0.014;
+ break;
+ case 9:
+ kGCUseMCPSmearing=1;
+ kGCPBremSmearing=1.;
+ kGCPSigSmearing=0.007;
+ kGCPSigSmearingCte=0.011;
+ break;
+
+ default:
+ return iResult;
+ }
+ switch(doPhotonAsymmetryCut){
+ case 0:
+ kGCdoPhotonAsymmetryCut=0;
+ kGCMinPPhotonAsymmetryCut=100.;
+ kGCMinPhotonAsymmetry=0.;
+ break;
+ case 1:
+ kGCdoPhotonAsymmetryCut=1;
+ kGCMinPPhotonAsymmetryCut=3.5;
+ kGCMinPhotonAsymmetry=0.04;
+ break;
+ case 2:
+ kGCdoPhotonAsymmetryCut=1;
+ kGCMinPPhotonAsymmetryCut=3.5;
+ kGCMinPhotonAsymmetry=0.06;
+ break;
+ default:
+ return iResult;
+ }
+
+ iResult = 1;
return iResult;
+
}
ASSIGNARRAY(12);
ASSIGNARRAY(13);
ASSIGNARRAY(14);
+ ASSIGNARRAY(15);
+ ASSIGNARRAY(16);
+ ASSIGNARRAY(17);
+ ASSIGNARRAY(18);
+ ASSIGNARRAY(19);
+ ASSIGNARRAY(20);
+ ASSIGNARRAY(21);
+ ASSIGNARRAY(22);
+ ASSIGNARRAY(23);
+ ASSIGNARRAY(24);
+ ASSIGNARRAY(25);
+ ASSIGNARRAY(26); // RRnewTOF
+ ASSIGNARRAY(27);
+ ASSIGNARRAY(28);
}
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff