Bool_t AddAMRsn(TString analysisSource = "proof", TString analysisMode = "test",TString input="aod",TString inputMC="", TString postfix = "",TString idStr="0")
{
- analysisSource.ToLower();analysisMode.ToLower();
+ analysisSource.ToLower(); analysisMode.ToLower();
if (!RsnLoadMacro("RsnManager.C")) return kFALSE;
TList *listRsn = RsnManager();
if (rsnPar) { AliAnalysisAlien::SetupPar(rsnLibName.Data()); myAdditionalLibs += Form(" %s.par",rsnLibName.Data()); }
else { gSystem->Load(Form("lib%s.so",rsnLibName.Data())); myAdditionalLibs += Form(" lib%s.so",rsnLibName.Data()); }
}
+
analysisPlugin->SetAdditionalLibs(myAdditionalLibs.Data());
AliMultiInputEventHandler *multiInputHandler = mgr->GetInputEventHandler();
if (pidResponse) {
// add PID Response Handler
if (!RsnLoadMacro("AddPIDResponseInputHandler.C")) return kFALSE;
- AddPIDResponseInputHandler(multiInputHandler);
+ AddPIDResponseInputHandler(multiInputHandler,useMC);
}
if (useRsnIH) {
if (!RsnLoadMacro("RsnConfig.C")) return kFALSE;
if (!RsnLoadMacro("AddMixingHandler.C")) return kFALSE;
if (!analysisSource.CompareTo("grid")) {
- if (!RsnLoadMacro("RsnGirdPlugin.C")) return kFALSE;
+ if (!RsnLoadMacro("RsnGridPlugin.C")) return kFALSE;
RsnGridPlugin();
}
return kFALSE;
}
+
#include <AliPIDResponseInputHandler.h>
#endif
-void AddPIDResponseInputHandler(AliMultiInputEventHandler *multiInputHandler)
+void AddPIDResponseInputHandler(AliMultiInputEventHandler *multiInputHandler,Bool_t isMC=kFALSE)
{
if (multiInputHandler) {
AliPIDResponseInputHandler *pidResponseIH = new AliPIDResponseInputHandler();
+ pidResponseIH->SetIsMC(isMC);
multiInputHandler->AddInputEventHandler(pidResponseIH);
}
}
AliRsnCutSet *AddRsnCommonPairCuts(AliAnalysisTaskSE *task=0,Bool_t isPP=kTRUE) {
+ AliRsnCutSet *cutsPair = 0;
// TODO
- AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
- // cutY->SetRangeD(-0.5, 0.5);
- cutY->SetRangeD(-0.9, 0.9);
+// AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
+// // cutY->SetRangeD(-0.5, 0.5);
+// cutY->SetRangeD(-0.9, 0.9);
+//
+// cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
+// cutsPair->AddCut(cutY);
+// cutsPair->SetCutScheme(cutY->GetName());
- AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
- cutsPair->AddCut(cutY);
- cutsPair->SetCutScheme(cutY->GetName());
- //
- // AliRsnCutSet *cutsPair = 0;
return cutsPair;
}
numberOfCuts++;
}
if (opt.Contains("mon")) {
- AddMonitorOutput(cuts1->GetMonitorOutput());
+ AddMonitorOutput(cuts1->GetMonitorOutput(),opt);
if (type1 != type2) {
- AddMonitorOutput(cuts2->GetMonitorOutput());
+ AddMonitorOutput(cuts2->GetMonitorOutput(),opt);
}
}
if (isRsnMini) {
// Define single cuts
//---------------------------------------------
- AliRsnCutPID *cut1 = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
+ Double_t etaRange=0.8;
+
+ AliRsnCutValue *cutEta;
+ Bool_t useEta = kFALSE;
+ if (opt.Contains("eta")) {
+ Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
+ useEta = kTRUE;
+ }
+
AliRsnCutSet *cuts1 = new AliRsnCutSet(Form("%sPDG%s",AliPID::ParticleName(type1),opt.Data()), AliRsnTarget::kDaughter);
+
+ Double_t nSigmaTPC=3.0;
+ Double_t nSigmaTOF=3.0;
+ Double_t ptTPCMax=0.8;
+ AliRsnCutKaonForPhi2010 *cutQuality1 = new AliRsnCutKaonForPhi2010("cutKaonPhi2010",nSigmaTPC,nSigmaTOF,ptTPCMax);
+ cutQuality1->SetMode(AliRsnCutKaonForPhi2010::kQuality);
+ cuts1->AddCut(cutQuality1);
+
+ AliRsnCutPID *cut1 = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cuts1->AddCut(cut1);
- cuts1->SetCutScheme(cut1->GetName());
- sel->Add(cuts1, kTRUE);
+ if (useEta) {
+ AliRsnCutValue *cutEta1 = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
+ AliRsnValueDaughter *valEta1 = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1)),AliRsnValueDaughter::kEta);
+ cutEta1->SetValueObj(valEta1);
+ cuts1->AddCut(cutEta1);
+ cuts1->SetCutScheme(Form("%s&%s&%s",cutQuality1->GetName(),cut1->GetName(),cutEta1->GetName()));
+ } else {
+ cuts1->SetCutScheme(Form("%s&%s",cutQuality1->GetName(),cut1->GetName()));
+ }
+ sel->Add(cuts1, kTRUE);
AliRsnCutSet *cuts2 = 0;
if (type1 != type2) {
AliRsnCutPID *cut2 = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE);
+ AliRsnCutKaonForPhi2010 *cutQuality2 = new AliRsnCutKaonForPhi2010("cutKaonPhi2010",nSigmaTPC,nSigmaTOF,ptTPCMax);
+ cutQuality2->SetMode(AliRsnCutKaonForPhi2010::kQuality);
+ cuts2->AddCut(cutQuality2);
+
cuts2 = new AliRsnCutSet(Form("%sPDG%s",AliPID::ParticleName(type2),opt.Data()), AliRsnTarget::kDaughter);
cuts2->AddCut(cut2);
- cuts2->SetCutScheme(cut2->GetName());
+ if (useEta) {
+ AliRsnCutValue *cutEta2 = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange);
+ AliRsnValueDaughter *valEta2 = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2)),AliRsnValueDaughter::kEta);
+ cutEta2->SetValueObj(valEta2);
+ cuts2->AddCut(cutEta2);
+ cuts2->SetCutScheme(Form("%s&%s&%s",cutQuality2->GetName(),cut2->GetName(),cutEta2->GetName()));
+ } else {
+ cuts2->SetCutScheme(Form("%s&%s",cutQuality2->GetName(),cut2->GetName()));
+ }
sel->Add(cuts2, kTRUE);
numberOfCuts++;
}
if (opt.Contains("mon")) {
- AddMonitorOutput(cuts1->GetMonitorOutput());
- AddMonitorOutput(cuts2->GetMonitorOutput());
+ AddMonitorOutput(cuts1->GetMonitorOutput(),opt);
+ if (type1 != type2) AddMonitorOutput(cuts2->GetMonitorOutput());
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
return numberOfCuts;
}
+
+
#ifndef __CINT__
-#include <ANALYSIS/AliAnalysisTaskSE.h>
-#include <PWG2/RESONANCES/AliRsnCutSet.h>
-#include <PWG2/RESONANCES/AliRsnInputHandler.h>
-#include <PWG2/RESONANCES/AliRsnCutKaonForPhi2010.h>
-#include <PWG2/RESONANCES/AliRsnMiniAnalysisTask.h>
-#include <PWG2/RESONANCES/AliRsnAnalysisTask.h>
+#include <PWGLF/RESONANCES/AliRsnCutSet.h>
+#include <PWGLF/RESONANCES/AliRsnInputHandler.h>
+#include <PWGLF/RESONANCES/AliRsnCutKaonForPhi2010.h>
+#include <PWGLF/RESONANCES/AliRsnMiniAnalysisTask.h>
+#include <PWGLF/RESONANCES/AliRsnAnalysisTask.h>
+#include <PWGLF/RESONANCES/AliRsnValueDaughter.h>
+#include <RESONANCES/AliRsnCutPID.h>
+#include <RESONANCES/AliRsnCutKaonForPhi2010PP.h>
+#include <RESONANCES/AliRsnCutValue.h>
#endif
Int_t AddRsnDaughterCutsPhi2010(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
+ Bool_t valid = kTRUE;
+ Int_t isPP = AliAnalysisManager::GetGlobalInt("rsnIsPP",valid);
+
+ Bool_t usePPCut = kFALSE;
+
+ if (isPP && (opt.Contains("usePP"))) usePPCut = kTRUE;
+
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 1;
Printf("AddRsnDaughterCutsPhi2010 Option : %s",opt.Data());
- AliRsnCutKaonForPhi2010 *cut = new AliRsnCutKaonForPhi2010("cutKaonPhi2010",3.0,3.0,0.8);
- if (opt.Contains("qualityonly")) cut->SetMode(AliRsnCutKaonForPhi2010::kQuality);
+ Bool_t useTrackPtCut = kFALSE;
+ Double_t trackPtMin = 0.0;
+ Double_t trackPtMax = 100000.0;
+ Double_t nSigmaTPC=3.0;
+ Double_t nSigmaTOF=3.0;
+ Double_t ptTPCMax=0.6;
+ Double_t etaRange=0.8;
+// etaRange=0.1;
+
+ if (opt.Contains("trackPt")) {
+ useTrackPtCut = kTRUE;
+ if (opt.Contains("trackPtMax18")) trackPtMax = 1.8;
+ if (opt.Contains("trackPtMax20")) trackPtMax = 2.0;
+ if (opt.Contains("trackPtMax25")) trackPtMax = 2.5;
+ }
+
+ if (opt.Contains("TPCsigma1")) nSigmaTPC = 1.0;
+ if (opt.Contains("TPCsigma2")) nSigmaTPC = 2.0;
+ if (opt.Contains("TPCsigma3")) nSigmaTPC = 3.0;
+
+ if (opt.Contains("TOFsigma1")) nSigmaTOF = 1.0;
+ if (opt.Contains("TOFsigma2")) nSigmaTOF = 2.0;
+ if (opt.Contains("TOFsigma3")) nSigmaTOF = 3.0;
+
+
+
+ if (opt.Contains("tpcptMax")) {
+ if (opt.Contains("tpcptMax04")) ptTPCMax=0.4;
+ if (opt.Contains("tpcptMax05")) ptTPCMax=0.5;
+ if (opt.Contains("tpcptMax06")) ptTPCMax=0.6;
+ if (opt.Contains("tpcptMax07")) ptTPCMax=0.7;
+ if (opt.Contains("tpcptMax08")) ptTPCMax=0.8;
+ if (opt.Contains("tpcptMax09")) ptTPCMax=0.9;
+ if (opt.Contains("tpcptMax10")) ptTPCMax=1.0;
+ }
+
+ AliRsnCutKaonForPhi2010PP *cutPP=0;
+ AliRsnCutKaonForPhi2010 *cutPbPb=0;
+ AliRsnCut *cut;
+ if (usePPCut) {
+ Printf("Using AliRsnCutKaonForPhi2010PP ...");
+ AliRsnCutKaonForPhi2010PP *cutPP = new AliRsnCutKaonForPhi2010PP("cutKaonPhi2010PP");
+ cutPP->SetTPCNSigmaLow(nSigmaTPC);
+ cutPP->SetTPCNSigmaHigh(5.0);
+ cutPP->SetTPCLimit(ptTPCMax);
+ cutPP->SetTOFNSigma(nSigmaTOF);
+ cut = cutPP;
+ }
+ else {
+ Printf("Using AliRsnCutKaonForPhi2010 ...");
+ AliRsnCutKaonForPhi2010 *cutPbPb = new AliRsnCutKaonForPhi2010("cutKaonPhi2010",nSigmaTPC,nSigmaTOF,ptTPCMax);
+ if (opt.Contains("qualityonly")) cutPbPb->SetMode(AliRsnCutKaonForPhi2010::kQuality);
+ if (opt.Contains("tofonly")) cutPbPb->SetMode(AliRsnCutKaonForPhi2010::kOnlyTOF);
+ if (opt.Contains("tpconly")) cutPbPb->SetMode(AliRsnCutKaonForPhi2010::kOnlyTPC);
+
+ cut = cutPbPb;
+ }
- if (opt.Contains("tpconly")) {
- cut->SetMode(AliRsnCutKaonForPhi2010::kOnlyTPC);
- if (opt.Contains("sigma1")) cut->SetCutTPC(1.0);
- if (opt.Contains("sigma2")) cut->SetCutTPC(2.0);
- if (opt.Contains("sigma3")) cut->SetCutTPC(3.0);
+ Bool_t usePDG=kFALSE;
+ if (opt.Contains("pdg")) {
+ Printf("Using PDG");
+ usePDG = kTRUE;
}
- if (opt.Contains("tofonly")) {
- cut->SetMode(AliRsnCutKaonForPhi2010::kOnlyTOF);
- if (opt.Contains("sigma1")) cut->SetCutTOF(1.0);
- if (opt.Contains("sigma2")) cut->SetCutTOF(2.0);
- if (opt.Contains("sigma3")) cut->SetCutTOF(3.0);
+
+ Bool_t useEta = kFALSE;
+ if (opt.Contains("eta")) {
+ Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
+ useEta = kTRUE;
}
//---------------------------------------------
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cuts = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
cuts->AddCut(cut);
- cuts->SetCutScheme(cut->GetName());
+
+ TString scheme="";
+ if (useTrackPtCut) {
+ Printf("Adding Pt min=%.3f max=%.3f ...",trackPtMin,trackPtMax);
+ AliRsnValueDaughter *valTrackPt = new AliRsnValueDaughter(Form("val%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt);
+
+ AliRsnCutValue *cutTrackPt = new AliRsnCutValue(Form("cut%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),trackPtMin,trackPtMax);
+ cutTrackPt->SetTargetType(AliRsnTarget::kDaughter);
+ cutTrackPt->SetValueObj(valTrackPt);
+ cuts->AddCut(cutTrackPt);
+ if (!scheme.IsNull()) scheme += "&";
+ scheme += cutTrackPt->GetName();
+ }
+
+
+ if (useEta) {
+ Printf("Adding ETA ...");
+ AliRsnValueDaughter *valEta = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
+ AliRsnCutValue *cutEta = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
+ cutEta->SetTargetType(AliRsnTarget::kDaughter);
+ cutEta->SetValueObj(valEta);
+ cuts->AddCut(cutEta);
+ if (!scheme.IsNull()) scheme += "&";
+ scheme += cutEta->GetName();
+// cuts->SetCutScheme(Form("%s&%s",cut->GetName(),cutEta->GetName()));
+ }
+ if (usePDG) {
+ Printf("Adding PDG ...");
+ AliRsnCutPID *cutPDG = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
+ cuts->AddCut(cutPDG);
+ if (!scheme.IsNull()) scheme += "&";
+ scheme += cutPDG->GetName();
+ }
+
+ if (!scheme.IsNull()) scheme += "&";
+ scheme += cut->GetName();
+
+ Printf ("------ scheme '%s'",scheme.Data());
+ cuts->SetCutScheme(scheme.Data());
if (opt.Contains("mon")) {
- AddMonitorOutput(cuts->GetMonitorOutput());
+ AddMonitorOutput(cuts->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
return numberOfCuts;
}
+
+#ifndef __CINT__
+#include <RESONANCES/AliRsnValuePair.h>
+#endif
+
void AddRsnPairsPhi(AliAnalysisTaskSE *task,
Bool_t isMC,
Bool_t isMixing,
// axes
AliRsnValuePair *axisIM = new AliRsnValuePair("IM", AliRsnValuePair::kInvMass);
AliRsnValuePair *axisPt = new AliRsnValuePair("PT", AliRsnValuePair::kPt);
+ AliRsnValuePair *axisEta = new AliRsnValuePair("ETA", AliRsnValuePair::kEta);
axisIM ->SetBins(300, 0.9, 1.2);
// axisIM ->SetBins(1000, 0.9, 1.9);
axisPt ->SetBins(120, 0.0, 12.0);
+ axisEta ->SetBins(400, -2.0, 2.0);
// output: 2D histogram of inv. mass vs. pt
AliRsnListOutput *outPair = 0;
outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoSparse);
outPair->AddValue(axisIM);
outPair->AddValue(axisPt);
+ outPair->AddValue(axisEta);
}
// add outputs to loop
pair->AddOutput(outPair);
if (isFullOutput) outputType = "SPARSE";
Int_t nIM = 300; Double_t minIM = 0.9, maxIM = 1.2;
- Int_t nEta = 200; Double_t minEta = -1.0, maxEta = 1.0;
+ Int_t nEta = 400; Double_t minEta = -2.0, maxEta = 2.0;
// Int_t nIM = 1000; Double_t minIM = 0.9, maxIM = 1.9;
Int_t nPt = 120; Double_t minPt = 0.0, maxPt = 12.0;
Int_t nCent = 100; Double_t minCent = 0.0, maxCent = 100.0;
#ifndef __CINT__
-#include <PWG2/RESONANCES/AliRsnCutPrimaryVertex.h>
-#include <PWG2/RESONANCES/AliRsnValuePair.h>
-#include <PWG2/RESONANCES/AliRsnListOutput.h>
-#include <PWG2/RESONANCES/AliRsnPairDef.h>
-#include <PWG2/RESONANCES/AliRsnLoopPair.h>
-#include <PWG2/RESONANCES/AliRsnAnalysisTask.h>
-#include <PWG2/RESONANCES/AliRsnLoopDaughter.h>
-#include <PWG2/RESONANCES/AliRsnValueDaughter.h>
-#include <PWG2/RESONANCES/AliRsnMiniAnalysisTask.h>
-#include <PWG2/RESONANCES/AliRsnCutMiniPair.h>
-#include <PWG2/RESONANCES/AliRsnInputHandler.h>
-#include <PWG2/RESONANCES/AliRsnMiniMonitor.h>
-#include <ANALYSIS/AliAnalysisManager.h>
-#include <PWG2/RESONANCES/AliRsnValueEvent.h>
+#include <AliAnalysisManager.h>
+#include <PWGLF/RESONANCES/AliRsnCutPrimaryVertex.h>
+#include <PWGLF/RESONANCES/AliRsnValuePair.h>
+#include <PWGLF/RESONANCES/AliRsnListOutput.h>
+#include <PWGLF/RESONANCES/AliRsnPairDef.h>
+#include <PWGLF/RESONANCES/AliRsnLoopPair.h>
+#include <PWGLF/RESONANCES/AliRsnAnalysisTask.h>
+#include <PWGLF/RESONANCES/AliRsnLoopDaughter.h>
+#include <PWGLF/RESONANCES/AliRsnValueDaughter.h>
+#include <PWGLF/RESONANCES/AliRsnMiniAnalysisTask.h>
+#include <PWGLF/RESONANCES/AliRsnCutMiniPair.h>
+#include <PWGLF/RESONANCES/AliRsnInputHandler.h>
+#include <PWGLF/RESONANCES/AliRsnMiniMonitor.h>
+#include <PWGLF/RESONANCES/AliRsnValueEvent.h>
#endif
Bool_t RsnConfig(AliAnalysisTaskSE *task,Bool_t isMC,Bool_t isMixing,AliRsnInputHandler *rsnIH=0,TList *listRsn=0) {
}
Bool_t valid;
Int_t isRsnMini = AliAnalysisManager::GetGlobalInt("rsnUseMiniPackage",valid);
-
+ TString rsnCutOptCommon = AliAnalysisManager::GetGlobalStr("rsnLegoTrainCommonCutOption",valid);
Int_t cutIndex = 0;
Int_t numOfCuts = 0;
TString rsnName,rsnNameOpt,rsnNameOptFull,rsnCutName,rsnCutOpt,rsnCutNameOptFull;
while ((rsnObj = (TNamed *)next())) {
GetOptionFromString(rsnObj->GetName(),rsnName,rsnNameOpt);
- rsnNameOptFull=rsnName; if (!rsnNameOpt.IsNull()) rsnNameOptFull += Form("_%s",rsnNameOpt.Data());
+ rsnNameOptFull=rsnName;
+ if (!rsnNameOpt.IsNull()) rsnNameOptFull += Form("_%s",rsnNameOpt.Data());
GetOptionFromString(rsnObj->GetTitle(),rsnCutName,rsnCutOpt);
- rsnCutNameOptFull=rsnCutName; if (!rsnCutOpt.IsNull())rsnCutNameOptFull += Form("_%s",rsnCutOpt.Data());
+ rsnCutNameOptFull=rsnCutName;
+ if (!rsnCutOpt.IsNull())rsnCutNameOptFull += Form("_%s",rsnCutOpt.Data());
+
+ if (!rsnCutOptCommon.IsNull()) {
+ if (!rsnCutOpt.IsNull()) rsnCutOpt += "_";
+ rsnCutOpt += rsnCutOptCommon.Data();
+ }
if (!RsnLoadMacroFromConfig(Form("AddRsnDaughterCuts%s.C",rsnCutName.Data()))) return kFALSE;
if (!RsnLoadMacroFromConfig(Form("AddRsnPairs%s.C",rsnName.Data()))) return kFALSE;
Bool_t valid;
TString lego_path = AliAnalysisManager::GetGlobalStr("rsnLegoTrainPath",valid);
- if (!valid) lego_path = "$ALICE_ROOT/PWG2/RESONANCES/macros/lego_train";
+ if (!valid) lego_path = "$ALICE_ROOT/PWGLF/RESONANCES/macros/lego_train";
if (!gSystem->AccessPathName(macro.Data())) {
gROOT->LoadMacro(macro.Data());
// void AddMonitorOutput(AliRsnLoopDaughter *mon)
-void AddMonitorOutput(TObjArray *mon)
+void AddMonitorOutput(TObjArray *mon,TString opt="")
{
- if (!mon) {Printf("Error: mon is null !!!!");return;}
+ if (!mon) {
+ Printf("Error: mon is null !!!!");
+ return;
+ }
Bool_t valid;
- Int_t useMCMomentum = AliAnalysisManager::GetGlobalInt("rsnUseMCMomentum",valid);
- if (useMCMomentum) return;
+ Int_t useMCMon = AliAnalysisManager::GetGlobalInt("rsnUseMCMonitoring",valid);
+// if (useMCMon) return;
// dEdx tpc
AliRsnValueDaughter *axisMomTPC = new AliRsnValueDaughter("pTPC", AliRsnValueDaughter::kPtpc);
outMonitordEdxTOF->AddValue(axisSigTOF);
// add outputs to loop
- // mon->Add(outMonitordEdxTOF);
+ mon->Add(outMonitordEdxTOF);
// Momentum
// add outputs to loop
mon->Add(outMonitorP);
+
+ if (useMCMon) {
+ AliRsnValueDaughter *axisMomPMC = new AliRsnValueDaughter("pMC", AliRsnValueDaughter::kP);
+ axisMomPMC->SetUseMCInfo(kTRUE);
+ axisMomPMC->SetBins(0.0,5.0,0.01);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorPMC = new AliRsnListOutput("PMC", AliRsnListOutput::kHistoDefault);
+ outMonitorPMC->AddValue(axisMomPMC);
+
+ // add outputs to loop
+ mon->Add(outMonitorPMC);
+ }
+
+
// Momentum Pt
AliRsnValueDaughter *axisMomPt = new AliRsnValueDaughter("pt", AliRsnValueDaughter::kPt);
axisMomPt->SetBins(0.0,5.0,0.01);
// add outputs to loop
mon->Add(outMonitorPt);
+ if (useMCMon) {
+ // Momentum Pt
+ AliRsnValueDaughter *axisMomPtMC = new AliRsnValueDaughter("ptMC", AliRsnValueDaughter::kPt);
+ axisMomPtMC->SetUseMCInfo(kTRUE);
+ axisMomPtMC->SetBins(0.0,5.0,0.01);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorPtMC = new AliRsnListOutput("PtMC", AliRsnListOutput::kHistoDefault);
+ outMonitorPtMC->AddValue(axisMomPtMC);
+
+ // add outputs to loop
+ mon->Add(outMonitorPtMC);
+ }
+
// Eta
AliRsnValueDaughter *axisMomEta = new AliRsnValueDaughter("eta", AliRsnValueDaughter::kEta);
axisMomEta->SetBins(-1.0,1.0,0.01);
// add outputs to loop
mon->Add(outMonitorEta);
+ if (useMCMon) {
+ // Eta
+ AliRsnValueDaughter *axisMomEtaMC = new AliRsnValueDaughter("etaMC", AliRsnValueDaughter::kEta);
+ axisMomEtaMC->SetUseMCInfo(kTRUE);
+ axisMomEtaMC->SetBins(-1.0,1.0,0.01);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorEtaMC = new AliRsnListOutput("EtaMC", AliRsnListOutput::kHistoDefault);
+ outMonitorEtaMC->AddValue(axisMomEtaMC);
+
+ // add outputs to loop
+ mon->Add(outMonitorEtaMC);
+ }
// kTOFnsigmaK
AliRsnValueDaughter *axisTPCnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTPCnsigmaK);
- axisTPCnsigmaK->SetBins(1000,0,100);
+ axisTPCnsigmaK->SetBins(1001,-100,100);
// output: 2D histogram of TPC signal vs. TPC momentum
AliRsnListOutput *outMonitorTPCnsigmaK = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault);
// kTPCnsigmaPi
AliRsnValueDaughter *axisTPCnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTPCnsigmaPi);
- axisTPCnsigmaPi->SetBins(1000,0,100);
+ axisTPCnsigmaPi->SetBins(1001,-100,100);
// output: 2D histogram of TPC signal vs. TPC momentum
AliRsnListOutput *outMonitorTPCnsigmaPi = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault);
// kTPCnsigmaP
AliRsnValueDaughter *axisTPCnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTPCnsigmaP);
- axisTPCnsigmaP->SetBins(1000,0,100);
+ axisTPCnsigmaP->SetBins(1001,-100,100);
// output: 2D histogram of TPC signal vs. TPC momentum
AliRsnListOutput *outMonitorTPCnsigmaP = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault);
mon->Add(outMonitorTPCnsigmaP);
- // kTOFnsigmaK
- AliRsnValueDaughter *axisTOFnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTOFnsigmaK);
- axisTOFnsigmaK->SetBins(1000,0,100);
+ if (!opt.Contains("NoTOFSIGMA")) {
- // output: 2D histogram of TPC signal vs. TPC momentum
- AliRsnListOutput *outMonitorTOFnsigmaK = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault);
- outMonitorTOFnsigmaK->AddValue(axisTOFnsigmaK);
+ // kTOFnsigmaK
+ AliRsnValueDaughter *axisTOFnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTOFnsigmaK);
+ axisTOFnsigmaK->SetBins(1001,-100,100);
- // add outputs to loop
- mon->Add(outMonitorTOFnsigmaK);
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorTOFnsigmaK = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFnsigmaK->AddValue(axisTOFnsigmaK);
- // kTOFnsigmaPi
- AliRsnValueDaughter *axisTOFnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTOFnsigmaPi);
- axisTOFnsigmaPi->SetBins(1000,0,100);
+ // add outputs to loop
+ mon->Add(outMonitorTOFnsigmaK);
- // output: 2D histogram of TPC signal vs. TPC momentum
- AliRsnListOutput *outMonitorTOFnsigmaPi = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault);
- outMonitorTOFnsigmaPi->AddValue(axisTOFnsigmaPi);
+ // kTOFnsigmaPi
+ AliRsnValueDaughter *axisTOFnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTOFnsigmaPi);
+ axisTOFnsigmaPi->SetBins(1001,-100,100);
- // add outputs to loop
- mon->Add(outMonitorTOFnsigmaPi);
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorTOFnsigmaPi = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFnsigmaPi->AddValue(axisTOFnsigmaPi);
- // kTOFnsigmaP
- AliRsnValueDaughter *axisTOFnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTOFnsigmaP);
- axisTOFnsigmaP->SetBins(1000,0,100);
+ // add outputs to loop
+ mon->Add(outMonitorTOFnsigmaPi);
- // output: 2D histogram of TPC signal vs. TPC momentum
- AliRsnListOutput *outMonitorTOFnsigmaP = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault);
- outMonitorTOFnsigmaP->AddValue(axisTOFnsigmaP);
+ // kTOFnsigmaP
+ AliRsnValueDaughter *axisTOFnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTOFnsigmaP);
+ axisTOFnsigmaP->SetBins(1001,-100,100);
- // add outputs to loop
- mon->Add(outMonitorTOFnsigmaP);
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorTOFnsigmaP = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFnsigmaP->AddValue(axisTOFnsigmaP);
+
+ // add outputs to loop
+ mon->Add(outMonitorTOFnsigmaP);
+ }
AliRsnListOutput *outMonitorPTvsMult = new AliRsnListOutput("PTvsMult",AliRsnListOutput::kHistoDefault);
if (!gGrid) TGrid::Connect("alien://");
if (!gGrid) return;
TGridResult *r = gGrid->Query(Form("%s/RsnTrain/%s",gGrid->GetHomeDirectory(),rsnTrainName.Data()),"*/analysis.root");
- TString s = r->GetKey(r->GetSize()-1,"lfn");
- s.ReplaceAll("/analysis.root","");
- s = gSystem->BaseName(s);
- Int_t idRsnTrain = s.Atoi()+1;
+ Int_t idRsnTrain = 0;
+ if (r) {
+ TString s = r->GetKey(r->GetSize()-1,"lfn");
+ s.ReplaceAll("/analysis.root","");
+ s = gSystem->BaseName(s);
+ if (!s.IsNull()) idRsnTrain = s.Atoi()+1;
+ }
rsnTrainName.Append(Form("/%03d",idRsnTrain));
TString rsnTrainWkDir = Form("RsnTrain/%s",rsnTrainName.Data());
plugin->SetGridOutputDir("output"); // In this case will be $HOME/work/output
plugin->SetAPIVersion("V1.1x");
-
+
TString rootver = AliAnalysisManager::GetGlobalStr("rsnLegoTrainROOTversion",valid);
plugin->SetROOTVersion(rootver.Data());
RsnSetData(plugin,dsConfig,1000);
- plugin->SetSplitMaxInputFileNumber(50);
+ plugin->SetSplitMaxInputFileNumber(25);
// Fatal("RsnDataSet","No dataset found !!!");
}
}
-void GetParameterFromConfig(TString &str,TString token="="){
+void GetParameterFromConfig(TString &str,TString token="=") {
TObjArray *array = str.Tokenize(token.Data());
TObjString *strObj = (TObjString *)array->At(1);
if (strObj) str = strObj->GetString();
Int_t isPP = 1; // in GRID case it will be overwriten
Int_t useRsnMini = 1;
- Int_t useMixing = 1;
+ Int_t useMixing = 0;
Int_t numMix = 10;
Int_t fullOutput = 1;
Int_t mcMomentum = 0;
+ Int_t mcMon = 0;
Int_t useEventMixPar = 0;
Int_t useRsnPar = 0;
-
- TString rootver = "v5-30-06";
+
+ TString rootver = "v5-30-06-1";
TString alirootver = "";
-// alirootver = "v5-02-17-AN";
-
+ // alirootver = "v5-02-17-AN";
+
TString legoTrainPath = "$ALICE_ROOT/PWGLF/RESONANCES/macros/lego_train";
-// legoTrainPath = "$HOME/git/PWG2resonances/PWG2/RESONANCES/macros/lego_train";
+// legoTrainPath = "$HOME/git/AliRsn/PWGLF/RESONANCES/macros/lego_train";
TList *listRsn = new TList();
// Note : for now you have to set gRsnUseMiniPackage = 0 to have mon histograms
// listRsn->Add(new TNamed("<Name>:mon","<CutName>:<opt>"));
-
- // listRsn->Add(new TNamed("Phi","Phi2010"));
- listRsn->Add(new TNamed("Phi","Phi2010:mon"));
-// listRsn->Add(new TNamed("Phi","Phi2010:tpconly_sigma1_mon"));
-// listRsn->Add(new TNamed("Phi","Phi2010:tpconly_sigma2_mon"));
-// listRsn->Add(new TNamed("Phi","Phi2010:tpconly_sigma3_mon"));
-// listRsn->Add(new TNamed("Phi","Phi2010:tofonly_sigma1_mon"));
-// listRsn->Add(new TNamed("Phi","Phi2010:tofonly_sigma2_mon"));
-// listRsn->Add(new TNamed("Phi","Phi2010:tofonly_sigma3_mon"));
-// listRsn->Add(new TNamed("Phi","BPID:mon"));
-// listRsn->Add(new TNamed("Phi","Phi2010:qualityonly_mon"));
- //
- // // in case you have MC
- // listRsn->Add(new TNamed("Phi","PDG:mon"));
- //
- // listRsn->Add(new TNamed("KStar","KStar2010:mon"));
- // listRsn->Add(new TNamed("KStar","BPID:mon"));
-
- // listRsn->Add(new TNamed("KStar","KStar:mon"));
- // listRsn->Add(new TNamed("KStar","KStar:TPCTOFpidDefaultKstarPP2010_mon"));
- // listRsn->Add(new TNamed("KStar","KStar:FastTPCpid1point5sigma_mon"));
- // listRsn->Add(new TNamed("KStar","KStar:FastTPCpid2sigma_mon"));
+ TString commonCutOption="";
+// commonCutOption="mon_eta";
+
+ listRsn->Add(new TNamed("Phi","Phi2010"));
+// listRsn->Add(new TNamed("Phi","Phi2010:pdg"));
+//
+// listRsn->Add(new TNamed("Phi","Phi2010:trackPtMax18"));
+// listRsn->Add(new TNamed("Phi","Phi2010:trackPtMax18_pdg"));
+//
+// listRsn->Add(new TNamed("Phi","Phi2010:usePP"));
+// listRsn->Add(new TNamed("Phi","Phi2010:usePP_pdg"));
+//
+// listRsn->Add(new TNamed("Phi","Phi2010:usePP_trackPtMax18"));
+// listRsn->Add(new TNamed("Phi","Phi2010:usePP_trackPtMax18_pdg"));
+//
+// // listRsn->Add(new TNamed("Phi","Phi2010:tpconly_TPCsigma1"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:tpconly_TPCsigma2"));
+// listRsn->Add(new TNamed("Phi","Phi2010:tpconly_TPCsigma3"));
+// listRsn->Add(new TNamed("Phi","Phi2010:tpconly_TPCsigma3_pdg"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:tofonly_TOFsigma1"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:tofonly_TOCsigma2"));
+// listRsn->Add(new TNamed("Phi","Phi2010:tofonly_TOCsigma3"));
+// listRsn->Add(new TNamed("Phi","Phi2010:tofonly_TOCsigma3_pdg"));
+// listRsn->Add(new TNamed("Phi","Phi2010:tofonly_TOCsigma3_trackPtMax18"));
+// listRsn->Add(new TNamed("Phi","Phi2010:tofonly_TOCsigma3_trackPtMax18_pdg"));
+//
+//
+// // listRsn->Add(new TNamed("Phi","BPID"));
+// listRsn->Add(new TNamed("Phi","Phi2010:qualityonly"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:tpcptMax05"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:tpcptMax06"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:tpcptMax07"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:tpcptMax08"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:TPCsigma1_tpcptMax06"));
+// // listRsn->Add(new TNamed("Phi","Phi2010:TPCsigma1_tpcptMax08"));
+//
+// //
+// // // in case you have MC
+// // listRsn->Add(new TNamed("Phi","PDG"));
+// listRsn->Add(new TNamed("Phi","PDG:NoTOFSIGMA"));
+// //
+// // listRsn->Add(new TNamed("KStar","KStar2010:mon"));
+// // listRsn->Add(new TNamed("KStar","BPID:mon"));
+//
+// // listRsn->Add(new TNamed("KStar","KStar:mon"));
+// // listRsn->Add(new TNamed("KStar","KStar:TPCTOFpidDefaultKstarPP2010_mon"));
+// // listRsn->Add(new TNamed("KStar","KStar:FastTPCpid1point5sigma_mon"));
+// // listRsn->Add(new TNamed("KStar","KStar:FastTPCpid2sigma_mon"));
//============= ONLY for GRID ====================
TString dsConfig;
-// isPP = 0;
-// dsConfig = "datasets-grid/LHC10h_p2_ESD.txt";
-// dsConfig = "datasets-grid/LHC10h_p2_AOD049.txt";
-// dsConfig = "datasets-grid/LHC10h_p2_AOD073.txt";
+ // isPP = 0;
+ // dsConfig = "datasets-grid/LHC10h_p2_ESD.txt";
+ // dsConfig = "datasets-grid/LHC10h_p2_AOD049.txt";
+ // dsConfig = "datasets-grid/LHC10h_p2_AOD073.txt";
-// dsConfig = "datasets-grid/LHC11a10b_AOD080.txt";
+ // dsConfig = "datasets-grid/LHC11a10b_AOD080.txt";
-// isPP = 1;
-// dsConfig = "datasets-grid/LHC10b_p2_ESD.txt";
-// dsConfig = "datasets-grid/LHC10b_p2_AOD038.txt";
+ // isPP = 1;
+ // dsConfig = "datasets-grid/LHC10b_p2_ESD.txt";
+ // dsConfig = "datasets-grid/LHC10b_p2_AOD038.txt";
+ // pp 2.76 TeV data
isPP = 1;
+ // data
dsConfig = "datasets-grid/LHC11a_AOD072.txt";
+ // mc
dsConfig = "datasets-grid/LHC11h5b_AOD079.txt";
+ dsConfig = "datasets-grid/LHC11e3a_AOD074.txt";
+
//================================================
///////////////////////////////////////////
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
- if (!mgr) { Printf("Error[RsnManager] mgr is null !!!"); return 0; }
+ if (!mgr) {
+ Printf("Error[RsnManager] mgr is null !!!");
+ return 0;
+ }
AliAnalysisManager::SetGlobalStr("rsnLegoTrainPath",legoTrainPath.Data());
// oputput settings
AliAnalysisManager::SetGlobalInt("rsnOutputFull",fullOutput);
AliAnalysisManager::SetGlobalInt("rsnUseMCMomentum",mcMomentum);
+ AliAnalysisManager::SetGlobalInt("rsnUseMCMonitoring",mcMon);
+
// expert options (don't change)
AliAnalysisManager::SetGlobalInt("rsnMixPrintRefresh",-1);
AliAnalysisManager::SetGlobalStr("rsnLegoTrainROOTversion",rootver.Data());
AliAnalysisManager::SetGlobalStr("rsnLegoTrainAliROOTversion",alirootver.Data());
+
+ AliAnalysisManager::SetGlobalStr("rsnLegoTrainCommonCutOption",commonCutOption.Data());
+
+
return listRsn;
}
// adds all tasks
if (!AddAllManagers(listManagers, anSrc, anMode,input,inputMC)) { Printf("Error : AddAllManagers failed !!!"); return kFALSE;}
+ gSystem->ListLibraries("ls");
+
TStopwatch timer;
timer.Start();
// runs analysis
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff