--- /dev/null
+#ifndef __CINT__
+#include <TString.h>
+#include <TROOT.h>
+#include <TSystem.h>
+#include <ANALYSIS/AliAnalysisManager.h>
+#include <PWG2/RESONANCES/AliRsnInputHandler.h>
+#include <ANALYSIS/AliAnalysisAlien.h>
+#include <ANALYSIS/AliAnalysisTaskSE.h>
+#endif
+
+Bool_t AddAMRsn(TString analysisSource = "proof", TString analysisMode = "test",TString input="aod",TString inputMC="", TString postfix = "",TString idStr="0")
+{
+
+ gROOT->LoadMacro("RsnManager.C");
+ TList *listRsn = RsnManager();
+
+ Bool_t useMC = !inputMC.CompareTo("mc");
+
+ // ALICE stuff
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) { Printf("Error[AddAMRsn] mgr is null !!!"); return kFALSE; }
+
+ AliAnalysisGrid *analysisPlugin = mgr->GetGridHandler();
+ if (!analysisPlugin) { Printf("Error[AddAMRsn] : analysisPlugin is null !!!"); return kFALSE; }
+
+ if (gRsnUseEventMixingPar) gRsnUseRSNPar = 1;
+
+ TString myAdditionalLibs;
+ if (gRsnUseEventMixingPar) { AliAnalysisAlien::SetupPar("EventMixing"); myAdditionalLibs += " EventMixing.par"; }
+ else { gSystem->Load("libEventMixing.so"); myAdditionalLibs += " libEventMixing.so"; }
+
+ if (gRsnUseRSNPar) { AliAnalysisAlien::SetupPar("PWG2resonances"); myAdditionalLibs += " PWG2resonances.par"; }
+ else { gSystem->Load("libPWG2resonances.so"); myAdditionalLibs += " libPWG2resonances.so"; }
+
+ analysisPlugin->SetAdditionalLibs(myAdditionalLibs.Data());
+
+
+ AliMultiInputEventHandler *multiInputHandler = mgr->GetInputEventHandler();
+ AliRsnInputHandler *rsnIH=0;
+
+ if (gRsnUsePIDResponse) {
+ // add PID Response Handler
+ gROOT->LoadMacro("AddPIDResponseInputHandler.C");
+ AddPIDResponseInputHandler(multiInputHandler);
+ }
+
+ if (gRsnUseRsnInputHandler) {
+ // add Rsn input handler (it has to be after ESD,MC,Tender input handler, but before Mixing)
+ AliRsnInputHandler *rsnIH = new AliRsnInputHandler();
+ multiInputHandler->AddInputEventHandler(rsnIH);
+ }
+
+ if (gRsnUsePhysSel) {
+ gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
+ AddTaskPhysicsSelection(useMC);
+
+ // maybe we can put it in $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C
+ AliMultiInputEventHandler *multiIH = dynamic_cast<AliMultiInputEventHandler *>(mgr->GetInputEventHandler());
+ if (multiIH) {
+ AliESDInputHandler *esdIH = dynamic_cast<AliESDInputHandler *>(multiIH->GetFirstInputEventHandler());
+ if (esdIH) esdIH->SetEventSelection(multiIH->GetEventSelection());
+ AliAODInputHandler *aodIH = dynamic_cast<AliAODInputHandler *>(multiIH->GetFirstInputEventHandler());
+ if (aodIH) aodIH->SetEventSelection(multiIH->GetEventSelection());
+ }
+ }
+
+
+ // load and run AddTask macro
+ gROOT->LoadMacro("AddRsnAnalysisTask.C");
+ gROOT->LoadMacro("RsnConfig.C");
+ gROOT->LoadMacro("AddMixingHandler.C");
+
+ if (gRsnSplitMgrByTasks) {
+ Int_t iTask=0;
+ TList *l=0;
+ TNamed *rsnObj = 0;
+ AliAnalysisTaskSE *task=0;
+ TString rsnName,rsnCutName;
+ TIter next(listRsn);
+ while ((rsnObj = (TNamed *)next())) {
+ l = new TList();
+ Printf("Adding task for RSN:%s CUT:%s ",rsnObj->GetName(),rsnObj->GetTitle());
+ l->Add(new TNamed(*rsnObj));
+ task = AddRsnAnalysisTask(input, useMC, gRsnUseMixing,rsnIH,l,Form("%s_%d",postfix.Data(),iTask++));
+ if (gRsnUseMixing) {
+ // add mixing handler (uncomment to turn on Mixnig)
+ AddMixingHandler(multiInputHandler,task, input, useMC,gRsnUseMiniPackage, gRsnNumMix,postfix);
+ }
+ }
+ } else {
+ task = AddRsnAnalysisTask(input, useMC, gRsnUseMixing,rsnIH,listRsn,postfix);
+ if (gRsnUseMixing) {
+ // add mixing handler (uncomment to turn on Mixnig)
+ AddMixingHandler(multiInputHandler,task, input, useMC,gRsnUseMiniPackage, gRsnNumMix,postfix);
+ }
+ }
+
+
+
+
+ return kTRUE;
+}
--- /dev/null
+#ifndef __CINT__
+#include <ANALYSIS/AliAnalysisManager.h>
+#include <ANALYSIS/EventMixing/AliAnalysisTaskMixInfo.h>
+#include <ANALYSIS/AliAnalysisDataContainer.h>
+#endif
+void AddAnalysisTaskMixInfo(TString opts = "")
+{
+ // create manager
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) return;
+
+ // create our task
+ AliAnalysisTaskMixInfo *task = new AliAnalysisTaskMixInfo("AliAnalysisTaskMixInfo");
+// Int_t debugLevel = 1;
+// TString myclasses = "";
+// myclasses += ":AliAnalysisTaskMixInfo";
+//
+// if (!myclasses.IsNull()) task->SetLogType(AliLog::kDebug + debugLevel, myclasses.Data());
+
+ // create mix output container
+ AliAnalysisDataContainer *outputMix = mgr->CreateContainer("cMixInfoList", TList::Class(), AliAnalysisManager::kOutputContainer, Form("MixInfo%s.root", opts.Data()));
+
+ // add our task to the manager
+ mgr->AddTask(task);
+
+ // finaly connect input and output
+ mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(task, 1, outputMix);
+
+}
--- /dev/null
+#ifndef __CINT__
+#include <AliAnalysisManager.h>
+#include <AliMultiInputEventHandler.h>
+#include <ANALYSIS/EventMixing/AliMixEventPool.h>
+#include <ANALYSIS/EventMixing/AliMixEventCutObj.h>
+#include <PWG2/RESONANCES/AliRsnAnalysisTask.h>
+#include <PWG2/RESONANCES/AliRsnMiniAnalysisTask.h>
+#endif
+
+void AddMixingHandler ( AliMultiInputEventHandler *multiInputHandler,AliAnalysisTaskSE *task, TString format = "esd", Bool_t useMC = kFALSE,Bool_t isRsnMini=kFALSE,const Int_t mixNum = 10, TString opts = "" ) {
+
+
+ Bool_t isPP = kTRUE;
+ if (gRsnUseMiniPackage) {
+ AliRsnMiniAnalysisTask *taskRsn = (AliRsnMiniAnalysisTask *) task;
+
+ // settings
+ if (isPP)
+ taskRsn->UseMultiplicity("QUALITY");
+ else
+ taskRsn->UseCentrality("V0M");
+
+ // set mixing
+ taskRsn->UseContinuousMix();
+ //task->UseBinnedMix();
+ taskRsn->SetNMix(mixNum);
+ taskRsn->SetMaxDiffVz(1.0);
+ taskRsn->SetMaxDiffMult(10.0);
+ taskRsn->SetMaxDiffAngle(1E20);
+
+ } else {
+ if ( !multiInputHandler ) return;
+
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ const Int_t bufferSize = 1;
+ AliMixInputEventHandler *mixHandler = new AliMixInputEventHandler ( bufferSize, mixNum );
+ mixHandler->SetInputHandlerForMixing ( dynamic_cast<AliMultiInputEventHandler *> ( mgr->GetInputEventHandler() ) );
+ AliMixEventPool *evPool = new AliMixEventPool();
+
+ AliMixEventCutObj *multi = 0;
+
+ if (isPP) {
+ multi = new AliMixEventCutObj ( AliMixEventCutObj::kMultiplicity, 2, 102, 10 );
+ } else {
+ multi = new AliMixEventCutObj ( AliMixEventCutObj::kCentrality, 0, 100, 10, "V0M" );
+ }
+ AliMixEventCutObj *zvertex = new AliMixEventCutObj ( AliMixEventCutObj::kZVertex, -10, 10, 1 );
+
+ evPool->AddCut(multi);
+ evPool->AddCut ( zvertex );
+
+ // adds event pool (comment it and u will have default mixing)
+ mixHandler->SetEventPool ( evPool );
+
+// mixHandler->SelectCollisionCandidates(AliVEvent::kAny);
+
+// mixHandler->DoMixIfNotEnoughEvents(kFALSE);
+
+ multiInputHandler->AddInputEventHandler ( mixHandler );
+
+ // adds mixing info task
+ gROOT->LoadMacro ( "AddAnalysisTaskMixInfo.C" );
+ AddAnalysisTaskMixInfo (opts );
+
+ }
+}
--- /dev/null
+#ifndef __CINT__
+#include <AliPIDResponseInputHandler.h>
+#endif
+
+void AddPIDResponseInputHandler(AliMultiInputEventHandler *multiInputHandler)
+{
+ if (multiInputHandler) {
+ AliPIDResponseInputHandler *pidResponseIH = new AliPIDResponseInputHandler();
+ multiInputHandler->AddInputEventHandler(pidResponseIH);
+ }
+}
--- /dev/null
+#ifndef __CINT__
+#include <TString.h>
+#include <ANALYSIS/AliAnalysisManager.h>
+#include <AliRsnAnalysisTask.h>
+#include <PWG2/RESONANCES/AliRsnDaughterSelector.h>
+#include <PWG2/RESONANCES/AliRsnMiniAnalysisTask.h>
+#endif
+AliAnalysisTaskSE *AddRsnAnalysisTask(TString format = "esd", Bool_t useMC = kFALSE,Bool_t isMixing = kFALSE,AliRsnInputHandler *rsnIH=0,TList *listRsn=0,TString postfix="")
+{
+ // create manager
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) { Printf("Error [AddRsnAnalysisTask%s] : mgr is null !!!",postfix.Data()); return 0;}
+
+ // initialize task with all available slots, even if not all of them will be used:
+ AliAnalysisTaskSE *task = 0;
+
+ if (gRsnUseMiniPackage) {
+ postfix.Prepend("Mini");
+ AliRsnMiniAnalysisTask *taskRsnMini = new AliRsnMiniAnalysisTask(Form("Rsn%s",postfix.Data()),useMC);
+ taskRsnMini->SetMixPrintRefresh(gRsnMixPrintRefresh);
+ Printf("sssssssss %d",gRsnMixPrintRefresh);
+ task = (AliAnalysisTaskSE *) taskRsnMini;
+ }
+ else {
+ AliRsnAnalysisTask *taskRsn = new AliRsnAnalysisTask(Form("Rsn%s",postfix.Data()));
+ task = (AliAnalysisTaskSE *) taskRsn;
+ }
+
+ Printf("pointer is %p",task);
+
+// gROOT->LoadMacro("RsnConfig.C");
+ if (!RsnConfig(task,useMC,isMixing,rsnIH,listRsn)) {
+ Printf("Error in RsnConfig.C");
+ return 0;
+ }
+
+ // add the task to manager
+ mgr->AddTask(task);
+
+ AliRsnDaughterSelector *sel = 0;
+
+ if (!gRsnUseMiniPackage) {
+ sel = rsnIH->GetSelector();
+ sel->Init();
+ }
+
+ // connect input container according to source choice
+ mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
+
+ // create paths for the output in the common file
+ TString commonPath = AliAnalysisManager::GetCommonFileName();
+
+ // create containers for output
+ AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnHist%s", postfix.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, commonPath.Data());
+
+ // big outout (expert only)
+ Int_t useBigOutput = 0;
+ if (useBigOutput) {
+ Printf("Using Big output ...");
+ task->UseBigOutput();
+ output->SetSpecialOutput();
+ mgr->SetSpecialOutputLocation("root://lx000.saske.sk:21094//tmp/mvala/");
+ }
+
+ mgr->ConnectOutput(task, 1, output);
+
+ return task;
+}
--- /dev/null
+AliRsnCutSet *AddRsnCommonEventCuts(AliAnalysisTaskSE *task=0,Bool_t isPP=kTRUE) {
+
+// return 0;
+ // primary vertex:
+ // - 2nd argument --> |Vz| range
+ // - 3rd argument --> minimum required number of contributors
+ // - 4th argument --> tells if TPC stand-alone vertexes must be accepted
+ // we switch on the check for pileup
+ AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
+ if (isPP) cutVertex->SetCheckPileUp(kTRUE);
+
+ // primary vertex is always used
+ AliRsnCutSet *commonEventCuts = new AliRsnCutSet("commonEventCuts", AliRsnTarget::kEvent);
+ commonEventCuts->AddCut(cutVertex);
+ commonEventCuts->SetCutScheme(cutVertex->GetName());
+
+ // if task is mini
+
+ if (gRsnUseMiniPackage) {
+ AliRsnMiniAnalysisTask *taskRsn = (AliRsnMiniAnalysisTask *)task;
+ taskRsn->SetEventCuts(commonEventCuts);
+ }
+
+ return commonEventCuts;
+}
--- /dev/null
+AliRsnCutSet *AddRsnCommonPairCuts(AliAnalysisTaskSE *task=0,Bool_t isPP=kTRUE) {
+// TODO
+// AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
+// cutY->SetRangeD(-0.5, 0.5);
+//
+// AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
+// cutsPair->AddCut(cutY);
+// cutsPair->SetCutScheme(cutY->GetName());
+//
+ AliRsnCutSet *cutsPair = 0;
+ return cutsPair;
+}
--- /dev/null
+#ifndef __CINT__
+#include <PWG2/RESONANCES/AliRsnCutPID.h>
+#include <PWG2/RESONANCES/AliRsnInputHandler.h>
+#include <PWG2/RESONANCES/AliRsnCutSet.h>
+#endif
+
+Int_t AddRsnDaughterCutsBPID(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
+{
+
+ if (!rsnIH) return 0;
+
+ // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
+ Int_t numberOfCuts = 1;
+
+ // gets selector
+ AliRsnDaughterSelector *sel = rsnIH->GetSelector();
+
+ //---------------------------------------------
+ // Define single cuts
+ //---------------------------------------------
+
+ AliRsnCutPID *cut1 = new AliRsnCutPID(Form("cut%sBPID%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kFALSE);
+ AliRsnCutSet *cuts1 = new AliRsnCutSet(Form("%sBPID%s",AliPID::ParticleName(type1),opt.Data()), AliRsnTarget::kDaughter);
+ cuts1->AddCut(cut1);
+ cuts1->SetCutScheme(cut1->GetName());
+ sel->Add(cuts1, kTRUE);
+
+
+ AliRsnCutSet *cuts2 = 0;
+ if (type1 != type2) {
+ AliRsnCutPID *cut2 = new AliRsnCutPID(Form("cut%sBPID%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kFALSE);
+ cuts2 = new AliRsnCutSet(Form("%sBPID%s",AliPID::ParticleName(type2),opt.Data()), AliRsnTarget::kDaughter);
+ cuts2->AddCut(cut2);
+ cuts2->SetCutScheme(cut2->GetName());
+ sel->Add(cuts2, kTRUE);
+ numberOfCuts++;
+ }
+ if (opt.Contains("mon")) {
+ TObjArray *output = new TObjArray;
+ AddMonitorOutput(output);
+ cuts1->SetMonitorOutput(output);
+
+ output = new TObjArray;
+ AddMonitorOutput(output);
+ cuts2->SetMonitorOutput(output);
+ }
+ if (isRsnMini) {
+ AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
+ if (taskRsnMini) {
+ taskRsnMini->AddTrackCuts(cuts1);
+ if (type1 != type2) taskRsnMini->AddTrackCuts(cuts2);
+ }
+ } else {
+ AliRsnDaughterSelector *sel = rsnIH->GetSelector();
+ sel->Add(cuts1, kTRUE);
+ if (type1 != type2) sel->Add(cuts2, kTRUE);
+ }
+
+
+ return numberOfCuts;
+}
--- /dev/null
+#ifndef __CINT__
+#include <PWG2/RESONANCES/AliRsnInputHandler.h>
+#include <PWG2/RESONANCES/AliRsnCutSet.h>
+#include <PWG2/RESONANCES/AliRsnCutDaughterKStar2010PP.h>
+#endif
+Int_t AddRsnDaughterCutsKStar2010(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
+{
+
+ if (!rsnIH) return 0;
+
+ // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
+ Int_t numberOfCuts = 2;
+
+ Printf("AddRsnDaughterCutsKStar2010 Option : %s",opt.Data());
+
+ // integrated kaon cut
+ AliRsnCutDaughterKStar2010PP *cutK = new AliRsnCutDaughterKStar2010PP("cutKaonForKStar", type1);
+ // cut set
+ AliRsnCutSet *cutSetK = new AliRsnCutSet("KaonForKStar", AliRsnTarget::kDaughter);
+ cutSetK->AddCut(cutK);
+ cutSetK->SetCutScheme(cutK->GetName());
+
+ // integrated proton cut
+ AliRsnCutDaughterKStar2010PP *cutP = new AliRsnCutDaughterKStar2010PP("cutPionForKStar", type2);
+ // cut set
+ AliRsnCutSet *cutSetP = new AliRsnCutSet("PionForKStar", AliRsnTarget::kDaughter);
+ cutSetP->AddCut(cutP);
+ cutSetP->SetCutScheme(cutP->GetName());
+
+ if (opt.Contains("mon")) {
+ TObjArray *output = new TObjArray;
+ AddMonitorOutput(output);
+ cutSetK->SetMonitorOutput(output);
+
+ output = new TObjArray;
+ AddMonitorOutput(output);
+ cutSetP->SetMonitorOutput(output);
+ }
+ if (isRsnMini) {
+ AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
+ if (taskRsnMini) {
+ taskRsnMini->AddTrackCuts(cutSetK);
+ taskRsnMini->AddTrackCuts(cutSetP);
+ }
+ } else {
+ AliRsnDaughterSelector *sel = rsnIH->GetSelector();
+ sel->Add(cutSetK, kTRUE);
+ sel->Add(cutSetP, kTRUE);
+ }
+
+
+ return numberOfCuts;
+}
--- /dev/null
+#ifndef __CINT__
+#include <PWG2/RESONANCES/AliRsnCutPID.h>
+#include <PWG2/RESONANCES/AliRsnInputHandler.h>
+#include <PWG2/RESONANCES/AliRsnCutSet.h>
+#endif
+
+Int_t AddRsnDaughterCutsPDG(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
+{
+
+ if (!rsnIH) return 0;
+
+ // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
+ Int_t numberOfCuts = 1;
+
+ // gets selector
+ AliRsnDaughterSelector *sel = rsnIH->GetSelector();
+
+ //---------------------------------------------
+ // Define single cuts
+ //---------------------------------------------
+
+ AliRsnCutPID *cut1 = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
+ AliRsnCutSet *cuts1 = new AliRsnCutSet(Form("%sPDG%s",AliPID::ParticleName(type1),opt.Data()), AliRsnTarget::kDaughter);
+ cuts1->AddCut(cut1);
+ cuts1->SetCutScheme(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);
+ cuts2 = new AliRsnCutSet(Form("%sPDG%s",AliPID::ParticleName(type2),opt.Data()), AliRsnTarget::kDaughter);
+ cuts2->AddCut(cut2);
+ cuts2->SetCutScheme(cut2->GetName());
+ sel->Add(cuts2, kTRUE);
+ numberOfCuts++;
+ }
+ if (opt.Contains("mon")) {
+ TObjArray *output = new TObjArray;
+ AddMonitorOutput(output);
+ cuts1->SetMonitorOutput(output);
+
+ output = new TObjArray;
+ AddMonitorOutput(output);
+ cuts2->SetMonitorOutput(output);
+ }
+ if (isRsnMini) {
+ AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
+ if (taskRsnMini) {
+ taskRsnMini->AddTrackCuts(cuts1);
+ if (type1 != type2) taskRsnMini->AddTrackCuts(cuts2);
+ }
+ } else {
+ AliRsnDaughterSelector *sel = rsnIH->GetSelector();
+ sel->Add(cuts1, kTRUE);
+ if (type1 != type2) sel->Add(cuts2, kTRUE);
+ }
+
+ return numberOfCuts;
+}
--- /dev/null
+#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>
+#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;
+
+ // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
+ Int_t numberOfCuts = 1;
+
+ //---------------------------------------------
+ // Define single cuts
+ //---------------------------------------------
+
+ Printf("AddRsnDaughterCutsPhi2010 Option : %s",opt.Data());
+
+ AliRsnCutKaonForPhi2010 *cut = new AliRsnCutKaonForPhi2010("cutKaonPhi2010");
+ if (!opt.CompareTo("qualityonly")) cut->SetMode(AliRsnCutKaonForPhi2010::kQuality);
+
+ 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);
+ }
+
+ 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);
+ }
+
+ //---------------------------------------------
+ // Combine cuts
+ //---------------------------------------------
+ TString cutname = "kaonPhi2010";
+ if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
+ AliRsnCutSet *cuts = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
+ cuts->AddCut(cut);
+ cuts->SetCutScheme(cut->GetName());
+
+ if (opt.Contains("mon")) {
+ TObjArray *output = new TObjArray;
+ AddMonitorOutput(output);
+ cuts->SetMonitorOutput(output);
+ }
+ if (isRsnMini) {
+ AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
+ if (taskRsnMini) {
+ taskRsnMini->AddTrackCuts(cuts);
+ }
+ } else {
+ AliRsnDaughterSelector *sel = rsnIH->GetSelector();
+ sel->Add(cuts, kTRUE);
+ }
+ return numberOfCuts;
+
+}
--- /dev/null
+#ifndef __CINT__
+#include <PWG2/RESONANCES/AliRsnInputHandler.h>
+#include <PWG2/RESONANCES/AliRsnCutKaonForPhi2010.h>
+
+#endif
+Int_t AddRsnDaughterCutsPhi2010KaonFromKStar(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
+{
+
+ if (!rsnIH) return 0;
+
+ // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
+ Int_t numberOfCuts = 1;
+
+ Printf("Option : %s",opt.Data());
+
+ //---------------------------------------------
+ // Define single cuts
+ //---------------------------------------------
+
+ AliRsnCutDaughterKStar2010PP *cutK = new AliRsnCutDaughterKStar2010PP("cutPhiKaonForKStar", AliPID::kKaon);
+ // cut set
+ AliRsnCutSet *cutSetK = new AliRsnCutSet("PhiKaonForKStar", AliRsnTarget::kDaughter);
+ cutSetK->AddCut(cutK);
+ cutSetK->SetCutScheme(cutK->GetName());
+ if (opt.Contains("mon")) {
+ TObjArray *output = new TObjArray;
+ AddMonitorOutput(output);
+ cuts->SetMonitorOutput(output);
+ }
+ if (isRsnMini) {
+ AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
+ if (taskRsnMini) {
+ taskRsnMini->AddTrackCuts(cutSetK);
+ }
+ } else {
+ AliRsnDaughterSelector *sel = rsnIH->GetSelector();
+ sel->Add(cutSetK, kTRUE);
+ }
+
+
+ return numberOfCuts;
+
+}
--- /dev/null
+void AddRsnPairsKStar(AliAnalysisTaskSE *task,
+ Bool_t isMC,
+ Bool_t isMixing,
+ AliPID::EParticleType pType1,
+ Int_t listID1,
+ AliPID::EParticleType pType2,
+ Int_t listID2,
+ AliRsnCutSet *cutsEvent=0,
+ AliRsnCutSet *cutsPair=0,
+ TString suffix = "") {
+
+ Printf("id1=%d id2=%d",listID1,listID2);
+
+ // retrieve mass from PDG database
+ Int_t pdg = 313;
+ TDatabasePDG *db = TDatabasePDG::Instance();
+ TParticlePDG *part = db->GetParticle(pdg);
+ Double_t mass = part->Mass();
+
+ if (gRsnUseMiniPackage) {
+ AddPairOutputMiniKStar(task,isMC,isMixing,pType1,listID1,pType2,listID2,pdg,mass,cutsPair,suffix);
+ } else {
+ // this function is common and it is located in RsnConfig.C
+ // as ouptup AddPairOutputKStar from this macro will be taken
+ AddPair(task,isMC,isMixing,pType1,listID1,pType2,listID2,pdg,mass,cutsEvent,cutsPair,suffix);
+ }
+}
+void AddPairOutputKStar(AliRsnLoopPair *pair)
+{
+
+ // axes
+ AliRsnValuePair *axisIM = new AliRsnValuePair("IM", AliRsnValuePair::kInvMass);
+ AliRsnValuePair *axisPt = new AliRsnValuePair("PT", AliRsnValuePair::kPt);
+ axisIM ->SetBins(900, 0.6, 1.5);
+ axisPt ->SetBins(120, 0.0, 12.0);
+
+ // output: 2D histogram of inv. mass vs. pt
+ AliRsnListOutput *outPair = 0;
+ if (!gRsnOutputFull) {
+ outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault);
+ outPair->AddValue(axisIM);
+ } else {
+ outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoSparse);
+ outPair->AddValue(axisIM);
+ outPair->AddValue(axisPt);
+ }
+ // add outputs to loop
+ pair->AddOutput(outPair);
+}
+
+void AddPairOutputMiniKStar(AliAnalysisTaskSE *task,Bool_t isMC,Bool_t isMixing, AliPID::EParticleType pType1,Int_t listID1, AliPID::EParticleType pType2,Int_t listID2, Int_t pdgMother,Double_t massMother, AliRsnCutSet *cutsPair=0,TString suffix = "") {
+
+ AliRsnMiniAnalysisTask *taskRsnMini = (AliRsnMiniAnalysisTask *)task;
+ /* invariant mass */ Int_t imID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
+ /* IM resolution */ Int_t resID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
+ /* transv. momentum */ Int_t ptID = taskRsnMini->CreateValue(AliRsnMiniValue::kPt, kFALSE);
+ /* centrality */ Int_t centID = taskRsnMini->CreateValue(AliRsnMiniValue::kMult, kFALSE);
+
+ //
+ // -- Create all needed outputs -----------------------------------------------------------------
+ //
+
+ Int_t iCutK = listID1;
+ Int_t iCutPi = listID2;
+
+ // use an array for more compact writing, which are different on mixing and charges
+ // [0] = unlike
+ // [1] = mixing
+ // [2] = like ++
+ // [3] = like --
+ Bool_t use [10] = { 1 , 1 , gRsnUseMixing , gRsnUseMixing , 1 , 1 , isMC , isMC , isMC , isMC };
+ Bool_t useIM [10] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 };
+ TString name [10] = {"Unlike1", "Unlike2", "Mixing1", "Mixing2", "LikePP", "LikeMM", "Trues1", "Trues2", "Res1" , "Res2" };
+ TString comp [10] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" , "TRUE" };
+ TString output [10] = {"HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" };
+ Char_t charge1 [10] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' };
+ Char_t charge2 [10] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' };
+ Int_t cutID1 [10] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK };
+ Int_t cutID2 [10] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi };
+
+ for (Int_t i = 0; i < 10; i++) {
+ if (!use[i]) continue;
+ // create output
+ AliRsnMiniOutput *out = taskRsnMini->CreateOutput(Form("%s_%s", suffix.Data(), name[i].Data()), output[i].Data(), comp[i].Data());
+ // selection settings
+ out->SetCutID(0, cutID1[i]);
+ out->SetCutID(1, cutID2[i]);
+ out->SetDaughter(0, AliRsnDaughter::kKaon);
+ out->SetDaughter(1, AliRsnDaughter::kPion);
+ out->SetCharge(0, charge1[i]);
+ out->SetCharge(1, charge2[i]);
+ out->SetMotherPDG(pdgMother);
+ out->SetMotherMass(massMother);
+ // pair cuts
+ if (cutsPair) out->SetPairCuts(cutsPair);
+ // axis X: invmass (or resolution)
+ if (useIM[i])
+ out->AddAxis(imID, 90, 0.6, 1.5);
+ else
+ out->AddAxis(resID, 200, -0.02, 0.02);
+
+ if (gRsnOutputFull) {
+ // axis Y: transverse momentum
+ out->AddAxis(ptID, 100, 0.0, 10.0);
+ // axis Z: centrality
+ out->AddAxis(centID, 100, 0.0, 100.0);
+ }
+ }
+
+}
--- /dev/null
+void AddRsnPairsPhi(AliAnalysisTaskSE *task,
+ Bool_t isMC,
+ Bool_t isMixing,
+ AliPID::EParticleType pType1,
+ Int_t listID1,
+ AliPID::EParticleType pType2,
+ Int_t listID2,
+ AliRsnCutSet *cutsEvent=0,
+ AliRsnCutSet *cutsPair=0,
+ TString suffix = "") {
+
+ Printf("id1=%d id2=%d",listID1,listID2);
+
+ // retrieve mass from PDG database
+ Int_t pdg = 333;
+ TDatabasePDG *db = TDatabasePDG::Instance();
+ TParticlePDG *part = db->GetParticle(pdg);
+ Double_t mass = part->Mass();
+
+ if (gRsnUseMiniPackage) {
+ AddPairOutputMiniPhi(task,isMC,isMixing,pType1,listID1,pType2,listID2,pdg,mass,cutsPair,suffix);
+ } else {
+ // this function is common and it is located in RsnConfig.C
+ // as ouptup AddPairOutputPhi from this macro will be taken
+ AddPair(task,isMC,isMixing,pType1,listID1,pType2,listID2,pdg,mass,cutsEvent,cutsPair,suffix);
+ }
+}
+void AddPairOutputPhi(AliRsnLoopPair *pair)
+{
+ // axes
+ AliRsnValuePair *axisIM = new AliRsnValuePair("IM", AliRsnValuePair::kInvMass);
+ AliRsnValuePair *axisPt = new AliRsnValuePair("PT", AliRsnValuePair::kPt);
+ axisIM ->SetBins(300, 0.9, 1.2);
+ axisPt ->SetBins(120, 0.0, 12.0);
+
+ // output: 2D histogram of inv. mass vs. pt
+ AliRsnListOutput *outPair = 0;
+ if (!gRsnOutputFull) {
+ outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault);
+ outPair->AddValue(axisIM);
+ } else {
+ outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoSparse);
+ outPair->AddValue(axisIM);
+ outPair->AddValue(axisPt);
+ }
+ // add outputs to loop
+ pair->AddOutput(outPair);
+}
+
+void AddPairOutputMiniPhi(AliAnalysisTaskSE *task, Bool_t isMC,Bool_t isMixing, AliPID::EParticleType pType1,Int_t listID1, AliPID::EParticleType pType2,Int_t listID2, Int_t pdgMother,Double_t massMother, AliRsnCutSet *cutsPair=0,TString suffix = "") {
+
+ AliRsnMiniAnalysisTask *taskRsnMini = (AliRsnMiniAnalysisTask *)task;
+
+ /* invariant mass */ Int_t imID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
+ /* IM resolution */ Int_t resID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMassDiff, kTRUE);
+ /* transv. momentum */ Int_t ptID = taskRsnMini->CreateValue(AliRsnMiniValue::kPt, kFALSE);
+ /* centrality */ Int_t centID = taskRsnMini->CreateValue(AliRsnMiniValue::kMult, kFALSE);
+
+
+ // use an array for more compact writing, which are different on mixing and charges
+ // [0] = unlike
+ // [1] = mixing
+ // [2] = like ++
+ // [3] = like --
+ Bool_t use [5] = { 1 , gRsnUseMixing , 1 , 1 , isMC };
+ TString name [5] = {"Unlike", "Mixing", "LikePP", "LikeMM", "Trues"};
+ TString comp [5] = {"PAIR" , "MIX" , "PAIR" , "PAIR" , "TRUE" };
+ Char_t charge1 [5] = {'+' , '+' , '+' , '-' , '+' };
+ Char_t charge2 [5] = {'-' , '-' , '+' , '-' , '-' };
+
+ // common definitions
+ TString outputType = "HIST";
+ if (gRsnOutputFull) outputType = "SPARSE";
+
+ Int_t nIM = 300; Double_t minIM = 0.9, maxIM = 1.2;
+ Int_t nPt = 100; Double_t minPt = 0.0, maxPt = 10.0;
+ Int_t nCent = 100; Double_t minCent = 0.0, maxCent = 100.0;
+ Int_t nRes = 200; Double_t maxRes = 0.01;
+
+ // retrieve mass from PDG database
+ Int_t pdg = 333;
+ TDatabasePDG *db = TDatabasePDG::Instance();
+ TParticlePDG *part = db->GetParticle(pdg);
+
+
+ Printf(suffix.Data());
+ // create standard outputs
+ for (Int_t i = 0; i < 5; i++) {
+ if (!use[i]) continue;
+ // create output
+ AliRsnMiniOutput *out = taskRsnMini->CreateOutput(Form("%s_%s", suffix.Data(),name[i].Data() ), outputType.Data(), comp[i].Data());
+ // selection settings
+ out->SetCutID(0, listID1);
+ out->SetCutID(1, listID1);
+ out->SetDaughter(0, AliRsnDaughter::kKaon);
+ out->SetDaughter(1, AliRsnDaughter::kKaon);
+ out->SetCharge(0, charge1[i]);
+ out->SetCharge(1, charge2[i]);
+ out->SetMotherPDG(pdg);
+ out->SetMotherMass(part->Mass());
+ // pair cuts
+ if (cutsPair) out->SetPairCuts(cutsPair);
+ // axis X: invmass
+ out->AddAxis(imID, nIM, minIM, maxIM);
+
+ if (gRsnOutputFull) {
+ // axis Y: transverse momentum
+ out->AddAxis(ptID, nPt, minPt, maxPt);
+ // axis Z: centrality
+ out->AddAxis(centID, nCent, minCent, maxCent);
+ }
+ }
+
+ // add output for resolution
+ if (isMC) {
+ AliRsnMiniOutput *outRes = taskRsnMini->CreateOutput(Form("phi_Res%s", suffix.Data()), outputType.Data(), "TRUE");
+ // selection settings
+ outRes->SetCutID(0, listID1);
+ outRes->SetCutID(1, listID1);
+ outRes->SetDaughter(0, AliRsnDaughter::kKaon);
+ outRes->SetDaughter(1, AliRsnDaughter::kKaon);
+ outRes->SetCharge(0, '+');
+ outRes->SetCharge(1, '-');
+ outRes->SetMotherPDG(pdg);
+ outRes->SetMotherMass(part->Mass());
+ // pair cuts
+ if (cutsPair) outRes->SetPairCuts(cutsPair);
+ // axis X: resolution
+ outRes->AddAxis(resID, nRes, -maxRes, maxRes);
+
+ if (gRsnOutputFull) {
+ // axis Y: transverse momentum
+ outRes->AddAxis(ptID, nPt, minPt, maxPt);
+ // axis Z: centrality
+ outRes->AddAxis(centID, nCent, minCent, maxCent);
+ }
+ }
+
+ //
+ // -- Create output for MC generated ------------------------------------------------------------
+ //
+
+ if (isMC) {
+ // create ouput
+ AliRsnMiniOutput *outMC = taskRsnMini->CreateOutput(Form("phi_MCGen%s", suffix.Data()), outputType.Data(), "MOTHER");
+ // selection settings
+ outMC->SetDaughter(0, AliRsnDaughter::kKaon);
+ outMC->SetDaughter(1, AliRsnDaughter::kKaon);
+ outMC->SetMotherPDG(pdg);
+ outMC->SetMotherMass(part->Mass());
+ // pair cuts
+ if (cutsPair) outMC->SetPairCuts(cutsPair);
+ // axis X: invmass
+ outMC->AddAxis(imID, nIM, minIM, maxIM);
+ if (gRsnOutputFull) {
+ // axis Y: transverse momentum
+ outMC->AddAxis(ptID, nPt, minPt, maxPt);
+ // axis Z: centrality
+ outMC->AddAxis(centID, nCent, minCent, maxCent);
+ }
+ }
+
+
+}
--- /dev/null
+#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>
+#endif
+
+Bool_t RsnConfig(AliAnalysisTaskSE *task,Bool_t isMC,Bool_t isMixing,AliRsnInputHandler *rsnIH=0,TList *listRsn=0) {
+
+ if (!task) return kFALSE;
+
+ if (!listRsn) {
+ return kFALSE;
+ }
+
+ Int_t cutIndex = 0;
+ Int_t numOfCuts = 0;
+
+ // set commol eventCuts
+
+ gROOT->LoadMacro("AddRsnCommonEventCuts.C");
+ AliRsnCutSet *commonEventCuts = AddRsnCommonEventCuts(task);
+
+ gROOT->LoadMacro("AddRsnCommonPairCuts.C");
+ AliRsnCutSet *commonPairCuts = AddRsnCommonPairCuts();
+
+
+ // TODO this is tmp hack
+ if (!rsnIH) rsnIH = new AliRsnInputHandler();
+
+ TIter next(listRsn);
+ TNamed *rsnObj=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());
+
+ GetOptionFromString(rsnObj->GetTitle(),rsnCutName,rsnCutOpt);
+ rsnCutNameOptFull=rsnCutName; if (!rsnCutOpt.IsNull())rsnCutNameOptFull += Form("_%s",rsnCutOpt.Data());
+
+ gROOT->LoadMacro(Form("AddRsnDaughterCuts%s.C",rsnCutName.Data()));
+ gROOT->LoadMacro(Form("AddRsnPairs%s.C",rsnName.Data()));
+
+ rsnNameOptFull.ToLower();
+ rsnName.ToLower();
+ // add cuts
+ if (!rsnName.CompareTo("phi")) {
+ numOfCuts = gROOT->ProcessLine(Form("AddRsnDaughterCuts%s(AliPID::kKaon,AliPID::kKaon,\"%s\",%d,(AliRsnInputHandler*)%p,(AliAnalysisTaskSE*)%p)",rsnCutName.Data(), rsnCutOpt.Data(),gRsnUseMiniPackage,rsnIH, task));
+ if (numOfCuts) {
+ if (rsnNameOpt.Contains("mon")) AddParticleMonitor(task,isMC,cutIndex,commonEventCuts,commonPairCuts,Form("%s_%s_K",rsnNameOptFull.Data(),rsnCutNameOptFull.Data()));
+ AddRsnPairsPhi(task,isMC,isMixing,AliPID::kKaon,cutIndex,AliPID::kKaon,cutIndex,commonEventCuts,commonPairCuts,Form("%s_%s",rsnNameOptFull.Data(),rsnCutNameOptFull.Data()));
+ cutIndex+=numOfCuts;
+ }
+ } else if (!rsnName.CompareTo("kstar")) {
+ numOfCuts = gROOT->ProcessLine(Form("AddRsnDaughterCuts%s(AliPID::kKaon,AliPID::kPion,\"%s\",%d,(AliRsnInputHandler*)%p,(AliAnalysisTaskSE*)%p)",rsnCutName.Data(), rsnCutOpt.Data(),gRsnUseMiniPackage,rsnIH,task));
+ if (numOfCuts) {
+ if (rsnNameOpt.Contains("mon")) AddParticleMonitor(task,isMC,cutIndex,commonEventCuts,commonPairCuts,Form("%s_%s_K",rsnNameOptFull.Data(),rsnCutNameOptFull.Data()));
+ if (rsnNameOpt.Contains("mon")) AddParticleMonitor(task,isMC,cutIndex+1,commonEventCuts,commonPairCuts,Form("%s_%s_pi",rsnNameOptFull.Data(),rsnCutNameOptFull.Data()));
+ AddRsnPairsKStar(task,isMC,isMixing,AliPID::kKaon,cutIndex,AliPID::kPion,cutIndex+1,commonEventCuts,commonPairCuts,Form("%s_%s",rsnNameOptFull.Data(),rsnCutNameOptFull.Data()));
+ cutIndex+=numOfCuts;
+ }
+ } else {
+ Printf("Error : Particle %s is not supported !!!!",rsnName.Data());
+ return kFALSE;
+ }
+
+ }
+
+ return kTRUE;
+}
+
+void GetOptionFromString(TString str,TString &outStr1,TString &outStr2,TString d=":") {
+// TStringO
+ TObjArray *tokens = str.Tokenize(d.Data());
+ TObjString *objStr = (TObjString *)tokens->At(0);
+ if (!objStr) {
+ outStr1 = "err";
+ outStr2 = "";
+ return;
+ }
+ outStr1 = objStr->GetString();
+
+ objStr = (TObjString *) tokens->At(1);
+ if (!objStr) {
+ outStr2 = "";
+ return;
+ }
+ outStr2 = objStr->GetString();
+
+}
+
+Bool_t AddPair(AliAnalysisTaskSE *task, Bool_t isMC,Bool_t isMixing, AliPID::EParticleType pType1,Int_t listID1, AliPID::EParticleType pType2,Int_t listID2, Int_t pdgMother,Double_t massMother, AliRsnCutSet *commonEventCuts=0,AliRsnCutSet *commonPairCuts=0, TString name = "") {
+
+ Bool_t typeSame = (pType1 == pType2);
+
+// Printf("------------- id1=%d id2=%d",listID1,listID2);
+
+ TList *listLoops = new TList;
+
+ // pair definition
+ AliRsnPairDef *pairDefPM = new AliRsnPairDef((AliRsnDaughter::ESpecies)pType1, '+', (AliRsnDaughter::ESpecies)pType2, '-', pdgMother, massMother);
+ AliRsnPairDef *pairDefMP = new AliRsnPairDef((AliRsnDaughter::ESpecies)pType1, '-', (AliRsnDaughter::ESpecies)pType2, '+', pdgMother, massMother);
+ AliRsnPairDef *pairDefPP = new AliRsnPairDef((AliRsnDaughter::ESpecies)pType1, '+', (AliRsnDaughter::ESpecies)pType2, '+', pdgMother, massMother);
+ AliRsnPairDef *pairDefMM = new AliRsnPairDef((AliRsnDaughter::ESpecies)pType1, '-', (AliRsnDaughter::ESpecies)pType2, '-', pdgMother, massMother);
+
+ // loop object creation
+ AliRsnLoopPair *lp = 0;
+
+ // sets +-
+ lp = new AliRsnLoopPair(Form("%s_PM", name.Data()), pairDefPM, kFALSE);
+ listLoops->Add(lp);
+
+ if (!typeSame) {
+ lp = new AliRsnLoopPair(Form("%s_MP", name.Data()), pairDefMP, kFALSE);
+ listLoops->Add(lp);
+ }
+
+ // sets +- TRUE pairs
+ if (isMC) {
+ lp = new AliRsnLoopPair(Form("%s_PM_TRUE", name.Data()), pairDefPM, kFALSE);
+ lp->SetOnlyTrue(kTRUE);
+ lp->SetCheckDecay(kTRUE);
+ listLoops->Add(lp);
+ if (!typeSame) {
+ lp = new AliRsnLoopPair(Form("%s_MP_TRUE", name.Data()), pairDefMP, kFALSE);
+ lp->SetOnlyTrue(kTRUE);
+ lp->SetCheckDecay(kTRUE);
+ listLoops->Add(lp);
+ }
+ // sets +- TRUE paris (MC is used for momentum)
+ lp = new AliRsnLoopPair(Form("%s_PM_TRUE_MC", name.Data()), pairDefPM, kFALSE);
+ lp->SetTrueMC(kTRUE);
+ listLoops->Add(lp);
+ if (!typeSame) {
+ // sets +- TRUE paris (MC is used for momentum)
+ lp = new AliRsnLoopPair(Form("%s_MP_TRUE_MC", name.Data()), pairDefMP, kFALSE);
+ lp->SetTrueMC(kTRUE);
+ listLoops->Add(lp);
+ }
+ }
+
+ // sets ++
+ lp = new AliRsnLoopPair(Form("%s_PP", name.Data()), pairDefPP, kFALSE);
+ listLoops->Add(lp);
+
+ // sets --
+ lp = new AliRsnLoopPair(Form("%s_MM", name.Data()), pairDefMM, kFALSE);
+ listLoops->Add(lp);
+
+ if (isMixing) {
+ // sets +- Mixing (NOT mini)
+ lp = new AliRsnLoopPair(Form("%s_PM", name.Data()), pairDefPM, kTRUE);
+ listLoops->Add(lp);
+
+ // sets -+ Mixing (NOT mini)
+ lp = new AliRsnLoopPair(Form("%s_MP", name.Data()), pairDefMP, kTRUE);
+ listLoops->Add(lp);
+
+ // sets ++ Mixing (NOT mini)
+ lp = new AliRsnLoopPair(Form("%s_PP", name.Data()), pairDefPP, kTRUE);
+ listLoops->Add(lp);
+
+ // sets -- Mixing (NOT mini)
+ lp = new AliRsnLoopPair(Form("%s_MM", name.Data()), pairDefMM, kTRUE);
+ listLoops->Add(lp);
+ }
+
+
+ // loops over all AliRsnLoops and sets everything (don't touch it if you don't know what you are doing)
+ TIter next(listLoops);
+ while ((lp = (AliRsnLoopPair *)next.Next())) {
+ lp->SetListID(0, listID1);
+ lp->SetListID(1, listID2);
+ lp->SetMCRefInfo(gRsnUseMCMomentum);
+ if (commonPairCuts) lp->SetPairCuts(commonPairCuts);
+ if (commonEventCuts) lp->SetEventCuts(commonEventCuts);
+ if (name.Contains("phi")) AddPairOutputPhi(lp);
+ else if (name.Contains("kstar")) AddPairOutputKStar(lp);
+ else continue;
+ ((AliRsnAnalysisTask *)task)->AddLoop(lp);
+ }
+ return kTRUE;
+}
+
+// void AddMonitorOutput(AliRsnLoopDaughter *mon)
+
+void AddMonitorOutput(TObjArray *mon)
+{
+// mcinfo is not supported yet
+ if (gRsnUseMCMomentum) return ;
+
+ // dEdx tpc
+ AliRsnValueDaughter *axisMomTPC = new AliRsnValueDaughter("pTPC", AliRsnValueDaughter::kPtpc);
+ AliRsnValueDaughter *axisSigTPC = new AliRsnValueDaughter("sTPC", AliRsnValueDaughter::kTPCsignal);
+ axisMomTPC->SetBins(0.0,5.0,0.01);
+ axisSigTPC->SetBins(0.0,500.0,2.0);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitordEdxTPC = new AliRsnListOutput("dEdx", AliRsnListOutput::kHistoDefault);
+ outMonitordEdxTPC->AddValue(axisMomTPC);
+ outMonitordEdxTPC->AddValue(axisSigTPC);
+
+ // add outputs to loop
+ mon->Add(outMonitordEdxTPC);
+
+ // dEdx tpc
+ AliRsnValueDaughter *axisMomTPCForTOF = new AliRsnValueDaughter("pTPC", AliRsnValueDaughter::kPtpc);
+ AliRsnValueDaughter *axisSigTOF = new AliRsnValueDaughter("sTOF", AliRsnValueDaughter::kTOFsignal);
+ axisMomTPCForTOF->SetBins(0.0,5.0,0.01);
+ axisSigTOF->SetBins(0.0,500.0,2.0);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitordEdxTOF = new AliRsnListOutput("Edx", AliRsnListOutput::kHistoDefault);
+ outMonitordEdxTOF->AddValue(axisMomTPCForTOF);
+ outMonitordEdxTOF->AddValue(axisSigTOF);
+
+ // add outputs to loop
+// mon->Add(outMonitordEdxTOF);
+
+
+ // Momentum
+ AliRsnValueDaughter *axisMomP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kP);
+ axisMomP->SetBins(0.0,5.0,0.01);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorP = new AliRsnListOutput("P", AliRsnListOutput::kHistoDefault);
+ outMonitorP->AddValue(axisMomP);
+
+ // add outputs to loop
+ mon->Add(outMonitorP);
+
+ // Momentum Pt
+ AliRsnValueDaughter *axisMomPt = new AliRsnValueDaughter("pt", AliRsnValueDaughter::kPt);
+ axisMomPt->SetBins(0.0,5.0,0.01);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorPt = new AliRsnListOutput("Pt", AliRsnListOutput::kHistoDefault);
+ outMonitorPt->AddValue(axisMomPt);
+
+ // add outputs to loop
+ mon->Add(outMonitorPt);
+
+ // Eta
+ AliRsnValueDaughter *axisMomEta = new AliRsnValueDaughter("eta", AliRsnValueDaughter::kEta);
+ axisMomEta->SetBins(-1.0,1.0,0.01);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorEta = new AliRsnListOutput("Eta", AliRsnListOutput::kHistoDefault);
+ outMonitorEta->AddValue(axisMomEta);
+
+ // add outputs to loop
+ mon->Add(outMonitorEta);
+
+ // kTOFnsigmaK
+ AliRsnValueDaughter *axisTPCnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTPCnsigmaK);
+ axisTPCnsigmaK->SetBins(1000,0,100);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorTPCnsigmaK = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault);
+ outMonitorTPCnsigmaK->AddValue(axisTPCnsigmaK);
+
+ // add outputs to loop
+ mon->Add(outMonitorTPCnsigmaK);
+
+ // kTPCnsigmaPi
+ AliRsnValueDaughter *axisTPCnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTPCnsigmaPi);
+ axisTPCnsigmaPi->SetBins(1000,0,100);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorTPCnsigmaPi = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault);
+ outMonitorTPCnsigmaPi->AddValue(axisTPCnsigmaPi);
+
+ // add outputs to loop
+ mon->Add(outMonitorTPCnsigmaPi);
+
+ // kTPCnsigmaP
+ AliRsnValueDaughter *axisTPCnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTPCnsigmaP);
+ axisTPCnsigmaP->SetBins(1000,0,100);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorTPCnsigmaP = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault);
+ outMonitorTPCnsigmaP->AddValue(axisTPCnsigmaP);
+
+ // add outputs to loop
+ mon->Add(outMonitorTPCnsigmaP);
+
+
+ // kTOFnsigmaK
+ AliRsnValueDaughter *axisTOFnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTOFnsigmaK);
+ axisTOFnsigmaK->SetBins(1000,0,100);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorTOFnsigmaK = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFnsigmaK->AddValue(axisTOFnsigmaK);
+
+ // add outputs to loop
+ mon->Add(outMonitorTOFnsigmaK);
+
+ // kTOFnsigmaPi
+ AliRsnValueDaughter *axisTOFnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTOFnsigmaPi);
+ axisTOFnsigmaPi->SetBins(1000,0,100);
+
+ // output: 2D histogram of TPC signal vs. TPC momentum
+ AliRsnListOutput *outMonitorTOFnsigmaPi = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault);
+ outMonitorTOFnsigmaPi->AddValue(axisTOFnsigmaPi);
+
+ // add outputs to loop
+ mon->Add(outMonitorTOFnsigmaPi);
+
+ // kTOFnsigmaP
+ AliRsnValueDaughter *axisTOFnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTOFnsigmaP);
+ axisTOFnsigmaP->SetBins(1000,0,100);
+
+ // 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);
+ AliRsnValueDaughter *vd1 = new AliRsnValueDaughter("pt",AliRsnValueDaughter::kPt);
+ vd1->SetBins(0.0,5.0,0.01);
+ outMonitorPTvsMult->AddValue(vd1);
+
+ AliRsnValueEvent *ve1 = new AliRsnValueEvent("mult",AliRsnValueEvent::kMult);
+ ve1->SetBins(0.0,100.0,1);
+ outMonitorPTvsMult->AddValue(ve1);
+ mon->Add(outMonitorPTvsMult);
+
+// mon->SetMCRefInfo(gRsnUseMCMomentum);
+
+}
+
+void AddMonitorOutputMini(AliRsnMiniAnalysisTask *task,Int_t listID1,TString name = "",Char_t charge='0')
+{
+ TString chargeName="all";
+ if ( charge == '+' ) chargeName = "pos";
+ if ( charge == '-' ) chargeName = "neg";
+
+ AliRsnMiniMonitor *mondEdx = new AliRsnMiniMonitor(Form("%s_dEdxTPCvsP_%s", name.Data(),chargeName.Data()),AliRsnMiniMonitor::kdEdxTPCvsP, listID1);
+ mondEdx->SetCharge(charge);
+
+ AliRsnMiniMonitor *monPt = new AliRsnMiniMonitor(Form("%s_Pt_%s", name.Data(),chargeName.Data()),AliRsnMiniMonitor::kTrackPt, listID1);
+ monPt->SetCharge(charge);
+
+}
+
+void AddParticleMonitor(AliAnalysisTaskSE *task, Bool_t isMC, Int_t listID1,AliRsnCutSet *commonEventCuts=0,AliRsnCutSet *cutPair=0,TString name = "")
+{
+
+ if (gRsnUseMiniPackage) {
+ Printf("Monitoring by mini is not supported now. It will be soon !!!");
+ return ;
+// AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+//
+// AddMonitorOutputMini((AliRsnMiniAnalysisTask *)task,listID1,name);
+// AddMonitorOutputMini((AliRsnMiniAnalysisTask *)task,listID1,name,'+');
+// AddMonitorOutputMini((AliRsnMiniAnalysisTask *)task,listID1,name,'-');
+ } else {
+ TList *listLoops = new TList;
+ // monitor definition
+ AliRsnDaughterDef *tracksAll = new AliRsnDaughterDef(AliRsnDaughter::kTrack /*'+' or '-'*/);
+ AliRsnDaughterDef *tracksPos = new AliRsnDaughterDef(AliRsnDaughter::kTrack,'+');
+ AliRsnDaughterDef *tracksNeg = new AliRsnDaughterDef(AliRsnDaughter::kTrack,'-');
+
+ AliRsnLoopDaughter *lm =0;
+ // loop object
+ listLoops->Add(new AliRsnLoopDaughter(Form("%s_all", name.Data()), listID1, tracksAll));
+ listLoops->Add(new AliRsnLoopDaughter(Form("%s_pos", name.Data()), listID1, tracksPos));
+ listLoops->Add(new AliRsnLoopDaughter(Form("%s_neg", name.Data()), listID1, tracksNeg));
+
+ TIter next(listLoops);
+ while ((lm = (AliRsnLoopDaughter *)next.Next()))) {
+ if (commonEventCuts) lm->SetEventCuts(commonEventCuts);
+ AddMonitorOutput(lm);
+ ((AliRsnAnalysisTask *)task)->AddLoop(lm);
+ }
+
+ }
+
+}
+
+
+
--- /dev/null
+
+// use parfiles instead of libs
+Bool_t gRsnUseEventMixingPar = 0;
+Bool_t gRsnUseRSNPar = 0;
+
+// common options
+Bool_t gRsnUsePhysSel = 0;
+
+// rsn options
+Bool_t gRsnUseMiniPackage = 1;
+
+// mixing setting
+Bool_t gRsnUseMixing = 0;
+Int_t gRsnNumMix = 1;
+
+// oputput settings
+Bool_t gRsnOutputFull = 0;
+Bool_t gRsnUseMCMomentum = 0;
+
+// expert options (don't change)
+Bool_t gRsnUsePIDResponse = 1;
+Bool_t gRsnUseRsnInputHandler = 1;
+Bool_t gRsnSplitMgrByTasks = 1;
+Int_t gRsnMixPrintRefresh = -1;
+
+TList *RsnManager() {
+
+ // don't change (experts only)
+ ExpertDefaultSetting();
+
+ TList *listRsn = new TList();
+
+ // This will use AddRsnPairs<Name>.C
+ // and for cuts AddRsnDaughterCuts<CutName>.C
+ // and <opt> string is passed to AddRsnDaughterCuts<CutName>.C
+ // so you can control different cut settings
+ // string "<Name>:mon" means that it will add monitoring histograms from cuts
+ // 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:qualityonly: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"));
+//
+// // 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"));
+
+ return listRsn;
+}
+void ExpertDefaultSetting() {
+
+ if (gRsnUseMiniPackage) {
+ gRsnUseRsnInputHandler = 0;
+// gRsnMixPrintRefresh = 10;
+ } else {
+ gRsnSplitMgrByTasks = 0;
+// gRsnUseMixing = 0;
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff