[u/mrichter/AliRoot.git] / PWG0 / multiplicity / run.C

void run(Char_t* data, Long64_t nRuns = -1, Long64_t offset = 0, Bool_t aDebug = kFALSE, Int_t aProof = 0, Int_t requiredData = 1, const char* option = "")
{
  // aProof option: 
  //               -2 grid, terminate mode
  //               -1 grid, full mode
  //                0 local
  //                1 proof with chain
  //                2 proof with dataset
  //                3 local with proof dataset 
  //
  // requiredData option: 0 = only ESD
  //                      1 = ESD+MC
  //                      2 = RAW (ESD+check on event type)
  //

  if (nRuns < 0)
    nRuns = 1234567890;

  if (aProof > 0)
  {
    gEnv->SetValue("XSec.GSI.DelegProxy", "2");
    TProof::Open("alicecaf");
    
    // Enable the needed package
    if (1)
    {
      gProof->UploadPackage("$ALICE_ROOT/STEERBase");
      gProof->EnablePackage("$ALICE_ROOT/STEERBase");
      gProof->UploadPackage("$ALICE_ROOT/ESD");
      gProof->EnablePackage("$ALICE_ROOT/ESD");
      gProof->UploadPackage("$ALICE_ROOT/AOD");
      gProof->EnablePackage("$ALICE_ROOT/AOD");
      gProof->UploadPackage("$ALICE_ROOT/ANALYSIS");
      gProof->EnablePackage("$ALICE_ROOT/ANALYSIS");
      gProof->UploadPackage("$ALICE_ROOT/ANALYSISalice");
      gProof->EnablePackage("$ALICE_ROOT/ANALYSISalice");
    }
    else
    {
      gProof->UploadPackage("$ALICE_ROOT/AF-v4-16");
      gProof->EnablePackage("$ALICE_ROOT/AF-v4-16");
    }

    gProof->UploadPackage("$ALICE_ROOT/PWG0base");
    gProof->EnablePackage("$ALICE_ROOT/PWG0base");
  }
  else
  {
    gSystem->Load("libVMC");
    gSystem->Load("libTree");
    gSystem->Load("libSTEERBase");
    gSystem->Load("libESD");
    gSystem->Load("libAOD");
    gSystem->Load("libANALYSIS");
    gSystem->Load("libANALYSISalice");
    gSystem->Load("libPWG0base");
    
    gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0"));
  }

  // Create the analysis manager
  mgr = new AliAnalysisManager;

  // Add ESD handler
  AliESDInputHandler* esdH = new AliESDInputHandler;
  esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks AliESDTZERO ALIESDACORDE MuonTracks TrdTracks");
  mgr->SetInputEventHandler(esdH);

  // physics selection
  gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
  physicsSelectionTask = AddTaskPhysicsSelection((requiredData == 2) ? kFALSE : kTRUE);

  // FO efficiency (for MC)
  if (0 && requiredData != 2)
  {
    //const char* fastORFile = "../dNdEta/spdFOEff_run104824_52.root";
    //const char* fastORFile = "../dNdEta/spdFOEff_run104867_92.root";
    //const char* fastORFile = "../dNdEta/spdFOEff_run105054_7.root";
    const char* fastORFile = "../dNdEta/spdFOEff_run114931.root";
  
    Printf("NOTE: Simulating FAST-OR efficiency on the analysis level using file %s", fastORFile);
    TFile::Open(fastORFile);
    
    spdFOEff = (TH1F*) gFile->Get("spdFOEff");
    physicsSelectionTask->GetPhysicsSelection()->Initialize(114931);
    physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis()->SetSPDGFOEfficiency(spdFOEff);
  }
  
  AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD | AliPWG0Helper::kFieldOn;
  //AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPCITS | AliPWG0Helper::kFieldOn;
  
  //AliTriggerAnalysis::Trigger trigger      = AliTriggerAnalysis::kAcceptAll | AliTriggerAnalysis::kOfflineFlag;
  AliTriggerAnalysis::Trigger trigger      = AliTriggerAnalysis::kAcceptAll | AliTriggerAnalysis::kOfflineFlag | AliTriggerAnalysis::kOneParticle; 
  
  //AliTriggerAnalysis::Trigger trigger      = AliTriggerAnalysis::kMB1Prime | AliTriggerAnalysis::kOfflineFlag;
  //AliTriggerAnalysis::Trigger trigger      = AliTriggerAnalysis::kSPDGFOBits | AliTriggerAnalysis::kOfflineFlag;
  //AliTriggerAnalysis::Trigger trigger      = AliTriggerAnalysis::kV0AND | AliTriggerAnalysis::kOfflineFlag; 

  AliPWG0Helper::DiffTreatment diffTreatment = AliPWG0Helper::kMCFlags;
  //AliPWG0Helper::DiffTreatment diffTreatment = AliPWG0Helper::kE710Cuts;
  
  AliPWG0Helper::PrintConf(analysisMode, trigger, diffTreatment);

  TString taskName("AliMultiplicityTask.cxx+");
  if (aDebug)
    taskName += "+g";

  // Create, add task
  if (aProof > 0) {
    gProof->Load(taskName);
  } else
    gROOT->Macro(taskName);

  // 0 bin calculation
  if (0)
  {
  }
  
  // V0 syst. study
  if (0)
  {
    Printf("NOTE: Systematic study for VZERO enabled!");
    //physicsSelectionTask->GetPhysicsSelection()->Initialize(104867);
    for (Int_t i=0; i<1; i++)
    {
      // for MC and data
      physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0HwPars(15, 61.5, 86.5);
      physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0AdcThr(15);
      // only for MC
      //physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0HwPars(0, 0, 125);
      //physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0AdcThr(0);
    }
  }

  TString optionStr(option);
  
  // remove SAVE option if set
  Bool_t save = kFALSE;
  TString optionStr(option);
  if (optionStr.Contains("SAVE"))
  {
    optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length());
    save = kTRUE;
  }
  
  task = new AliMultiplicityTask(optionStr);

  if (!(analysisMode & AliPWG0Helper::kSPD))
  {
    // selection of esd tracks
    gROOT->ProcessLine(".L ../CreateStandardCuts.C");
    AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
    if (!esdTrackCuts)
    {
      printf("ERROR: esdTrackCuts could not be created\n");
      return;
    }

    task->SetTrackCuts(esdTrackCuts);
  }
  //else
  //  task->SetDeltaPhiCut(0.05);

  task->SetAnalysisMode(analysisMode);
  task->SetTrigger(trigger);
  task->SetDiffTreatment(diffTreatment);

  if (requiredData == 1)
    task->SetReadMC();

  //task->SetUseMCVertex();
  
  if (requiredData != 2)
    task->SetSkipParticles();

  mgr->AddTask(task);

  if (requiredData == 1) {
    // Enable MC event handler
    AliMCEventHandler* handler = new AliMCEventHandler;
    if (!optionStr.Contains("particle-efficiency"))
      handler->SetReadTR(kFALSE);
    mgr->SetMCtruthEventHandler(handler);
  }

  // pt study
  if (optionStr.Contains("pt-spectrum-func"))
  {
    TF1* func = new TF1("func", "1", 0, 0.2);
    //TF1* func = new TF1("func", "1.5 - x / 0.2 * 0.5", 0, 0.2);
    //TF1* func = new TF1("func", "1.25 - x / 0.2 * 0.25", 0, 0.2);
    //TF1* func = new TF1("func", "0.75 + x / 0.2 * 0.25", 0, 0.2);
    hist = func->GetHistogram();
    //new TCanvas; func->Draw();
    //inputList.Add(func->GetHistogram()->Clone("pt-spectrum"));

    new TCanvas; hist->Draw();
    task->SetPtSpectrum((TH1D*) hist->Clone("pt-spectrum"));
  }

  // Attach input
  cInput  = mgr->GetCommonInputContainer();
  mgr->ConnectInput(task, 0, cInput);

  // Attach output
  cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer, "mult_Temp.root");
  mgr->ConnectOutput(task, 0, cOutput);

  // Enable debug printouts
  if (aDebug)
    mgr->SetDebugLevel(2);

  // Run analysis
  mgr->InitAnalysis();
  mgr->PrintStatus();

  if (aProof == 2)
  {
    // process dataset

    mgr->StartAnalysis("proof", data, nRuns, offset);
  
    if (save)
    {
      TString path("maps/");
      path += TString(data).Tokenize("/")->Last()->GetName();
      
      UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) AliTriggerAnalysis::kStartOfFlags;
      switch (triggerNoFlags)
      {
        case AliTriggerAnalysis::kAcceptAll: path += "/all"; break;
        case AliTriggerAnalysis::kMB1: path += "/mb1"; break;
        case AliTriggerAnalysis::kMB2: path += "/mb2"; break;
        case AliTriggerAnalysis::kMB3: path += "/mb3"; break;
        case AliTriggerAnalysis::kSPDGFO: path += "/spdgfo"; break;
        case AliTriggerAnalysis::kSPDGFOBits: path += "/spdgfobits"; break;
        case AliTriggerAnalysis::kV0AND: path += "/v0and"; break;
        case AliTriggerAnalysis::kNSD1: path += "/nsd1"; break;
        case AliTriggerAnalysis::kMB1Prime: path += "/mb1prime"; break;
        default: Printf("ERROR: Trigger undefined for path to files"); return;
      }
      
      if (trigger & AliTriggerAnalysis::kOneParticle)
        path += "-onepart";
      
      if (analysisMode & AliPWG0Helper::kSPD)
        path += "/spd";
      
      if (analysisMode & AliPWG0Helper::kTPC)
        path += "/tpc";
        
      if (analysisMode & AliPWG0Helper::kTPCITS)
        path += "/tpcits";

      gSystem->mkdir(path, kTRUE);
      
      TString fileName("multiplicity");
      if (optionStr.Contains("only-process-type-nd"))
        fileName += "ND";
      if (optionStr.Contains("only-process-type-sd"))
        fileName += "SD";
      if (optionStr.Contains("only-process-type-dd"))
        fileName += "DD";
      fileName += ".root";
      
      gSystem->Rename(fileName, path + "/" + fileName);
      gSystem->Rename("event_stat.root", path + "/event_stat.root");
      
      Printf(">>>>> Moved files to %s", path.Data());
    }  
  }
  else if (aProof == 3)
  {
    gROOT->ProcessLine(".L CreateChainFromDataSet.C");
    ds = gProof->GetDataSet(data)->GetStagedSubset();
    chain = CreateChainFromDataSet(ds, "esdTree", nRuns);
    mgr->StartAnalysis("local", chain, nRuns, offset);
  }
  else if (aProof == 0)
  {
    // Create chain of input files
    gROOT->LoadMacro("../CreateESDChain.C");
    chain = CreateESDChain(data, nRuns, offset);

    mgr->StartAnalysis((aProof > 0) ? "proof" : "local", chain);
  }
  else if (aProof == -1 || aProof == -2)
  {
    gSystem->Unlink("EventStat_temp.root");
    gSystem->Unlink("mult_Temp.root");
    gSystem->Unlink("event_stat.root");
    gSystem->Unlink("multiplicity.root");
  
    AliAnalysisAlien *plugin = new AliAnalysisAlien();
  
    if (aProof == -1)
      plugin->SetRunMode("full");
    else
      plugin->SetRunMode("terminate");

    plugin->SetAPIVersion("V1.1x");
    plugin->SetROOTVersion("v5-26-00b-2");
    //plugin->SetAliROOTVersion("v4-19-10-AN");
  
    //plugin->SetGridDataDir("/alice/sim/LHC10b6");
    //plugin->SetDataPattern("*/AliESDs.root");
    //plugin->SetRunRange(115186, 115210);
    
    //plugin->SetGridDataDir("/alice/data/2010/LHC10b");
    //plugin->SetDataPattern("*/AliESDs.root");
    //plugin->SetRunRange(114931, 114931);
    //plugin->SetRunPrefix("000");
    
  //plugin->AddDataFile("/alice/cern.ch/user/j/jgrosseo/run114931_6.xml"); //LHC10b4
  
    TString dataStr(data);
    dataStr.ReplaceAll("__", "#");
    TObjArray* dataList = dataStr.Tokenize("#");
    for (Int_t i=0; i<dataList->GetEntries(); i++)
      plugin->AddDataFile(Form("/alice/cern.ch/user/j/jgrosseo/%s", dataList->At(i)->GetName()));
  
    TGrid::Connect("alien://");
    
    // use work dir from ds name
    TString dir;
    dir.Form("gridjob/dir_%s", data);
    if (aProof == -1)
      gGrid->Rmdir(dir);
    
    /*
    Int_t n = 0;
    while (n < 1000)
    {
      dir.Form("gridjob/dir%d", n);
      TMap* mapLs = (TMap*) gGrid->Ls(dir)->At(0);
      TObjString *valueLsPath = dynamic_cast<TObjString*>(mapLs->GetValue("path"));
      if (!valueLsPath)
        break;
      n++;
    }
    if (n == 1000)
      AliFatal("Clean your home dir!");
    if (aProof == -2)
      n--;
    dir.Form("gridjob/dir%d", n);
    */
    Printf(">>>>> Using relative dir %s", dir.Data());
  
    plugin->SetGridWorkingDir(dir);
    plugin->SetGridOutputDir("griddir");
    plugin->SetDefaultOutputs();
    
    //
    plugin->SetFastReadOption();
  
  //plugin->EnablePackage(gSystem->ExpandPathName("$ALICE_ROOT/PWG0base.par"));
    plugin->EnablePackage(gSystem->ExpandPathName("STEERBase.par"));
    plugin->EnablePackage(gSystem->ExpandPathName("ESD.par"));
    plugin->EnablePackage(gSystem->ExpandPathName("AOD.par"));
    plugin->EnablePackage(gSystem->ExpandPathName("ANALYSIS.par"));
    plugin->EnablePackage(gSystem->ExpandPathName("ANALYSISalice.par"));
    plugin->EnablePackage(gSystem->ExpandPathName("PWG0base.par"));
    plugin->SetAnalysisSource("AliMultiplicityTask.cxx");
    plugin->SetAdditionalLibs("AliMultiplicityTask.h AliMultiplicityTask.cxx");
  
    plugin->SetSplitMaxInputFileNumber(50);
    plugin->SetNtestFiles(2);
  
    AliAnalysisManager::GetAnalysisManager()->SetGridHandler(plugin);
    
    mgr->StartAnalysis("grid");
    if (aProof == -1)
      return;
  }

  if (save)
  {
    TString path("maps/");
    path += TString(data).Tokenize("/")->Last()->GetName();
  
    UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) AliTriggerAnalysis::kStartOfFlags;
    switch (triggerNoFlags)
    {
      case AliTriggerAnalysis::kAcceptAll: path += "/all"; break;
      case AliTriggerAnalysis::kMB1: path += "/mb1"; break;
      case AliTriggerAnalysis::kMB2: path += "/mb2"; break;
      case AliTriggerAnalysis::kMB3: path += "/mb3"; break;
      case AliTriggerAnalysis::kSPDGFO: path += "/spdgfo"; break;
      case AliTriggerAnalysis::kSPDGFOBits: path += "/spdgfobits"; break;
      case AliTriggerAnalysis::kV0AND: path += "/v0and"; break;
      case AliTriggerAnalysis::kNSD1: path += "/nsd1"; break;
      case AliTriggerAnalysis::kMB1Prime: path += "/mb1prime"; break;
      default: Printf("ERROR: Trigger undefined for path to files"); return;
    }
  
    if (trigger & AliTriggerAnalysis::kOneParticle)
      path += "-onepart";
  
    if (analysisMode & AliPWG0Helper::kSPD)
      path += "/spd";
  
    if (analysisMode & AliPWG0Helper::kTPC)
      path += "/tpc";
    
    if (analysisMode & AliPWG0Helper::kTPCITS)
      path += "/tpcits";

    gSystem->mkdir(path, kTRUE);
  
    TString fileName("multiplicity");
    if (optionStr.Contains("only-process-type-nd"))
      fileName += "ND";
    if (optionStr.Contains("only-process-type-sd"))
      fileName += "SD";
    if (optionStr.Contains("only-process-type-dd"))
      fileName += "DD";
    fileName += ".root";
  
    gSystem->Rename(fileName, path + "/" + fileName);
    gSystem->Rename("event_stat.root", path + "/event_stat.root");
  
    Printf(">>>>> Moved files to %s", path.Data());
  }
}
Commit	Line	Data
eb9356d5	1	void run(Char_t* data, Long64_t nRuns = -1, Long64_t offset = 0, Bool_t aDebug = kFALSE, Int_t aProof = 0, Int_t requiredData = 1, const char* option = "")
a9017e49	2	{
f55b30d2	3	// aProof option:
	4	// -2 grid, terminate mode
	5	// -1 grid, full mode
	6	// 0 local
745d6088	7	// 1 proof with chain
745d6088	8	// 2 proof with dataset
f55b30d2	9	// 3 local with proof dataset
eb9356d5	10	//
	11	// requiredData option: 0 = only ESD
	12	// 1 = ESD+MC
	13	// 2 = RAW (ESD+check on event type)
	14	//
745d6088	15
	16	if (nRuns < 0)
	17	nRuns = 1234567890;
	18
f55b30d2	19	if (aProof > 0)
a9017e49	20	{
70fdd197	21	gEnv->SetValue("XSec.GSI.DelegProxy", "2");
69b09e3b	22	TProof::Open("alicecaf");
eb9356d5	23
a9017e49	24	// Enable the needed package
dca331bb	25	if (1)
	26	{
	27	gProof->UploadPackage("$ALICE_ROOT/STEERBase");
	28	gProof->EnablePackage("$ALICE_ROOT/STEERBase");
	29	gProof->UploadPackage("$ALICE_ROOT/ESD");
	30	gProof->EnablePackage("$ALICE_ROOT/ESD");
	31	gProof->UploadPackage("$ALICE_ROOT/AOD");
	32	gProof->EnablePackage("$ALICE_ROOT/AOD");
	33	gProof->UploadPackage("$ALICE_ROOT/ANALYSIS");
	34	gProof->EnablePackage("$ALICE_ROOT/ANALYSIS");
	35	gProof->UploadPackage("$ALICE_ROOT/ANALYSISalice");
	36	gProof->EnablePackage("$ALICE_ROOT/ANALYSISalice");
	37	}
	38	else
	39	{
69b09e3b	40	gProof->UploadPackage("$ALICE_ROOT/AF-v4-16");
69b09e3b	41	gProof->EnablePackage("$ALICE_ROOT/AF-v4-16");
dca331bb	42	}
745d6088	43
	44	gProof->UploadPackage("$ALICE_ROOT/PWG0base");
	45	gProof->EnablePackage("$ALICE_ROOT/PWG0base");
a9017e49	46	}
	47	else
	48	{
	49	gSystem->Load("libVMC");
	50	gSystem->Load("libTree");
	51	gSystem->Load("libSTEERBase");
	52	gSystem->Load("libESD");
dca331bb	53	gSystem->Load("libAOD");
a9017e49	54	gSystem->Load("libANALYSIS");
dca331bb	55	gSystem->Load("libANALYSISalice");
a9017e49	56	gSystem->Load("libPWG0base");
f55b30d2	57
f55b30d2	58	gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0"));
a9017e49	59	}
a9017e49	60
a9017e49	61	// Create the analysis manager
dca331bb	62	mgr = new AliAnalysisManager;
a9017e49	63
eb9356d5	64	// Add ESD handler
	65	AliESDInputHandler* esdH = new AliESDInputHandler;
	66	esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks AliESDTZERO ALIESDACORDE MuonTracks TrdTracks");
	67	mgr->SetInputEventHandler(esdH);
	68
	69	// physics selection
	70	gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
	71	physicsSelectionTask = AddTaskPhysicsSelection((requiredData == 2) ? kFALSE : kTRUE);
	72
	73	// FO efficiency (for MC)
f55b30d2	74	if (0 && requiredData != 2)
eb9356d5	75	{
	76	//const char* fastORFile = "../dNdEta/spdFOEff_run104824_52.root";
	77	//const char* fastORFile = "../dNdEta/spdFOEff_run104867_92.root";
	78	//const char* fastORFile = "../dNdEta/spdFOEff_run105054_7.root";
	79	const char* fastORFile = "../dNdEta/spdFOEff_run114931.root";
	80
	81	Printf("NOTE: Simulating FAST-OR efficiency on the analysis level using file %s", fastORFile);
	82	TFile::Open(fastORFile);
	83
	84	spdFOEff = (TH1F*) gFile->Get("spdFOEff");
	85	physicsSelectionTask->GetPhysicsSelection()->Initialize(114931);
	86	physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis()->SetSPDGFOEfficiency(spdFOEff);
	87	}
	88
	89	AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kSPD \| AliPWG0Helper::kFieldOn;
	90	//AliPWG0Helper::AnalysisMode analysisMode = AliPWG0Helper::kTPCITS \| AliPWG0Helper::kFieldOn;
	91
	92	//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kAcceptAll \| AliTriggerAnalysis::kOfflineFlag;
	93	AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kAcceptAll \| AliTriggerAnalysis::kOfflineFlag \| AliTriggerAnalysis::kOneParticle;
	94
	95	//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kMB1Prime \| AliTriggerAnalysis::kOfflineFlag;
	96	//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kSPDGFOBits \| AliTriggerAnalysis::kOfflineFlag;
	97	//AliTriggerAnalysis::Trigger trigger = AliTriggerAnalysis::kV0AND \| AliTriggerAnalysis::kOfflineFlag;
a2cdb42c	98
eb9356d5	99	AliPWG0Helper::DiffTreatment diffTreatment = AliPWG0Helper::kMCFlags;
	100	//AliPWG0Helper::DiffTreatment diffTreatment = AliPWG0Helper::kE710Cuts;
	101
	102	AliPWG0Helper::PrintConf(analysisMode, trigger, diffTreatment);
a9017e49	103
	104	TString taskName("AliMultiplicityTask.cxx+");
	105	if (aDebug)
	106	taskName += "+g";
	107
	108	// Create, add task
745d6088	109	if (aProof > 0) {
a9017e49	110	gProof->Load(taskName);
	111	} else
	112	gROOT->Macro(taskName);
	113
eb9356d5	114	// 0 bin calculation
	115	if (0)
	116	{
	117	}
	118
	119	// V0 syst. study
	120	if (0)
	121	{
	122	Printf("NOTE: Systematic study for VZERO enabled!");
	123	//physicsSelectionTask->GetPhysicsSelection()->Initialize(104867);
	124	for (Int_t i=0; i<1; i++)
	125	{
	126	// for MC and data
	127	physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0HwPars(15, 61.5, 86.5);
	128	physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0AdcThr(15);
	129	// only for MC
	130	//physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0HwPars(0, 0, 125);
	131	//physicsSelectionTask->GetPhysicsSelection()->GetTriggerAnalysis(i)->SetV0AdcThr(0);
	132	}
	133	}
	134
	135	TString optionStr(option);
	136
	137	// remove SAVE option if set
	138	Bool_t save = kFALSE;
	139	TString optionStr(option);
	140	if (optionStr.Contains("SAVE"))
	141	{
	142	optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length());
	143	save = kTRUE;
	144	}
	145
	146	task = new AliMultiplicityTask(optionStr);
f3eb27f6	147
70fdd197	148	if (!(analysisMode & AliPWG0Helper::kSPD))
f3eb27f6	149	{
	150	// selection of esd tracks
	151	gROOT->ProcessLine(".L ../CreateStandardCuts.C");
	152	AliESDtrackCuts* esdTrackCuts = CreateTrackCuts(analysisMode);
	153	if (!esdTrackCuts)
	154	{
	155	printf("ERROR: esdTrackCuts could not be created\n");
	156	return;
	157	}
	158
	159	task->SetTrackCuts(esdTrackCuts);
	160	}
eb9356d5	161	//else
eb9356d5	162	// task->SetDeltaPhiCut(0.05);
f3eb27f6	163
745d6088	164	task->SetAnalysisMode(analysisMode);
a2cdb42c	165	task->SetTrigger(trigger);
eb9356d5	166	task->SetDiffTreatment(diffTreatment);
2fa65f52	167
eb9356d5	168	if (requiredData == 1)
2fa65f52	169	task->SetReadMC();
2fa65f52	170
f3eb27f6	171	//task->SetUseMCVertex();
eb9356d5	172
	173	if (requiredData != 2)
	174	task->SetSkipParticles();
f3eb27f6	175
a9017e49	176	mgr->AddTask(task);
a9017e49	177
eb9356d5	178	if (requiredData == 1) {
2fa65f52	179	// Enable MC event handler
2fa65f52	180	AliMCEventHandler* handler = new AliMCEventHandler;
69b09e3b	181	if (!optionStr.Contains("particle-efficiency"))
69b09e3b	182	handler->SetReadTR(kFALSE);
2fa65f52	183	mgr->SetMCtruthEventHandler(handler);
2fa65f52	184	}
a9017e49	185
dca331bb	186	// pt study
dca331bb	187	if (optionStr.Contains("pt-spectrum-func"))
dca331bb	188	{
69b09e3b	189	TF1* func = new TF1("func", "1", 0, 0.2);
	190	//TF1* func = new TF1("func", "1.5 - x / 0.2 * 0.5", 0, 0.2);
	191	//TF1* func = new TF1("func", "1.25 - x / 0.2 * 0.25", 0, 0.2);
	192	//TF1* func = new TF1("func", "0.75 + x / 0.2 * 0.25", 0, 0.2);
	193	hist = func->GetHistogram();
dca331bb	194	//new TCanvas; func->Draw();
	195	//inputList.Add(func->GetHistogram()->Clone("pt-spectrum"));
	196
dca331bb	197	new TCanvas; hist->Draw();
69b09e3b	198	task->SetPtSpectrum((TH1D*) hist->Clone("pt-spectrum"));
dca331bb	199	}
dca331bb	200
a9017e49	201	// Attach input
861795a8	202	cInput = mgr->GetCommonInputContainer();
a9017e49	203	mgr->ConnectInput(task, 0, cInput);
	204
	205	// Attach output
f55b30d2	206	cOutput = mgr->CreateContainer("cOutput", TList::Class(), AliAnalysisManager::kOutputContainer, "mult_Temp.root");
a9017e49	207	mgr->ConnectOutput(task, 0, cOutput);
	208
	209	// Enable debug printouts
	210	if (aDebug)
	211	mgr->SetDebugLevel(2);
	212
	213	// Run analysis
	214	mgr->InitAnalysis();
	215	mgr->PrintStatus();
745d6088	216
	217	if (aProof == 2)
	218	{
	219	// process dataset
	220
	221	mgr->StartAnalysis("proof", data, nRuns, offset);
eb9356d5	222
	223	if (save)
	224	{
	225	TString path("maps/");
	226	path += TString(data).Tokenize("/")->Last()->GetName();
	227
	228	UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) AliTriggerAnalysis::kStartOfFlags;
	229	switch (triggerNoFlags)
	230	{
	231	case AliTriggerAnalysis::kAcceptAll: path += "/all"; break;
	232	case AliTriggerAnalysis::kMB1: path += "/mb1"; break;
	233	case AliTriggerAnalysis::kMB2: path += "/mb2"; break;
	234	case AliTriggerAnalysis::kMB3: path += "/mb3"; break;
	235	case AliTriggerAnalysis::kSPDGFO: path += "/spdgfo"; break;
	236	case AliTriggerAnalysis::kSPDGFOBits: path += "/spdgfobits"; break;
	237	case AliTriggerAnalysis::kV0AND: path += "/v0and"; break;
	238	case AliTriggerAnalysis::kNSD1: path += "/nsd1"; break;
	239	case AliTriggerAnalysis::kMB1Prime: path += "/mb1prime"; break;
	240	default: Printf("ERROR: Trigger undefined for path to files"); return;
	241	}
	242
	243	if (trigger & AliTriggerAnalysis::kOneParticle)
	244	path += "-onepart";
	245
	246	if (analysisMode & AliPWG0Helper::kSPD)
	247	path += "/spd";
	248
	249	if (analysisMode & AliPWG0Helper::kTPC)
	250	path += "/tpc";
	251
	252	if (analysisMode & AliPWG0Helper::kTPCITS)
	253	path += "/tpcits";
	254
	255	gSystem->mkdir(path, kTRUE);
	256
	257	TString fileName("multiplicity");
	258	if (optionStr.Contains("only-process-type-nd"))
	259	fileName += "ND";
	260	if (optionStr.Contains("only-process-type-sd"))
	261	fileName += "SD";
	262	if (optionStr.Contains("only-process-type-dd"))
	263	fileName += "DD";
	264	fileName += ".root";
	265
	266	gSystem->Rename(fileName, path + "/" + fileName);
	267	gSystem->Rename("event_stat.root", path + "/event_stat.root");
	268
	269	Printf(">>>>> Moved files to %s", path.Data());
	270	}
745d6088	271	}
69b09e3b	272	else if (aProof == 3)
	273	{
	274	gROOT->ProcessLine(".L CreateChainFromDataSet.C");
	275	ds = gProof->GetDataSet(data)->GetStagedSubset();
eb9356d5	276	chain = CreateChainFromDataSet(ds, "esdTree", nRuns);
69b09e3b	277	mgr->StartAnalysis("local", chain, nRuns, offset);
69b09e3b	278	}
f55b30d2	279	else if (aProof == 0)
745d6088	280	{
	281	// Create chain of input files
	282	gROOT->LoadMacro("../CreateESDChain.C");
	283	chain = CreateESDChain(data, nRuns, offset);
	284
	285	mgr->StartAnalysis((aProof > 0) ? "proof" : "local", chain);
	286	}
f55b30d2	287	else if (aProof == -1 \|\| aProof == -2)
	288	{
	289	gSystem->Unlink("EventStat_temp.root");
	290	gSystem->Unlink("mult_Temp.root");
	291	gSystem->Unlink("event_stat.root");
	292	gSystem->Unlink("multiplicity.root");
	293
	294	AliAnalysisAlien *plugin = new AliAnalysisAlien();
	295
	296	if (aProof == -1)
	297	plugin->SetRunMode("full");
	298	else
	299	plugin->SetRunMode("terminate");
	300
	301	plugin->SetAPIVersion("V1.1x");
	302	plugin->SetROOTVersion("v5-26-00b-2");
	303	//plugin->SetAliROOTVersion("v4-19-10-AN");
	304
	305	//plugin->SetGridDataDir("/alice/sim/LHC10b6");
	306	//plugin->SetDataPattern("*/AliESDs.root");
	307	//plugin->SetRunRange(115186, 115210);
	308
	309	//plugin->SetGridDataDir("/alice/data/2010/LHC10b");
	310	//plugin->SetDataPattern("*/AliESDs.root");
	311	//plugin->SetRunRange(114931, 114931);
	312	//plugin->SetRunPrefix("000");
	313
	314	//plugin->AddDataFile("/alice/cern.ch/user/j/jgrosseo/run114931_6.xml"); //LHC10b4
	315
	316	TString dataStr(data);
	317	dataStr.ReplaceAll("__", "#");
	318	TObjArray* dataList = dataStr.Tokenize("#");
	319	for (Int_t i=0; i<dataList->GetEntries(); i++)
	320	plugin->AddDataFile(Form("/alice/cern.ch/user/j/jgrosseo/%s", dataList->At(i)->GetName()));
	321
	322	TGrid::Connect("alien://");
	323
	324	// use work dir from ds name
	325	TString dir;
	326	dir.Form("gridjob/dir_%s", data);
	327	if (aProof == -1)
	328	gGrid->Rmdir(dir);
	329
	330	/*
	331	Int_t n = 0;
	332	while (n < 1000)
	333	{
	334	dir.Form("gridjob/dir%d", n);
	335	TMap* mapLs = (TMap*) gGrid->Ls(dir)->At(0);
	336	TObjString valueLsPath = dynamic_cast<TObjString>(mapLs->GetValue("path"));
	337	if (!valueLsPath)
	338	break;
	339	n++;
	340	}
	341	if (n == 1000)
	342	AliFatal("Clean your home dir!");
	343	if (aProof == -2)
	344	n--;
	345	dir.Form("gridjob/dir%d", n);
	346	*/
	347	Printf(">>>>> Using relative dir %s", dir.Data());
	348
	349	plugin->SetGridWorkingDir(dir);
	350	plugin->SetGridOutputDir("griddir");
351	plugin->SetDefaultOutputs();
352
353	//
354	plugin->SetFastReadOption();
355
356	//plugin->EnablePackage(gSystem->ExpandPathName("$ALICE_ROOT/PWG0base.par"));
357	plugin->EnablePackage(gSystem->ExpandPathName("STEERBase.par"));
358	plugin->EnablePackage(gSystem->ExpandPathName("ESD.par"));
359	plugin->EnablePackage(gSystem->ExpandPathName("AOD.par"));
360	plugin->EnablePackage(gSystem->ExpandPathName("ANALYSIS.par"));
361	plugin->EnablePackage(gSystem->ExpandPathName("ANALYSISalice.par"));
362	plugin->EnablePackage(gSystem->ExpandPathName("PWG0base.par"));
363	plugin->SetAnalysisSource("AliMultiplicityTask.cxx");
364	plugin->SetAdditionalLibs("AliMultiplicityTask.h AliMultiplicityTask.cxx");
365
366	plugin->SetSplitMaxInputFileNumber(50);
367	plugin->SetNtestFiles(2);
368
369	AliAnalysisManager::GetAnalysisManager()->SetGridHandler(plugin);
370
371	mgr->StartAnalysis("grid");
372	if (aProof == -1)
373	return;
374	}
375
376	if (save)
377	{
378	TString path("maps/");
379	path += TString(data).Tokenize("/")->Last()->GetName();
380
381	UInt_t triggerNoFlags = (UInt_t) trigger % (UInt_t) AliTriggerAnalysis::kStartOfFlags;
382	switch (triggerNoFlags)
383	{
384	case AliTriggerAnalysis::kAcceptAll: path += "/all"; break;
385	case AliTriggerAnalysis::kMB1: path += "/mb1"; break;
386	case AliTriggerAnalysis::kMB2: path += "/mb2"; break;
387	case AliTriggerAnalysis::kMB3: path += "/mb3"; break;
388	case AliTriggerAnalysis::kSPDGFO: path += "/spdgfo"; break;
389	case AliTriggerAnalysis::kSPDGFOBits: path += "/spdgfobits"; break;
390	case AliTriggerAnalysis::kV0AND: path += "/v0and"; break;
391	case AliTriggerAnalysis::kNSD1: path += "/nsd1"; break;
392	case AliTriggerAnalysis::kMB1Prime: path += "/mb1prime"; break;
393	default: Printf("ERROR: Trigger undefined for path to files"); return;
394	}
395
396	if (trigger & AliTriggerAnalysis::kOneParticle)
397	path += "-onepart";
398
399	if (analysisMode & AliPWG0Helper::kSPD)
400	path += "/spd";
401
402	if (analysisMode & AliPWG0Helper::kTPC)
403	path += "/tpc";
404
405	if (analysisMode & AliPWG0Helper::kTPCITS)
406	path += "/tpcits";
407
408	gSystem->mkdir(path, kTRUE);
409
410	TString fileName("multiplicity");
411	if (optionStr.Contains("only-process-type-nd"))
412	fileName += "ND";
413	if (optionStr.Contains("only-process-type-sd"))
414	fileName += "SD";
415	if (optionStr.Contains("only-process-type-dd"))
416	fileName += "DD";
417	fileName += ".root";
418
419	gSystem->Rename(fileName, path + "/" + fileName);
420	gSystem->Rename("event_stat.root", path + "/event_stat.root");
421
422	Printf(">>>>> Moved files to %s", path.Data());
423	}
a9017e49	424	}