Fasel); all macros now relocated in their new directory.
+++ /dev/null
-AliAnalysisTask *AddTaskHFE(){
- //get the current analysis manager
- AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
- if (!mgr) {
- Error("AddTaskHFE", "No analysis manager found.");
- return NULL;
- }
- if (!mgr->GetInputEventHandler()) {
- ::Error("AddTaskHFE", "This task requires an input event handler");
- return NULL;
- }
- TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
- if (type=="AOD"){
- ::Error("AddTaskHFE", "The tasks exits because AODs are in input");
- return NULL;
- }
- Bool_t MCthere=kTRUE;
- AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>(mgr->GetMCtruthEventHandler());
- if(!mcH){
- MCthere=kFALSE;
- }
-
- //============= Set Task Name ===================
- //TString taskName=("AliAnalysisTaskHFE.cxx+");
- //===============================================
-
- AliHFEcuts *hfecuts = new AliHFEcuts("hfeCuts","HFE Standard Cuts");
- hfecuts->CreateStandardCuts();
- hfecuts->SetMinNClustersTPC(110);
- hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
- hfecuts->SetCheckITSLayerStatus(kFALSE);
- hfecuts->SetSigmaToVertex(10);
- hfecuts->SetQAOn();
- //hfecuts->SetMinNTrackletsTRD(5);
-
- AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE("HFEanalysis");
- task->SetESDAnalysis();
- if (MCthere)
- task->SetHasMCData(kTRUE);
- else{
- task->SetHasMCData(kFALSE);
- task->SelectCollisionCandidates();
- }
-
- task->SetPIDStrategy(6);
- task->SetHFECuts(hfecuts);
- if(!MCthere){
- TF1 *hBackground = new TF1("hadronicBackgroundFunction", "[0]+[1]*TMath::Erf([2]*x+[3])", 0, 20);
- hBackground->SetParameter(0, 0.2194);
- hBackground->SetParameter(1, 0.217);
- hBackground->SetParameter(2, 0.6829);
- hBackground->SetParameter(3, -2.697);
- task->SetBackGroundFactorsFunction(hBackground);
- }
-
- // kPIDqa needs to be off for flat pT spectra !!!
- task->SetQAOn(AliAnalysisTaskHFE::kPIDqa);
- task->SetQAOn(AliAnalysisTaskHFE::kMCqa);
- //task->SwitchOnPlugin(AliAnalysisTaskHFE::kIsElecBackGround);
- //task->SwitchOnPlugin(AliAnalysisTaskHFE::kSecVtx);
-
- mgr->AddTask(task);
-
- //----------------------
- //create data containers
- //----------------------
-
- //find input container
- AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
- TString containerName = mgr->GetCommonFileName();
- containerName += ":PWG3_hfe";
-
- task->ConnectOutput(1, mgr->CreateContainer("HFE_nEvents", TH1I::Class(),
- AliAnalysisManager::kOutputContainer, containerName.Data()));
- task->ConnectOutput(2, mgr->CreateContainer("HFE_Results", TList::Class(),
- AliAnalysisManager::kOutputContainer, containerName.Data()));
- task->ConnectOutput(3, mgr->CreateContainer("HFE_QA", TList::Class(),
- AliAnalysisManager::kOutputContainer, containerName.Data()));
- mgr->ConnectInput (task, 0, cinput );
-
- return task;
-}
--- /dev/null
+AliAnalysisTask *AddTaskHFE(){
+ //get the current analysis manager
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ Error("AddTaskHFE", "No analysis manager found.");
+ return NULL;
+ }
+ if (!mgr->GetInputEventHandler()) {
+ ::Error("AddTaskHFE", "This task requires an input event handler");
+ return NULL;
+ }
+ TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
+ if (type=="AOD"){
+ ::Error("AddTaskHFE", "The tasks exits because AODs are in input");
+ return NULL;
+ }
+ Bool_t MCthere=kTRUE;
+ AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>(mgr->GetMCtruthEventHandler());
+ if(!mcH){
+ MCthere=kFALSE;
+ }
+
+ //============= Set Task Name ===================
+ //TString taskName=("AliAnalysisTaskHFE.cxx+");
+ //===============================================
+
+ gROOT->LoadMacro(Form("%s/PWG3/hfe/macros/ConfigHFEstandard.C", gSystem->Getenv("ALICE_ROOT")));
+ //gROOT->LoadMacro(Form("%s/PWG3/hfe/macros/ConfigHFEtrd.C", gSystem->Getenv("ALICE_ROOT")));
+
+ AliAnalysisTaskHFE *hfetask = ConfigHFEstandard(MCthere);
+ mgr->AddTask(hfetask);
+
+ //----------------------
+ //create data containers
+ //----------------------
+
+ //find input container
+ AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
+ TString containerName = mgr->GetCommonFileName();
+ containerName += ":PWG3_hfe";
+
+ hfetask->ConnectOutput(1, mgr->CreateContainer("HFE_Results", TList::Class(),
+ AliAnalysisManager::kOutputContainer, containerName.Data()));
+ hfetask->ConnectOutput(2, mgr->CreateContainer("HFE_QA", TList::Class(),
+ AliAnalysisManager::kOutputContainer, containerName.Data()));
+ mgr->ConnectInput (hfetask, 0, cinput );
+
+/*
+ AliAnalysisTaskHFE *trdtask = ConfigHFEtrd(MCthere);
+
+ //----------------------
+ //create data containers
+ //----------------------
+
+ trdtask->ConnectOutput(1, mgr->CreateContainer("HFE_Results", TList::Class(),
+ AliAnalysisManager::kOutputContainer, containerName.Data()));
+ trdtask->ConnectOutput(2, mgr->CreateContainer("HFE_QA", TList::Class(),
+ AliAnalysisManager::kOutputContainer, containerName.Data()));
+ mgr->ConnectInput (trdtask, 0, cinput );
+*/
+
+ return hfetask;
+}
--- /dev/null
+AliAnalysisTaskHFE *ConfigHFEhm(Bool_t useMC){
+ //
+ // HFE standard task configuration
+ //
+
+ AliHFEcuts *hfecuts = new AliHFEcuts("hfeCutsHM","HFE cuts for High Multiplicity studies");
+ hfecuts->CreateStandardCuts();
+ hfecuts->SetMinNClustersTPC(110);
+ hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
+ hfecuts->SetCheckITSLayerStatus(kFALSE);
+ hfecuts->SetSigmaToVertex(10);
+ hfecuts->SetQAOn();
+ //hfecuts->SetMinNTrackletsTRD(5);
+
+ AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE("HFEanalysisHM");
+ task->SetHFECuts(hfecuts);
+
+ // Define Variables
+ AliHFEvarManager *vm = task->GetVarManager();
+ vm->AddVariable("pt");
+ vm->AddVariable("eta");
+ vm->AddVariable("phi");
+ vm->AddVariable("charge");
+ vm->AddVariable("source");
+
+ if(!useMC){
+ TF1 *hBackground = new TF1("hadronicBackgroundFunction", "[0]+[1]*TMath::Erf([2]*x+[3])", 0, 20);
+ hBackground->SetParameter(0, 0.1249);
+ hBackground->SetParameter(1, 0.1239);
+ hBackground->SetParameter(2, 0.8156);
+ hBackground->SetParameter(3, -2.867);
+ task->SetBackGroundFactorsFunction(hBackground);
+ }
+
+ // Define PID
+ AliHFEpid *pid = task->GetPID();
+ pid->AddDetector("TOF", 0);
+ pid->AddDetector("TPC", 1);
+ pid->ConfigureTPCrejection();
+
+ // QA
+ task->SetQAOn(AliAnalysisTaskHFE::kPIDqa);
+ task->SetQAOn(AliAnalysisTaskHFE::kMCqa);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kIsElecBackGround);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kSecVtx);
+
+ printf("*************************************\n");
+ printf("Configuring high multiplicity Task:\n");
+ task->Print();
+ pid->PrintStatus();
+ printf("*************************************\n");
+ return task;
+}
--- /dev/null
+AliAnalysisTaskHFE* ConfigHFEstandard(Bool_t useMC){
+ //
+ // HFE standard task configuration
+ //
+
+ Bool_t kAnalyseTaggedTracks = kTRUE;
+
+ AliHFEcuts *hfecuts = new AliHFEcuts("hfeCuts","HFE Standard Cuts");
+ hfecuts->CreateStandardCuts();
+ //hfecuts->SetTPCiter1(kTRUE);
+ hfecuts->SetMinNClustersTPC(100);
+ //hfecuts->SetMinNClustersITS(1);
+ hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
+ hfecuts->SetCheckITSLayerStatus(kFALSE);
+ hfecuts->UnsetVertexRequirement();
+ hfecuts->SetVertexRange(10.);
+ //hfecuts->SetSigmaToVertex(10);
+ hfecuts->SetQAOn();
+ //hfecuts->SetMinNTrackletsTRD(5);
+
+ AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE("HFEanalysisStandard");
+ printf("task %p\n", task);
+ task->SetHFECuts(hfecuts);
+ task->SetRemovePileUp(kTRUE);
+
+ // Define Variables
+ AliHFEvarManager *vm = task->GetVarManager();
+ vm->AddVariable("pt");
+ vm->AddVariable("eta");
+ vm->AddVariable("phi");
+ vm->AddVariable("charge");
+ vm->AddVariable("source");
+ //vm->AddVariable("centrality");
+
+ if(!useMC){
+ // New background model (LHC10d pass2)
+ TF1 *hBackground = new TF1("hadronicBackgroundFunction", "TMath::Min(0.99, TMath::Max(0., TMath::Exp([0]+[1]*x) + [2]*TMath::Gaus(x,[3],[4])))", 0., 20.);
+ hBackground->SetParameter(0, -7.267);
+ hBackground->SetParameter(1, 1.442);
+ hBackground->SetParameter(2, 0.02579);
+ hBackground->SetParameter(3, 2.066);
+ hBackground->SetParameter(4, 0.3016);
+/*
+ TF1 *hBackground = new TF1("hadronicBackgroundFunction", "[0]+[1]*TMath::Erf([2]*x+[3])", 0, 20);
+ hBackground->SetParameter(0, 8.19639e-02);
+ hBackground->SetParameter(1, 7.66857e-02);
+ hBackground->SetParameter(2, 8.74797e-01);
+ hBackground->SetParameter(3, -2.69972e+00);
+*/
+/* hBackground->SetParameter(0, 0.1249);
+ hBackground->SetParameter(1, 0.1239);
+ hBackground->SetParameter(2, 0.8156);
+ hBackground->SetParameter(3, -2.867);*/
+ task->SetBackGroundFactorsFunction(hBackground);
+ }
+
+ // Define PID
+ AliHFEpid *pid = task->GetPID();
+ if(useMC) pid->SetHasMCData(kTRUE);
+ pid->AddDetector("TOF", 0);
+ pid->AddDetector("TPC", 1);
+ pid->ConfigureTPCrejection();
+ // Define electron line correction
+ /*TF1 *elelinecorrection = new TF1("elelinecorrection", "[0]*TMath::Exp([1]*x", 0.. 20.);
+ elelinecorrection->SetParameter(0, -1.28330e-01);
+ elelinecorrection->SetParameter(1, -2.53721e-01);
+ AliHFEpidTPC *tpcpid = dynamic_cast<AliHFEpidTPC *>(pid->GetDetPID(AliHFEpid::kTPCpid));
+ tpcpid->SetElectronMeanCorrection(elelinecorrection);*/
+
+ if(kAnalyseTaggedTracks){
+ AliHFEcuts *v0trackCuts = new AliHFEcuts("V0trackCuts", "Track Cuts for tagged track Analysis");
+ v0trackCuts->CreateStandardCuts();
+ v0trackCuts->SetMinNClustersTPC(60);
+ v0trackCuts->SetMinNClustersITS(1);
+ v0trackCuts->SetCutITSpixel(AliHFEextraCuts::kAny);
+ v0trackCuts->SetCheckITSLayerStatus(kFALSE);
+ v0trackCuts->UnsetVertexRequirement();
+ //hfecuts->SetSigmaToVertex(10);
+ v0trackCuts->SetQAOn();
+
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kTaggedTrackAnalysis);
+ task->SetTaggedTrackCuts(v0trackCuts);
+ task->SetCleanTaggedTrack(kTRUE);
+ }
+
+ // QA
+ printf("task %p\n", task);
+ task->SetQAOn(AliAnalysisTaskHFE::kPIDqa);
+ task->SetQAOn(AliAnalysisTaskHFE::kMCqa);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kIsElecBackGround);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kSecVtx);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kDEstep);
+
+ printf("*************************************\n");
+ printf("Configuring standard Task:\n");
+ task->PrintStatus();
+ pid->PrintStatus();
+ printf("*************************************\n");
+ return task;
+}
--- /dev/null
+AliAnalysisTaskHFE* ConfigHFEstandard_PbPb(Bool_t useMC){
+ //
+ // HFE standard task configuration
+ //
+
+ AliHFEcuts *hfecuts = new AliHFEcuts("hfeCuts","HFE Standard Cuts");
+ hfecuts->CreateStandardCuts();
+ hfecuts->SetMinNClustersTPC(80);
+ hfecuts->SetMinNClustersITS(3);
+ hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
+ hfecuts->SetCheckITSLayerStatus(kFALSE);
+ hfecuts->UnsetVertexRequirement();
+ hfecuts->SetSigmaToVertex(10);
+ hfecuts->SetQAOn();
+ //hfecuts->SetMinNTrackletsTRD(5);
+
+ AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE("HFEanalysisStandard");
+ task->SetHFECuts(hfecuts);
+// task->SetRemovePileUp(kTRUE);
+
+ // Define Variables
+ AliHFEvarManager *vm = task->GetVarManager();
+ vm->AddVariable("pt");
+ vm->AddVariable("eta");
+ vm->AddVariable("phi");
+ vm->AddVariable("charge");
+ vm->AddVariable("source");
+ vm->AddVariable("centrality");
+
+ if(!useMC){
+ TF1 *hBackground = new TF1("hadronicBackgroundFunction", "[0]+[1]*TMath::Erf([2]*x+[3])", 0, 20);
+ hBackground->SetParameter(0, 8.19639e-02);
+ hBackground->SetParameter(1, 7.66857e-02);
+ hBackground->SetParameter(2, 8.74797e-01);
+ hBackground->SetParameter(3, -2.69972e+00);
+/* hBackground->SetParameter(0, 0.1249);
+ hBackground->SetParameter(1, 0.1239);
+ hBackground->SetParameter(2, 0.8156);
+ hBackground->SetParameter(3, -2.867);*/
+ task->SetBackGroundFactorsFunction(hBackground);
+ }
+
+ // Define PID
+ AliHFEpid *pid = task->GetPID();
+ if(useMC) pid->SetHasMCData(kTRUE);
+ pid->AddDetector("TOF", 0);
+ pid->AddDetector("TPC", 1);
+ pid->ConfigureTPCrejection();
+
+ // QA
+ task->SetQAOn(AliAnalysisTaskHFE::kPIDqa);
+ task->SetQAOn(AliAnalysisTaskHFE::kMCqa);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kIsElecBackGround);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kSecVtx);
+
+ printf("*************************************\n");
+ printf("Configuring standard Task:\n");
+ task->Print();
+ pid->PrintStatus();
+ printf("*************************************\n");
+ return task;
+}
--- /dev/null
+AliAnalysisTaskHFE *ConfigHFEtest(Bool_t useMC){
+ //
+ // HFE standard task configuration
+ //
+
+ AliHFEcuts *hfecuts = new AliHFEcuts("hfeCutsTest","HFE Standard Cuts with slight variation");
+ hfecuts->CreateStandardCuts();
+ hfecuts->SetMinNClustersTPC(100);
+ hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
+ hfecuts->SetCheckITSLayerStatus(kFALSE);
+ hfecuts->SetSigmaToVertex(10);
+ hfecuts->SetQAOn();
+ //hfecuts->SetMinNTrackletsTRD(5);
+
+ AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE("HFEanalysis1");
+ task->SetHFECuts(hfecuts);
+
+ // Define Variables
+ AliHFEvarManager *vm = task->GetVarManager();
+ vm->AddVariable("pt");
+ vm->AddVariable("eta");
+ vm->AddVariable("phi");
+ vm->AddVariable("charge");
+ vm->AddVariable("source");
+
+ if(!useMC){
+ TF1 *hBackground = new TF1("hadronicBackgroundFunction", "[0]+[1]*TMath::Erf([2]*x+[3])", 0, 20);
+ hBackground->SetParameter(0, 8.19639e-02);
+ hBackground->SetParameter(1, 7.66857e-02);
+ hBackground->SetParameter(2, 8.74797e-01);
+ hBackground->SetParameter(3, -2.69972e+00);
+
+ task->SetBackGroundFactorsFunction(hBackground);
+ }
+
+ // Define PID
+ AliHFEpid *pid = task->GetPID();
+ if(useMC) pid->SetHasMCData(kTRUE);
+ pid->AddDetector("TOF", 0);
+ pid->AddDetector("TPC", 1);
+ pid->ConfigureTPCrejection();
+
+ // QA
+ task->SetQAOn(AliAnalysisTaskHFE::kPIDqa);
+ task->SetQAOn(AliAnalysisTaskHFE::kMCqa);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kIsElecBackGround);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kSecVtx);
+
+ printf("*************************************\n");
+ printf("Configuring standard Task:\n");
+ task->Print();
+ pid->PrintStatus();
+ printf("*************************************\n");
+ return task;
+}
--- /dev/null
+AliAnalysisTaskHFE *ConfigHFEtrd(Bool_t useMC){
+ //
+ // HFE standard task configuration
+ //
+
+ AliHFEcuts *hfecuts = new AliHFEcuts("hfeCutsTRD","HFE cuts including TRD PID");
+ hfecuts->CreateStandardCuts();
+ hfecuts->SetMinNClustersTPC(110);
+ hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
+ hfecuts->SetCheckITSLayerStatus(kFALSE);
+ hfecuts->SetSigmaToVertex(10);
+ hfecuts->SetQAOn();
+ hfecuts->SetMinNTrackletsTRD(6);
+
+ AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE("HFEanalysisTRD");
+ printf("task %p\n", task);
+ task->SetHFECuts(hfecuts);
+
+ // Define Variables
+ AliHFEvarManager *vm = task->GetVarManager();
+ vm->AddVariable("pt");
+ vm->AddVariable("eta");
+ vm->AddVariable("phi");
+ vm->AddVariable("charge");
+ vm->AddVariable("source");
+
+ // Define PID
+ AliHFEpid *pid = task->GetPID();
+ pid->AddDetector("TOF", 0);
+ pid->AddDetector("TRD", 1);
+ pid->AddDetector("TPC", 2);
+ AliHFEpidTRD *trdpid = pid->GetDetPID(AliHFEpid::kTRDpid);
+ trdpid->SetPIDMethod(AliHFEpidTRD::kLQ);
+ trdpid->SetElectronEfficiency(0.71);
+ // New threshold parameters for LHC10d
+ const Double_t kNparams = 4;
+ Double_t par70[kNparams] = {2.29791e-02, 1.17777e-02, 4.29038e-02, 2.11955e+00};
+ Double_t par75[kNparams] = {-1.89881e+00, -2.31561e-01, 1.98553e+00, -1.04081e-01};
+ Double_t par80[kNparams] = {-1.85572e+00, -3.88746e-01, 2.01796e+00, -1.61435e-01};
+ Double_t par85[kNparams] = {2.44547e-01, -8.26956e-02, 4.49075e-02, -7.84496e-01};
+ Double_t par90[kNparams] = {1.64799e-01, 2.07216e-01, 4.43009e-01, 1.19677e+00};
+ Double_t par95[kNparams] = {8.43719e-01, 4.95028e-02, 1.11009e-01, 4.58459e+00};
+ trdpid->SetThresholdParameters(0.71, par70);
+ trdpid->SetThresholdParameters(0.76, par75);
+ trdpid->SetThresholdParameters(0.81, par80);
+ trdpid->SetThresholdParameters(0.86, par85);
+ trdpid->SetThresholdParameters(0.91, par90);
+ trdpid->SetThresholdParameters(0.96, par95);
+
+ // QA
+ printf("task %p\n", task);
+ task->SetQAOn(AliAnalysisTaskHFE::kPIDqa);
+ task->SetQAOn(AliAnalysisTaskHFE::kMCqa);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kIsElecBackGround);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kSecVtx);
+ task->SwitchOnPlugin(AliAnalysisTaskHFE::kDEstep);
+
+ printf("*************************************\n");
+ printf("Configuring standard Task:\n");
+ task->PrintStatus();
+ pid->PrintStatus();
+ printf("*************************************\n");
+ return task;
+}
--- /dev/null
+//-----------------Global variables for the the analysis------------------------
+TString aliroot_version = "v4-21-11-AN";
+TString analysis_mode = "";
+TString output_file = "PWG3hfe.root";
+TString root_version = "";
+TString api_version = "V1.1x";
+TString input_data = "";
+
+//___________________________________________________________
+Bool_t FindDependentPackages(){
+ // Find packages where aliroot depends on
+ // Method is the following: the dependencies are on a webpage on alimonitor
+ // we download file and try to find the aliroot expression in the file. The line
+ // we read into a string. The we tokenize the string and look for the expression VO_ALICE@ROOT::
+ // Then we have all information we need
+ const char *wd = gSystem->pwd();
+ gSystem->cd("/tmp");
+ gSystem->Exec("wget http://alimonitor.cern.ch/packages");
+ TString setting = gSystem->GetFromPipe(Form("cat index.html | grep VO_ALICE@AliRoot::%s", aliroot_version.Data()));
+ gSystem->Exec("rm index.html");
+ gSystem->cd(wd);
+ if(!setting.Length()) return kFALSE;
+ TObjArray *tokens = setting.Tokenize(";");
+ TIter tokiter(tokens);
+ TObjString *os = NULL;
+ while((os = dynamic_cast<TObjString *>(tokiter()))){
+ TString &mys = os->String();
+ if(!mys.Contains("VO_ALICE@ROOT")) continue;
+ mys.ReplaceAll("VO_ALICE@ROOT::", "");
+ mys.ReplaceAll(""","");
+ root_version = mys;
+ break;
+ }
+ // print results:
+ printf("Found Packages for Analysis:\n");
+ printf("=====================================\n");
+ printf("ALIROOT: %s\n", aliroot_version.Data());
+ printf("ROOT: %s\n", root_version.Data());
+ printf("\n");
+ return kTRUE;
+}
+
+//___________________________________________________________
+AliAnalysisAlien *CreateAlienHandler(Bool_t isProof){
+ //if(!AliAnalysisGrid::CreateToken()) return NULL;
+ if(!FindDependentPackages()) return NULL;
+ AliAnalysisAlien *alienplugin = new AliAnalysisAlien;
+
+ // common settings
+ alienplugin->SetAliROOTVersion(aliroot_version);
+ alienplugin->SetROOTVersion(root_version);
+ alienplugin->SetAPIVersion(api_version);
+ alienplugin->SetAdditionalLibs("libPWG3hfe.so");
+ alienplugin->SetDefaultOutputs(kTRUE);
+ if(isProof){
+ // proof mode
+ if(analysis_mode.Contains("test")) alienplugin->SetRunMode("test");
+ alienplugin->SetProofCluster("alice_caf.cern.ch");
+ alienplugin->SetRootVersionForProof(root_version);
+ alienplugin->SetAliRootMode("aliroot");
+ } else {
+ // grid mode
+ alienplugin->SetRunMode(analysis_mode.Data());
+ // default setting that need no deeper logic
+ alienplugin->SetJDLName("hfeanalysis.jdl");
+ alienplugin->SetExecutable("hfeanalysis.sh");
+ alienplugin->SetAnalysisMacro("hfeanalysis.C");
+ alienplugin->SetValidationScript("hfevalidate.sh");
+ alienplugin->SetGridWorkingDir("hfeanalysis");
+ /*alienplugin->SetOutputArchive();
+ alienplugin->SetDefaultOutputs();*/
+ alienplugin->SetOverwriteMode();
+ alienplugin->SetFastReadOption();
+ alienplugin->SetSplitMaxInputFileNumber(5);
+ alienplugin->SetTTL(30000);
+ alienplugin->SetInputFormat("xml-single");
+ alienplugin->SetPrice(1);
+ alienplugin->SetSplitMode("se");
+ alienplugin->SetNtestFiles(1);
+
+ // Merging setting, only needed in terminate or full mode
+ if(analysis_mode.Contains("full") || analysis_mode.Contains("terminate")){
+ alienplugin->SetMergeViaJDL();
+ alienplugin->SetMaxMergeFiles(50);
+ alienplugin->SetMaxMergeStages(5);
+ }
+ }
+ return alienplugin;
+}
+
+//___________________________________________________________
+void DecodeDataString(const TString &datastring, TString &sample, TArrayI &listofruns){
+ TObjArray *toks = datastring.Tokenize(":");
+ sample = (dynamic_cast<TObjString *>(toks->At(0)))->String();
+ TString &listrunstring = (dynamic_cast<TObjString *>(toks->At(1)))->String();
+ TObjArray *runstrings = listrunstring.Tokenize(",");
+ TIter runiter(runstrings);
+ listofruns.Set(runstrings->GetEntriesFast());
+ TObjString *myrunstring = NULL;
+ Int_t counter = 0;
+ while((myrunstring = dynamic_cast<TObjString *>(runiter()))) listofruns[counter++] = myrunstring->String().Atoi();
+ // Print summary:
+ printf("Selected sample: %s\n", sample.Data());
+ printf("========================================\n");
+ for(Int_t irun = 0; irun < listofruns.GetSize(); irun++){
+ printf("\trun %d\n", listofruns[irun]);
+ }
+ printf("\n");
+ delete toks; delete runstrings;
+}
+
+//___________________________________________________________
+Int_t GetYear(TString &sample){
+ TString yearstring = sample(3,4);
+ Int_t year = yearstring.Atoi();
+ return 2000 + year;
+}
+
+//___________________________________________________________
+void AddInput(AliAnalysisAlien *alienhandler, TString sample, TArrayI &listofruns, Bool_t MC){
+ Int_t year = GetYear(sample);
+ TString specialpattern, datapattern;
+ if(!MC){
+ // handle Data
+ datapattern = "ESDs/pass2/*ESDs.root";
+ specialpattern = Form("data/%d", year);
+ //alienhandler->SetRunPrefix("%09d");
+ } else {
+ // handle MC
+ datapattern = "*ESDs.root";
+ specialpattern = "sim";
+ }
+ alienhandler->SetGridDataDir(Form("/alice/%s/%s", specialpattern.Data(), sample.Data()));
+ alienhandler->SetDataPattern(datapattern.Data());
+ for(Int_t ien = 0; ien < listofruns.GetSize(); ien++){
+ if(!MC) alienhandler->AddRunNumber(Form("%09d", listofruns[ien]));
+ else alienhandler->AddRunNumber(listofruns[ien]);
+ }
+ alienhandler->SetGridOutputDir(sample.Data());
+ alienhandler->SetOutputToRunNo();
+}
+
+//___________________________________________________________
+void runAlien(TString data, TString mode = "test", Bool_t MC = kFALSE){
+ if(!gSystem->Getenv("ALICE_ROOT")){
+ printf("AliRoot has to be initialized\n");
+ return;
+ }
+
+ // check for valid modes
+ const int kModes = 5;
+ TString allowed_modes[kModes] = {"proof", "prooftest", "test", "full", "submit"};
+ Bool_t isValid = kFALSE;
+ mode.ToLower();
+ for(int imode = 0; imode < kModes; imode++){
+ if(!mode.CompareTo(allowed_modes[imode])) isValid = kTRUE;
+ }
+ if(!isValid){
+ printf("invalid analysis mode selected\n");
+ return;
+ }
+ analysis_mode = mode;
+ Bool_t proofmode = mode.Contains("proof");
+ // libraries to be loaded
+ gSystem->Load("libANALYSIS");
+ gSystem->Load("libANALYSISalice");
+ gSystem->Load("libCORRFW");
+ gSystem->Load("libPWG3hfe");
+
+ // Create Analysis Manager
+ AliAnalysisManager *runAnalysis = new AliAnalysisManager("Heavy Flavour Electron Analysis");
+ runAnalysis->SetCommonFileName(output_file.Data());
+ runAnalysis->SetInputEventHandler(new AliESDInputHandler);
+ if(MC) runAnalysis->SetMCtruthEventHandler(new AliMCEventHandler);
+ AliAnalysisAlien *alienhandler = CreateAlienHandler(proofmode);
+ printf("alienhandler %p\n", alienhandler);
+ runAnalysis->SetGridHandler(alienhandler);
+ //return;
+
+ // Specify input (runs or dataset)
+ if(!proofmode){
+ // Query sample ID and runs
+ TString sample;
+ TArrayI listofruns;
+ DecodeDataString(data, sample, listofruns);
+ AddInput(alienhandler, sample, listofruns, MC);
+ } else {
+ alienhandler->SetProofDataSet(data);
+ }
+
+ // Add Tasks
+ gROOT->LoadMacro(Form("%s/ANALYSIS/macros/AddTaskPhysicsSelection.C", gSystem->Getenv("ALICE_ROOT")));
+ gROOT->LoadMacro(Form("%s/PWG3/hfe/macros/AddTaskHFE.C", gSystem->Getenv("ALICE_ROOT")));
+ AddTaskPhysicsSelection(MC);
+ AddTaskHFE(); // @TODO: MC and PbPb flag to be fixed
+
+ // Run Analysis
+ TString anamode = proofmode ? "proof" : "grid";
+ if(runAnalysis->InitAnalysis()){
+ runAnalysis->PrintStatus();
+ runAnalysis->StartAnalysis(anamode);
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff