Example #1
0
AliAnalysisTask *RegisterTaskPID2(Bool_t useMC, Bool_t isAOD, Int_t tpcCls=120, Int_t tpcClsPID = 80, 
                  Int_t itsCls=4, Double_t dcaxy=1.0, Double_t dcaz=2.0, 
                  Double_t tpcs=-0.0113, Double_t tpcu=3.09, 
                  Double_t tofs=3., Int_t tofm=0,
                  Int_t itshitpixel = AliHFEextraCuts::kBoth, 
                  Bool_t withetacorrection = kTRUE,
                  Int_t TRDtrigger=0){

  gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/pPb/ConfigHFEmbpPb.C");
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
  AliAnalysisTaskHFE *task = ConfigHFEmbpPb(useMC, isAOD, tpcCls, tpcClsPID, itsCls, dcaxy, dcaz,
					     tpcs,tpcu,tofs,tofm,3.,kFALSE,kTRUE,kFALSE,itshitpixel,withetacorrection,0,TRDtrigger);

  if(isAOD)
    task->SetAODAnalysis();
  else
    task->SetESDAnalysis();

  if (useMC)
    task->SetHasMCData(kTRUE);
  else{
    task->SetHasMCData(kFALSE);
  }

  if(TRDtrigger<2) task->SelectCollisionCandidates(AliVEvent::kINT7);
  else task->SelectCollisionCandidates(AliVEvent::kTRD);

  Int_t idcaxy = (Int_t)(dcaxy*10.);
  Int_t idcaz = (Int_t)(dcaz*10.);
  Int_t itpcs = (Int_t)(tpcs*1000.);
  Int_t itofs = (Int_t)(tofs*10.);
  Int_t ipixelany = itshitpixel;
  Int_t ietacorr = 0;
  if(withetacorrection) ietacorr = 1;
  
  TString appendix(TString::Format("mbTPCc%dTPCp%dITS%dDCAr%dz%dTPCs%dTOFs%dm%ipa%dtrdt%d",tpcCls,
				   tpcClsPID,itsCls,idcaxy,idcaz,itpcs,itofs,tofm,ipixelany,TRDtrigger));
  printf("Add macro appendix %s\n", appendix.Data());

  TString containerName = mgr->GetCommonFileName();
  containerName += ":HFEtask";
  containerName += appendix.Data();
  printf("container name: %s\n", containerName.Data());

  //create data containers
  task->ConnectOutput(1, mgr->CreateContainer(Form("HFE_Results_%s", appendix.Data()), 
					      TList::Class(), AliAnalysisManager::kOutputContainer, 
					      containerName.Data()));
  task->ConnectOutput(2, mgr->CreateContainer(Form("HFE_QA_%s", appendix.Data()), TList::Class(), 
					      AliAnalysisManager::kOutputContainer, 
					      containerName.Data()));
  mgr->ConnectInput(task,  0, cinput );

  mgr->AddTask(task);
  return NULL;
}
Example #2
0
AliAnalysisTaskCaloHFEpp* AddTaskCaloHFEpp(TString name = "name",
		                 TString dataname = "dataname",
		                 Bool_t flagEG1,
		                 Bool_t flagEG2,
		                 Bool_t SetFlagClsTypeEMC,
		                 Bool_t SetFlagClsTypeDCAL)
{
    // get the manager via the static access member. since it's static, you don't need
    // an instance of the class to call the function
    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
    if (!mgr) {
        return 0x0;
    }
    // get the input event handler, again via a static method. 
    // this handler is part of the managing system and feeds events
    // to your task
    if (!mgr->GetInputEventHandler()) {
        return 0x0;
    }
    // by default, a file is open for writing. here, we get the filename
    TString fileName = AliAnalysisManager::GetCommonFileName();
    fileName += ":CaloHFEpp";      // create a subfolder in the file
    // now we create an instance of your task
    AliAnalysisTaskCaloHFEpp* task = new AliAnalysisTaskCaloHFEpp(name.Data());   
    task -> SetEG1(flagEG1);
    task -> SetEG2(flagEG2);
    task -> SetfFlagClsTypeEMC(SetFlagClsTypeEMC);
    task -> SetfFlagClsTypeDCAL(SetFlagClsTypeDCAL);
    if(!task) return 0x0;

    // add your task to the manager
    mgr->AddTask(task);

    TString containerName = mgr->GetCommonFileName();
    containerName += ":PWGHF_hfeCalpp";
    TString SubcontainerName = Form("hfeCalpp");
    SubcontainerName += name;
    AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
    AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(SubcontainerName, TList::Class(),AliAnalysisManager::kOutputContainer, containerName.Data());
    mgr->ConnectInput(task, 0, cinput);
    mgr->ConnectOutput(task, 1, coutput1); 

    return task;
}
AliAnalysisTaskUpsilonTreeTuned* AddTaskUpsilonTreeTuned(Bool_t isMC = kFALSE, TString changeName = "")
{
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddtaskUpsilon", "No analysis manager to connect to.");
    return NULL;
  }

  TString type = mgr->GetInputEventHandler()->GetDataType();
  if (!type.Contains("ESD") && !type.Contains("AOD")) {
    ::Error("AddtaskUpsilon", "Upsilon task needs the manager to have an ESD or AOD input handler.");
    return NULL;
  }

  // Create container
  TString outputfile = mgr->GetCommonFileName();
  if ( ! outputfile.IsNull() ) outputfile += ":Upsilon" + changeName;
  else outputfile = "UpsilonAnalysis" + changeName + ".root";

  TString containerName = "UpsilonOut" + changeName;
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(containerName.Data(),TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);

  // Create cuts
  TString cutsName = "StdMuonPairCuts" + changeName;
  AliMuonPairCuts* muonPairCuts = new AliMuonPairCuts(cutsName.Data(), cutsName.Data());
  muonPairCuts->SetIsMC(isMC);


  // Create task
  TString taskName = "UpsilonTask" + changeName;
  AliMuonTrackCuts *muonCuts = new AliMuonTrackCuts("cuts","cuts");
  AliAnalysisTaskUpsilonTreeTuned *upsilonAnalysisTask = new AliAnalysisTaskUpsilonTreeTuned(taskName.Data(),muonCuts);
  if ( isMC ) upsilonAnalysisTask->SetTrigClassPatterns("ANY");
  mgr->AddTask(upsilonAnalysisTask);
   // Connect containers
   mgr->ConnectInput  (upsilonAnalysisTask,  0, mgr->GetCommonInputContainer());
   mgr->ConnectOutput (upsilonAnalysisTask,  1, coutput1);

   return upsilonAnalysisTask;
}
Example #4
0
AliAnaVZEROQA* AddTaskVZEROQATrig(Int_t runNumber)
{
  // Creates a QA task exploiting simple symmetries phi, eta +/-, charge ...
  
  // Get the pointer to the existing analysis manager via the static access method.
  //==============================================================================
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddTaskQAsym", "No analysis manager to connect to.");
    return NULL;
  }  
  
  // Check the analysis type using the event handlers connected to the analysis manager.
  //==============================================================================
  if (!mgr->GetInputEventHandler()) {
    ::Error("AddTasQAsym", "This task requires an input event handler");
    return NULL;
  }
   TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
  
   // Configure analysis
   //===========================================================================
   
 
 
   AliAnaVZEROQA* task = new AliAnaVZEROQA("AliAnaVZEROQATrig");
   mgr->AddTask(task);
  
   AliAnalysisDataContainer *cout  = mgr->CreateContainer("QAVZEROHistsTrig",TList::Class(),
							  AliAnalysisManager::kOutputContainer, Form("%s:VZERO_Performance_Trig", 
												     mgr->GetCommonFileName()));

   mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
   mgr->ConnectOutput (task, 1, cout);

   return task;
   
  
}
AliAnalysisTask *AddTaskHFEreducedEvent(Bool_t MCthere=kFALSE, Int_t TRDtrigger=0,Int_t minnbTPC=70,Int_t minnbTPCPID=80,Int_t minnbITS=3,
					Bool_t isRemoveFirstEvent=kTRUE){

  //
  // Produce reduced events
  //
  

  // Name
    TString appendixx(TString::Format("HFEreducedEventt%dTPCcl%dpidcl%dITScl%d",(Int_t)TRDtrigger,(Int_t) minnbTPC,(Int_t) minnbTPCPID,(Int_t) minnbITS,
				      (Int_t) isRemoveFirstEvent));
  
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();

  // task
  AliHFEreducedEventCreatorESD *reducedEventCreator = new AliHFEreducedEventCreatorESD("HFEreducedEventCreator");
  reducedEventCreator->SetMinNclustersTPC(minnbTPC);
  reducedEventCreator->SetMinNclustersTPCPID(minnbTPCPID);
  reducedEventCreator->SetMinNclustersITS(minnbITS);
  if(isRemoveFirstEvent) reducedEventCreator->SetRemoveFirstEventFromChunk();

  if(TRDtrigger==0) reducedEventCreator->SelectCollisionCandidates(AliVEvent::kINT7);
  else reducedEventCreator->SelectCollisionCandidates(AliVEvent::kINT7 | AliVEvent::kTRD);

  mgr->AddTask(reducedEventCreator);
  
  TString containerName = mgr->GetCommonFileName();
  containerName += ":";
  containerName += appendixx.Data();

  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
  mgr->ConnectOutput(reducedEventCreator,1, mgr->CreateContainer(Form("list_%s",appendixx.Data()), TTree::Class(),AliAnalysisManager::kOutputContainer,containerName.Data()));
  mgr->ConnectInput(reducedEventCreator,0, cinput );    

  return NULL;

  
}
Example #6
0
AliAnalysisTaskMuonCuts* AddTaskMuonCuts(Bool_t isMC = kFALSE)
{
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddtaskMuonCuts", "No analysis manager to connect to.");
    return NULL;
  }

  TString type = mgr->GetInputEventHandler()->GetDataType();
  if (!type.Contains("ESD") && !type.Contains("AOD")) {
    ::Error("AddtaskMuonCuts", "MuonCuts task needs the manager to have an ESD or AOD input handler.");
    return NULL;
  }

  // Create container
  TString currName = "";
  TString outputfile = mgr->GetCommonFileName();
  if ( ! outputfile.IsNull() ) outputfile += ":PWG3_muonCuts";
  else outputfile = "muonCutsAnalysis.root";

  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("MuonTrackCuts",TObjArray::Class(),AliAnalysisManager::kOutputContainer,outputfile);

  // Create cuts
  AliMuonTrackCuts* muonTrackCuts = new AliMuonTrackCuts("TestStandardMuonTrackCuts", "TestStandardMuonTrackCuts");
  muonTrackCuts->SetIsMC(isMC);
  muonTrackCuts->SetAllowDefaultParams();
  muonTrackCuts->SetCustomParamFromRun();

  // Create task
  AliAnalysisTaskMuonCuts *muonCutsAnalysisTask = new AliAnalysisTaskMuonCuts("MuonCutsTask", *muonTrackCuts);
  if ( isMC ) muonCutsAnalysisTask->SetTrigClassPatterns("ANY");
  mgr->AddTask(muonCutsAnalysisTask);

   // Connect containers
   mgr->ConnectInput  (muonCutsAnalysisTask,  0, mgr->GetCommonInputContainer());
   mgr->ConnectOutput (muonCutsAnalysisTask,  1, coutput1);

   return muonCutsAnalysisTask;
}
AliAnalysisTask *AddTask_HypTritEventTree(UInt_t triggerMask = AliVEvent::kINT7, Bool_t pidQa = kTRUE, Bool_t betheSplines = kTRUE, Int_t period = 2015) {
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    Error("AddTask_lkreis_HypTritEventTree", "No analysis manager found.");
    return 0;
  }
  AliAnalysisTaskHypTritEventTree *task = new AliAnalysisTaskHypTritEventTree("lkreisTaskHypTritEventTree");
  task->SelectCollisionCandidates(triggerMask);
  task->SetPidQa(pidQa);
  //task->SetPeriod(period);
  task->SetBetheSplines(betheSplines);
  // MC LHC12d3
//  Double_t he3Params[6] = {1.79043,18.0066,0.00212257,2.24677,4.25945,0.06892};
//  Double_t tParams[6] = {2.32603,19.2492,30.7943,2.16971,-8.11114, 0.09311};
  // DATA LHC15o
  if(period == 2015){
    Double_t he3Params[6] = {2.45605,19.8067,-0.774729,1.96279,0.172695, 0.05655};
    Double_t tParams[6] = {2.32603,19.2492,30.7943,2.16971,-8.11114, 0.09311};
  }
  else if(period == 2016){
    Double_t he3Params[6] = {1.69155, 27.4992, 4.00313e-15, 2.48485, 8.31768, 0.05655};
    Double_t tParams[6] = {1.69155, 27.4992, 4.00313e-15, 2.48485, 8.31768, 0.09311};
  }
  task->SetParamsHe(he3Params);
  task->SetParamsT(tParams);
  //Data Containers
  AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
  AliAnalysisDataContainer *coutput1 =
    mgr->CreateContainer("histograms", TList::Class(),AliAnalysisManager::kOutputContainer,mgr->GetCommonFileName());
  AliAnalysisDataContainer *coutput2 =
    mgr->CreateContainer("tree", TTree::Class(),AliAnalysisManager::kOutputContainer,mgr->GetCommonFileName());
  AliAnalysisDataContainer *coutput3 =
    mgr->CreateContainer("tree_mc", TTree::Class(),AliAnalysisManager::kOutputContainer,mgr->GetCommonFileName());
  mgr->ConnectInput(task, 0, cinput);
  mgr->ConnectOutput(task, 1, coutput1);
  mgr->ConnectOutput(task, 2, coutput2);
  mgr->ConnectOutput(task, 3, coutput3);
  return task;
}
Example #8
0
AliAnalysisTaskSE* AddTaskZDCQApp()
{
  // Creates a QA task to check ZDC data

  // Get the pointer to the existing analysis manager via the static access method.
  //==============================================================================
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddTaskZDCQA", "No analysis manager to connect to.");
    return NULL;
  }

  // Check the analysis type using the event handlers connected to the analysis manager.
  //==============================================================================
  if (!mgr->GetInputEventHandler()) {
    ::Error("AddTaskZDCQA", "This task requires an input event handler");
    return NULL;
  }
   TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"

   // Configure analysis
   //===========================================================================
   AliAnalysisTaskZDCpp* task = new AliAnalysisTaskZDCpp("AliAnaZDCQA");
   //AliAnalysisTaskZDCPbPb* task = new AliAnalysisTaskZDCPbPb("AliAnaZDCQA");
   //AliAnalysisTaskZDCpA* task = new AliAnalysisTaskZDCpA("AliAnaZDCQA");
   mgr->AddTask(task);

   AliAnalysisDataContainer *cout  = mgr->CreateContainer("QAZDCHists",TList::Class(),
							  AliAnalysisManager::kOutputContainer, Form("%s:ZDC_Performance",
												     mgr->GetCommonFileName()));

   mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
   mgr->ConnectOutput (task, 1, cout);

   return task;
}
//____________________________________________
AliPerformanceTask* AddTaskPerformanceTPCdEdxQA(Bool_t bUseMCInfo=kFALSE, Bool_t bUseESDfriend=kTRUE, 
						Bool_t highMult = kFALSE, const char *triggerClass=0, 
						Bool_t bUseHLT = kFALSE, Bool_t bUseTOF = kFALSE, Bool_t bTPCTrackingOnly = kFALSE,
						Bool_t bDoEffTpcSec = kFALSE)
{
  const TString taskName[] = {"TPC", "HLT"};
  const TString taskName2[] = {"", "_Tracking"};
  Int_t idx = 0, idx2 = 0;
  if (bUseHLT) idx = 1;
  if (bTPCTrackingOnly) idx2 = 1;
  
  //
  // Add AliPerformanceTask with TPC performance components
  //
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if(!mgr) { 
    Error("AddTaskPerformanceTPCdEdxQA","AliAnalysisManager not set!");
    return NULL;
  }
  
  TString type = mgr->GetInputEventHandler()->GetDataType();
  if (!type.Contains("ESD")) {
    Error("AddTaskPerformanceTPCdEdxQA", "ESD input handler needed!");
    return NULL;
  }
  
  AliMCEventHandler *mcH = (AliMCEventHandler*)mgr->GetMCtruthEventHandler();
  if (!mcH && bUseMCInfo) {
    Error("AddTaskPerformanceTPCdEdxQA", "MC input handler needed!");
    return NULL;
  }

  //
  // Add HLT Event
  //
  if (bUseHLT) {
    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
    esdH->SetReadHLT();
  }

  //
  // Create task
  //
  AliPerformanceTask *task = new AliPerformanceTask("PerformanceQA",Form("%s%s Performance",taskName[idx].Data(), taskName2[idx2].Data()));
  if (!task) {
    Error("AddTaskPerformanceTPCdEdxQA", "%s", Form("%s%s performance task cannot be created!",taskName[idx].Data(), taskName2[idx2].Data()));
    return NULL;
  }
  task->SetUseMCInfo(bUseMCInfo);
  task->SetUseESDfriend(bUseESDfriend);
  //  task->SetUseTerminate(kFALSE);
  task->SetUseHLT(bUseHLT);

  //
  // Add task to analysis manager
  //
  mgr->AddTask(task);

  //
  // Create TPC-ESD track reconstruction cuts
  // MB tracks
  //
  AliRecInfoCuts *pRecInfoCutsTPC = new AliRecInfoCuts("pRecInfoCutsTPC"); 
  if(pRecInfoCutsTPC) {
    pRecInfoCutsTPC->SetMaxDCAToVertexXY(3.0);
    pRecInfoCutsTPC->SetMaxDCAToVertexZ(3.0);
    pRecInfoCutsTPC->SetRequireSigmaToVertex(kFALSE);
    pRecInfoCutsTPC->SetRequireTPCRefit(kFALSE);
    pRecInfoCutsTPC->SetAcceptKinkDaughters(kFALSE);
    pRecInfoCutsTPC->SetMinNClustersTPC(70);
    pRecInfoCutsTPC->SetMaxChi2PerClusterTPC(4.);
    pRecInfoCutsTPC->SetDCAToVertex2D(kTRUE);

    pRecInfoCutsTPC->SetHistogramsOn(kFALSE); 
  } else {
    Error("AddTaskPerformanceTPCdEdxQA", "AliRecInfoCutsTPC cannot be created!");
    return NULL;
  }

  //
  // Create TPC-MC track reconstruction cuts
  //
  AliMCInfoCuts *pMCInfoCuts = new AliMCInfoCuts("pMCInfoCuts");
  if(pMCInfoCuts) {
    pMCInfoCuts->SetMinTrackLength(70);
  } else {
    Error("AddTaskPerformanceTPCdEdxQA", "AliMCInfoCuts cannot be created!");
    return NULL;
  }

  //
  // Create performance objects for TPC and set cuts 
  //
  enum { kTPC = 0, kTPCITS, kConstrained, kTPCInner, kTPCOuter, kTPCSec };

  AliPerformanceTPC *pCompTPC0;
  AliPerformanceMatch *pCompMatch1;
  AliPerformanceMatch *pCompMatch2;
  AliPerformanceDEdx *pCompDEdx3;
  if (bTPCTrackingOnly == kFALSE) {
    //
    // TPC performance
    //
    pCompTPC0 = new AliPerformanceTPC("AliPerformanceTPC","AliPerformanceTPC",kTPC,kFALSE,-1,highMult); 
    if(!pCompTPC0) {
      Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceTPC");
    }
    pCompTPC0->SetAliRecInfoCuts(pRecInfoCutsTPC);
    pCompTPC0->SetAliMCInfoCuts(pMCInfoCuts);
    //  pCompTPC0->SetUseTrackVertex(kFALSE);
    pCompTPC0->SetUseTrackVertex(kTRUE);
    pCompTPC0->SetUseHLT(bUseHLT);
    pCompTPC0->SetUseTOFBunchCrossing(bUseTOF);
    
    //
    // TPC ITS match
    //
    pCompMatch1 = new AliPerformanceMatch("AliPerformanceMatchTPCITS","AliPerformanceMatchTPCITS",0,kFALSE); 
    if(!pCompMatch1) {
      Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceMatchTPCITS");
    }
    pCompMatch1->SetAliRecInfoCuts(pRecInfoCutsTPC);
    pCompMatch1->SetAliMCInfoCuts(pMCInfoCuts);
    pCompMatch1->SetUseTOFBunchCrossing(bUseTOF);


    //
    // ITS TPC match
    //
    pCompMatch2 = new AliPerformanceMatch("AliPerformanceMatchITSTPC","AliPerformanceMatchITSTPC",1,kFALSE); 
    if(!pCompMatch2) {
      Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceMatchITSTPC");  }
    pCompMatch2->SetAliRecInfoCuts(pRecInfoCutsTPC);
    pCompMatch2->SetAliMCInfoCuts(pMCInfoCuts);
    pCompMatch2->SetUseTOFBunchCrossing(bUseTOF);

    //
    // dEdx
    //
    pCompDEdx3 = new AliPerformanceDEdx("AliPerformanceDEdxTPCInner","AliPerformanceDEdxTPCInner",kTPCInner,kFALSE); 
    if(!pCompDEdx3) {
      Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceDEdxTPCInner");
    }
    pCompDEdx3->SetAliRecInfoCuts(pRecInfoCutsTPC);
    pCompDEdx3->SetAliMCInfoCuts(pMCInfoCuts);
    //pCompDEdx3->SetUseTrackVertex(kFALSE);
    pCompDEdx3->SetUseTrackVertex(kTRUE);
  } //end bTPCTrackingOnly == kFALSE

  //
  // Resolution ------------------------------------------------------------------------------------
  //

  AliPerformanceRes *pCompRes4 = new AliPerformanceRes(bTPCTrackingOnly ? "AliPerformanceResTPC" : "AliPerformanceRes",
						       "AliPerformanceRes", bTPCTrackingOnly == kTRUE ? kTPCInner : kTPC,kFALSE); 
  if(!pCompRes4) {
    Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceRes");
  }


  pCompRes4->SetAliRecInfoCuts(pRecInfoCutsTPC);
  pCompRes4->SetAliMCInfoCuts(pMCInfoCuts);
  pCompRes4->SetUseTrackVertex(bTPCTrackingOnly == kTRUE ? kFALSE : kTRUE);

  //
  // Efficiency ------------------------------------------------------------------------------------
  //

  AliPerformanceEff *pCompEff5 = new AliPerformanceEff(bTPCTrackingOnly ? "AliPerformanceEffTPC" : "AliPerformanceEff",
						       "AliPerformanceEff",kTPC,kFALSE); 
  if(!pCompEff5) {
    Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceEff");
  }

  AliRecInfoCuts *pRecInfoCutsTPC2 = NULL;
  if (bTPCTrackingOnly)
  {
    //For low pt tracks, HLT finds only short track segments.
    //Hence, for the tpc-tracking only tracking-efficiency, we lower the minimum number of hits per reconstructed TPC track
    pRecInfoCutsTPC2 = new AliRecInfoCuts(*pRecInfoCutsTPC); 
    pRecInfoCutsTPC2->SetMinNClustersTPC(20);
    pCompEff5->SetAliRecInfoCuts(pRecInfoCutsTPC2);
  }
  else
  {
    pCompEff5->SetAliRecInfoCuts(pRecInfoCutsTPC);
  }
  pCompEff5->SetAliMCInfoCuts(pMCInfoCuts);
  pCompEff5->SetUseTrackVertex(bTPCTrackingOnly == kTRUE ? kFALSE : kTRUE);

  AliPerformanceEff *pCompEff5Sec;
  if (bDoEffTpcSec)
  {
    pCompEff5Sec = new AliPerformanceEff(bTPCTrackingOnly ? "AliPerformanceEffSecTPC" : "AliPerformanceEffSec",
                   "AliPerformanceEffSec",kTPCSec,kFALSE); 
    if(!pCompEff5Sec) {
      Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceEff");
    }

    pCompEff5Sec->SetAliRecInfoCuts(bTPCTrackingOnly ? pRecInfoCutsTPC2 : pRecInfoCutsTPC);
    pCompEff5Sec->SetAliMCInfoCuts(pMCInfoCuts);
    pCompEff5Sec->SetUseTrackVertex(bTPCTrackingOnly == kTRUE ? kFALSE : kTRUE);
  }

  //
  // TPC Constrain to vertex
  //
  AliPerformanceMatch *pCompConstrain6;
  if (bTPCTrackingOnly == kFALSE) {
    pCompConstrain6 = new AliPerformanceMatch("AliPerformanceMatchTPCConstrain","AliPerformanceMatchTPCConstrain",2,kFALSE); 
    if(!pCompConstrain6) {
      Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceMatchTPCConstrain");  }
    pCompConstrain6->SetAliRecInfoCuts(pRecInfoCutsTPC);
    pCompConstrain6->SetAliMCInfoCuts(pMCInfoCuts);
    pCompConstrain6->SetUseTOFBunchCrossing(bUseTOF);
  } //end bTPCTrackingOnly == kFALSE



  //
  // Add components to the performance task
  //
  if (bTPCTrackingOnly == kFALSE) {
  if(!bUseMCInfo) { 
    pCompTPC0->SetTriggerClass(triggerClass);
    pCompMatch1->SetTriggerClass(triggerClass);
    pCompMatch2->SetTriggerClass(triggerClass);
    pCompDEdx3->SetTriggerClass(triggerClass);
    pCompConstrain6->SetTriggerClass(triggerClass);
  }
  task->AddPerformanceObject( pCompTPC0 );
  task->AddPerformanceObject( pCompMatch1 );
  task->AddPerformanceObject( pCompMatch2 );
  task->AddPerformanceObject( pCompDEdx3 );
  task->AddPerformanceObject( pCompConstrain6 );
  } //end bTPCTrackingOnly == kFALSE
  if(bUseMCInfo)   {
      task->AddPerformanceObject( pCompRes4 );
      task->AddPerformanceObject( pCompEff5 );
      if (bDoEffTpcSec) task->AddPerformanceObject( pCompEff5Sec );
  }

  //
  // Create containers for input
  //
  mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());

  //
  // Create containers for output
  //
   
  AliAnalysisDataContainer *coutput = mgr->CreateContainer(Form("%s%sQA", taskName[idx].Data(), taskName2[idx2].Data()), TList::Class(), 
                 AliAnalysisManager::kOutputContainer, 
                 Form("%s:%s_%s", mgr->GetCommonFileName(), taskName[idx].Data(),task->GetName()));


  AliAnalysisDataContainer *coutput2  = mgr->CreateContainer(Form("%s%sQASummary", taskName[idx].Data(), taskName2[idx2].Data()), TTree::Class(), 
                   AliAnalysisManager::kParamContainer, 
                   Form("trending.root:Summary%sQA", taskName[idx].Data())); 
  
  mgr->ConnectOutput(task, 1, coutput);
  mgr->ConnectOutput(task, 0, coutput2);

return task;  
}
Example #10
0
AliAnalysisTask *AddTaskHFEFlowTPCTOFEPSP(Bool_t useMC=kFALSE,
					  Int_t trigger=0,
					  Int_t aodfilter=16,
					  Bool_t scalarProduct=kFALSE,
					  Bool_t cutPileup=kFALSE,
					  Int_t variableM = 1,
					  Int_t tpcCls=110,
					  Double_t tpcClsr=60,
					  Int_t tpcClspid=80,
					  Int_t itsCls=4,
					  Int_t pixellayer=2,
					  Double_t dcaxy=100,
					  Double_t dcaz=200,
					  Double_t tofsig=30.,
					  Double_t tpceff=50.,
					  Int_t vzero=1,
					  Int_t debuglevel=2,
					  Double_t etarange=80,
					  Bool_t withetacorrection=kFALSE,
					  Bool_t withmultcorrection=kFALSE,
					  Double_t ITSclustersback=0,
					  Double_t minTPCback=-2.0,
					  Double_t maxTPCback=5.0,
					  Int_t wei=-1,
					  Int_t selectgenerator=-1){

  //
  // Define TPC cut for 2011 data
  //
  Double_t tpcdedx[8] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0}; //0-5,5-10,10-20,20-30,30-40,40-50,50-60,60-100
  // -0.2 0-5%
  // -0.15 5-10%
  // -0.1 10-20%
  // -0.0 20-30%, sigma=1.17
  // 0.156 30-40%, sigma=1.2
  // 0.19 40-50%, sigma=1.2
  // 0.2 50-60%
  // 0.2 60-80% list_t65536f16TPC110r60p80s11km0ITS4C36Pi2DCAr100z200TOF30TPCe50V1D0er8i0t-20t50

  /*
  tpcdedx[0]=-0.2;
  tpcdedx[1]=-0.15;
  tpcdedx[2]=-0.1;
  tpcdedx[3]=0.0;
  tpcdedx[4]=0.156;
  tpcdedx[5]=0.19;
  tpcdedx[6]=0.2;
  tpcdedx[7]=0.2;
  if(TMath::Abs(tpceff-55)<0.01) {
    tpcdedx[0]=-0.365;
    tpcdedx[1]=-0.314;
    tpcdedx[2]=-0.267;
    tpcdedx[3]=-0.165;
    tpcdedx[4]=-0.022;
    tpcdedx[5]= 0.01;
    tpcdedx[6]= 0.018;
    tpcdedx[7]= 0.018;
  }
  if(TMath::Abs(tpceff-45)<0.01) {
    tpcdedx[0]=-0.062;
    tpcdedx[1]=-0.015;
    tpcdedx[2]=0.035;
    tpcdedx[3]=0.131;
    tpcdedx[4]=0.278;
    tpcdedx[5]=0.32;
    tpcdedx[6]=0.32;
    tpcdedx[7]=0.32;
  }
  if(TMath::Abs(tpceff-60)<0.01) {
    tpcdedx[0]=-0.518;
    tpcdedx[1]=-0.47;
    tpcdedx[2]=-0.42;
    tpcdedx[3]=-0.315;
    tpcdedx[4]=-0.178;
    tpcdedx[5]=-0.145;
    tpcdedx[6]=-0.135;
    tpcdedx[7]=-0.135;
  }
  if(TMath::Abs(tpceff-40)<0.01) {
    tpcdedx[0]=0.09;
    tpcdedx[1]=0.14;
    tpcdedx[2]=0.188;
    tpcdedx[3]=0.28;
    tpcdedx[4]=0.43;
    tpcdedx[5]=0.462;
    tpcdedx[6]=0.473;
    tpcdedx[7]=0.473;
  }
  */

  
  // Name
  TString appendixx(TString::Format("t%df%ds%dp%dM%dTPC%dr%dp%dITS%dPi%dDCAr%dz%dTOF%dTPCe%dV%dD%der%dbin%di%dt%dt%d%dW%dSG%d",(Int_t)trigger,aodfilter,(Int_t)scalarProduct,(Int_t)cutPileup,(Int_t)variableM,tpcCls,(Int_t)tpcClsr,tpcClspid,itsCls,(Int_t) pixellayer,(Int_t) dcaxy,(Int_t)dcaz,(Int_t) tofsig,(Int_t)tpceff,vzero,debuglevel,(Int_t)(etarange*0.1),(Int_t)withetacorrection,(Int_t)withmultcorrection,(Int_t)ITSclustersback,(Int_t)(minTPCback*10.0),(Int_t)(maxTPCback*10.0),wei,selectgenerator));
  //TString appendixx("tpctofv2");
  
  //printf("appendixx %s\n",appendixx.Data());
  
  //set config file name
  TString configFile("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/PbPb/ConfigHFE_FLOW_TOFTPC.C");
  //TString configFile("ConfigHFE_FLOW_TOFTPC.C");
  TString checkconfig="ConfigHFE_FLOW_TOFTPC";
  if (!gROOT->GetListOfGlobalFunctions()->FindObject(checkconfig.Data()))
    gROOT->LoadMacro(configFile.Data());
  
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
  //printf("Create the task\n");
  AliAnalysisTaskFlowTPCTOFEPSP *task = ConfigHFE_FLOW_TOFTPC(useMC,appendixx,trigger,aodfilter,scalarProduct,cutPileup,variableM,tpcCls, tpcClsr, tpcClspid, itsCls, pixellayer, dcaxy, dcaz,tofsig,&tpcdedx[0],vzero,debuglevel,etarange,withetacorrection,withmultcorrection,ITSclustersback,minTPCback,maxTPCback,wei,selectgenerator);  
  
  task->SetNbBinsCentralityQCumulant(4);
  //task->SetBinCentralityLess(0,0.0);
  task->SetBinCentralityLess(0,0.0);
  task->SetBinCentralityLess(1,10.0);
  task->SetBinCentralityLess(2,20.0);
  task->SetBinCentralityLess(3,40.0);
  task->SetBinCentralityLess(4,50.0);
  //task->SetBinCentralityLess(5,60.0);
  //task->SetBinCentralityLess(7,80.0);

  task->SetHFEVZEROEventPlane(0x0);
  //AliLog::SetClassDebugLevel("AliAnalysisTaskHFEFlow",3);

  //printf("Init the weights\n");
  //if(useMC && (!gROOT->GetListOfGlobalFunctions()->FindObject("ConfigWeightFactorsHFEv2"))) gROOT->LoadMacro("ConfigWeightFactorsHFEv2.C");
  if(useMC && (!gROOT->GetListOfGlobalFunctions()->FindObject("ConfigWeightFactorsHFEv2"))) gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/PbPb/ConfigWeightFactorsHFEv2.C");
  if(useMC && (wei>=0)) ConfigWeightFactorsHFEv2(task,kFALSE,wei);
  
  mgr->AddTask(task);

  TString containerName = mgr->GetCommonFileName();
  containerName += ":";
  containerName += appendixx.Data();

  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
  mgr->ConnectOutput(task,1, mgr->CreateContainer(Form("list_%s",appendixx.Data()), TList::Class(),AliAnalysisManager::kOutputContainer,containerName.Data()));
  mgr->ConnectInput(task,0, cinput );    

  return NULL;

  
}
Example #11
0
AliAnalysisTask *AddTaskHFEtpctofPbPb(Bool_t isaod, Bool_t isMC,Int_t aodfilter=16,Int_t clusterdef=AliHFEextraCuts::kFoundAll, Int_t clusterrdef=AliHFEextraCuts::kFoundAllOverFindable,Int_t tpcCls=130,  Int_t tpcClsPID = 80, Double_t tpcClsRatio = 0.6, Double_t tpcClShared = 1.1, Bool_t rejectkinkmother = kFALSE, Int_t itsCls=4,Double_t itsChi2PerClusters=-1,Int_t itspixelcut=AliHFEextraCuts::kBoth, Double_t dcaxy=1.0, Double_t dcaz=2.0, Bool_t usetof=kTRUE, Double_t tofs=3.,Bool_t etacor=kFALSE,TString listname="",Double_t tpceff=0.5, Float_t prodlow=0., Float_t prodhigh=3.,Bool_t kNoPhotonic = kTRUE){

  // libraries in case
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice");


  //set config file name
  TString configFile("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/PbPb/ConfigHFEpbpb.C");
  //TString configFile("/d/alice12/bailhache/AliRootInstallations/07_10_2012/AliRoot/PWGHF/hfe/macros/configs/PbPb/ConfigHFEpbpb.C");
  TString checkconfig="ConfigHFEpbpb";
  if (!gROOT->GetListOfGlobalFunctions()->FindObject(checkconfig.Data()))
    gROOT->LoadMacro(configFile.Data());

  
  // Name 
  Int_t itpcClsRatio = (Int_t) (tpcClsRatio*10);
  Int_t itpcClShared = (Int_t) (tpcClShared*10);
  Int_t iitsChi2PerClusters = (Int_t) (itsChi2PerClusters*10);
  Int_t idcaxy = (Int_t) (dcaxy*10);
  Int_t idcaz = (Int_t) (dcaz*10);
  Int_t itofs = (Int_t) (tofs*10);
  Int_t iprodlow = (Int_t) (prodlow*10);
  Int_t iprodhigh = (Int_t) (prodhigh*10);
  Int_t itof = 0;
  Int_t iNoPhotonic = 0;
  Int_t ietacor = 0;
  Int_t itpceff = (Int_t) (tpceff*10);
  Int_t irejectkinkmother = 0;
  if(usetof) itof=kTRUE;
  if(kNoPhotonic) iNoPhotonic = 1;
  if(etacor) ietacor = 1;
  if(rejectkinkmother) irejectkinkmother = 1;
  
  TString appendix(TString::Format("f%dcd%dcr%dt%dtp%dtr%dts%dkm%di%dic%di%ddcaxy%dz%dtof%dts%de%dtpc%dprodlow%dhigh%dnhfe%d",aodfilter,clusterdef,clusterrdef,tpcCls,tpcClsPID,itpcClsRatio,itpcClShared,irejectkinkmother,itsCls,iitsChi2PerClusters,itspixelcut,idcaxy,idcaz,itof,itofs,ietacor,itpceff,iprodlow,iprodhigh,iNoPhotonic));
  printf("appendix %s\n", appendix.Data());
  

  // ESD or AOD
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr->GetInputEventHandler()) {
    printf("AddTaskEventplane", "This task requires an input event handler");
    return NULL;
  }
  TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
  Bool_t isaod = kFALSE;
  if (inputDataType == "AOD") isaod = kTRUE;

  
  // TPC cut 2010
  // 0-5,5-10,10-20,20-30,30-40,40-50,50-60,60-70,70-80,80-90,90-100,one more per history
  // http://www.physi.uni-heidelberg.de/~pachmay/projects/hfe/pid/tpc/
  // without eta correction 50%
  Double_t tpcdEdxcutlow[12] = {0.03,0.15,0.24,0.3,0.39,0.48,0.5,0.51,0.5,0.5,0.5,0.5};
  // with eta correction 50%
  // Double_t tpcdEdxcutlow[12] = {-0.01,0.076,0.197,0.26,0.298,0.3,0.3,0.3,0.3,0.3,0.3,0.3};
  Double_t tpcdEdxcuthigh[12] = {3.0,3.0,3.0,3.0,3.0,3.0,3.0,3.0,3.0,3.0,3.0,3.0};


  // Task
  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
  AliAnalysisTaskHFE *task = ConfigHFEpbpb(isaod,isMC,appendix,aodfilter,clusterdef,clusterrdef,tpcCls,tpcClsPID,tpcClsRatio,tpcClShared,irejectkinkmother,itsCls,itsChi2PerClusters,itspixelcut,dcaxy,dcaz,usetof,tofs,etacor,listname,tpcdEdxcutlow,tpcdEdxcuthigh,prodlow,prodhigh,kNoPhotonic);  

  mgr->AddTask(task);


  // Write Output 
  TString containerName = mgr->GetCommonFileName();
  containerName += ":";
  containerName += appendix.Data();

  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
  mgr->ConnectOutput(task,1, mgr->CreateContainer(Form("HFE_Results_%s", appendix.Data()), TList::Class(),AliAnalysisManager::kOutputContainer,containerName.Data()));
  mgr->ConnectOutput(task,2, mgr->CreateContainer(Form("HFE_QA_%s", appendix.Data()), TList::Class(),AliAnalysisManager::kOutputContainer,containerName.Data()));
  mgr->ConnectInput(task,0, cinput );    

  return NULL;
  
}
AliAnalysisTaskPHOSNeutralMeson* AddTaskAliAnalysisTaskPHOSNeutralMeson(
		TString taskName,
		TString collisionCandidates, 
		Bool_t usePhysicsSelection,
		Bool_t usePHOSTender,
		Int_t clusterMinCells, 
		Float_t clusterMinE,
		Float_t clusterMinM02,
		Float_t distToBadCellOnCellLevel,
		Float_t distToBadCell,
		Bool_t doTimingCut,
		Float_t timingCutMin,
		Float_t timingCutMax,
		Float_t zVertexCut,
		TString recalOption,
		Double_t recalFactorMod1,
		Double_t recalFactorMod2,
		Double_t recalFactorMod3,
		TString mPtHistoMode,
		Bool_t applyBadMap_manually,
		Bool_t useIsVertexSelected2013pA,
		TString badMapName = "defaultTenderBM",
		Bool_t fillMCHistos = kFALSE,
		Bool_t analyseAddedSignals = kFALSE,
		TString mcParticleToAnalyse = "pi0",
		Double_t expoPara1 = 0.0,
		Double_t expoPara2 = 0.0,
		Double_t expoPara3 = 0.0,
		Double_t expoPara4 = 0.0,
		TString additionalFileNameString = "",
		Bool_t fillHitMapsAddedS = kFALSE,
		Bool_t  fillDecayInfoAddedS = kFALSE, 
		Char_t *suffix = "") 
{
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddTaskAliFraNeutralMeson", "No analysis manager to connect to.");
    return NULL;
  }  
  
	// ****************************************************** 
	//  *****  SETTINGS ***** ***** ***** ***** ***** ***** 
	// for possible bad maps see alien:///alice/cern.ch/user/m/mhecker/BadMaps/:
	// BM13c_6_15_allMd_all_noMod2 = BM_d_13c_22_6_2015_allMod_allMod2Off.root (old name)
	// defaultTenderBM  (switches off SetForceUsingBadMap for Tender!)
	// BM_d_13c_22_6_2015_allMod_all.root    BM_d_13c_28_4_15
	
	Bool_t DoDistToBadCell = false;
	if (distToBadCell > 0.00001) DoDistToBadCell = true;
	Bool_t DoDistToBadCellOnCellLevel = false;
	if (distToBadCellOnCellLevel > 0) DoDistToBadCellOnCellLevel = true;
																			
	// ***** ***** ***** ***** ***** ***** ***** ***** ***** 
	// ****************************************************** 
	
	TString ContName = "contPHOSNeutralMeson";
	TString combinedName;
	combinedName.Form("%s%s",ContName.Data(), suffix);
	
	TString pathToBadMap;
	
	if (badMapName !="defaultTenderBM") {
		gSystem->Exec(Form("alien_cp alien:///alice/cern.ch/user/m/mhecker/BadMaps/%s.root .",badMapName.Data()));
		pathToBadMap = Form("%s/",gSystem->pwd());
		pathToBadMap += badMapName;
		pathToBadMap += ".root";
	}

	// **** PHOS TENDER  ***********
	if(usePHOSTender) {
		cout<<"######  PHOS TENDER ! ######"<<endl;

		
		// ~~~~~~~~~~~~~ Loading Tender for AODs ~~~~~~~~~~~~~~~~~~

		Int_t tenderPassNumber = 1;  // does not matter (just has to be >= 0). tender then finds the correct pass itself
		gROOT->LoadMacro("$ALICE_PHYSICS/PWGGA/PHOSTasks/PHOS_PbPb/AddAODPHOSTender.C");
		AliPHOSTenderTask *tenderPHOS = AddAODPHOSTender("PHOSTenderTask","PHOStender","",tenderPassNumber);
		AliPHOSTenderSupply *PHOSSupply = tenderPHOS->GetPHOSTenderSupply();
		
		if(badMapName !="defaultTenderBM") {
			printf("Setting Tender-BadMap to private BM \n");
			PHOSSupply->ForceUsingBadMap(pathToBadMap.Data());
		} else printf("Running Tender with its default BadMap \n");
	}
  
  // ********** PHYSICS SELECTION ******************
	if(usePhysicsSelection) {
		gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
		AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
		printf(" ********* AliPhysicsSelectionTask configured ********* ");
	}

  
	// Initialize Task
	AliAnalysisTaskPHOSNeutralMeson *task = new AliAnalysisTaskPHOSNeutralMeson(taskName.Data());
	
	// Set variables for Outputfile Name
	if(usePHOSTender) { 
		task->SetSelectedSelectedTenderForOutputName("PHSTndr");
	} else {
		task->SetSelectedSelectedTenderForOutputName("noTndr");
	}
	
	if(usePhysicsSelection) {
		task->SetSelectedPhysSelectionForOutputName("AliPhySl");
	} else {
		task->SetSelectedPhysSelectionForOutputName("noPhySl");
	}
	
	task->SetUsedBadmapForOutputName(badMapName);
 
 
	// ******* SET BAD MAP ******************
	task->SetApplyBadMapManually(applyBadMap_manually);
	
	if(applyBadMap_manually) {
		if (badMapName == "defaultTenderBM") AliError("Cannot apply default tender bad map in task, now applying empty bad map. Specify own bad map to fix it.");
		else {
			TFile *fBadMap = TFile::Open(pathToBadMap.Data());
			
			if(fBadMap->IsOpen()){
				printf("\n\n...Adding PHOS bad channel map (MANUALY) \n") ;
				gROOT->cd();
				Char_t key[55] ;
				for(Int_t mod=1;mod<4; mod++){
					sprintf(key,"PHOS_BadMap_mod%d",mod) ;
					TH2I * h = (TH2I*)fBadMap->Get(key) ;
					if(h)
					task->SetPHOSBadMap(mod,h) ;
				}
				fBadMap->Close() ;
			}
		}
	}
	// ***** END OF SET BAD MAP ***************
  
	//~~~~~~~ Geometry ~~~~~~~~~~~~~~
	//task->SetEtaAccMinMax(-0.14, 0.14); 	    
	//task->SetPhiAccMinMax(-1.72568, -0.72635); 
	task->SetEtaAccMinMax(-0.13, 0.13);				// Set Min and Max of eta for PHOS acceptance (MC)
	Double_t phiMin = 260 * (TMath::Pi()/180);
	Double_t phiMax = 320 * (TMath::Pi()/180);
	task->SetPhiAccMinMax(phiMin,phiMax); //60 degrees (in rad)
	
	
	//~~~~~~~~ MC related ~~~~~~~~~~~~~
	task->SetfFillMCHistos(fillMCHistos);
	task->SetAnalyseAddedSignals(analyseAddedSignals);
	//task->SetFillFeedDownHistos(true); 	
	task->SetAnalyseMCPi0OrEta(mcParticleToAnalyse);  //pi0 eta both 
	task->SetExponentialParameters(expoPara1, expoPara2, expoPara3, expoPara4); //for weighing added signals
  	task->SetAdditionalFileNameString(additionalFileNameString); //String appears at the end of the filname. 
  	task->SetFillClusterHitmapsAddedSignals(fillHitMapsAddedS);
  	task->SetFillDecayPhotonInfoAddedSig(fillDecayInfoAddedS);
	
	task->SetFillNDaughtersVsPtAndR(kFALSE);				//implement bool to list of arguments of AddTask if needed
	task->SetFillMPtForSingleOrMultContrClus(kFALSE);	//implement bool to list of arguments of AddTask if needed
	 
 
	// ~~~~~~ Event Cuts ~~~~~~~~~~~~~
	task->SetUseOnlyCINT1events(kFALSE);
	task->SetDoZvertexCut(kTRUE);
	task->SetUseIsVertexSelected2013pA(useIsVertexSelected2013pA); 
	task->SetZvertexCut(zVertexCut);	// 10.0									
	
	
	// ~~~~~~ Cluster Cuts ~~~~~~~~~~~
	task->SetClusterMinCells(clusterMinCells); //3
	task->SetClusterMinE(clusterMinE); 	//0.3 GeV
	task->SetClusterMinM02(clusterMinM02);  //0.2
	task->SetDoTimingCut(doTimingCut);	//for MC: false
	task->SetTimingCutMinMax(timingCutMin, timingCutMax); //-0.10e-6,0.10e-6

	task->SetDoDistToBadCellCut(DoDistToBadCell);  
	task->SetDistToBadCell(distToBadCell);  // [cm]  
	
	task->SetDoDistToBadCellCutOnCellLevel(DoDistToBadCellOnCellLevel);
	task->SetDistToBadCellOnCellLevel(distToBadCellOnCellLevel);

	// ~~~~~~~~ Filling options ~~~~~~
	task->SetFillCellIdVsE(false);   	//Neccessary for QA (BadMap) (increases Outputfile-size)
	task->SetFillTimingHistos(true);  	//Neccessary to determine timing cut values.
	task->SetFillClusterHitmaps(true);	// To check the BadMaps and cluster distributions

	if (mPtHistoMode != "nrmlMptHst") {
		if (mPtHistoMode == "hMPTvsMod") task->SetFillhMassPtModules(true); 	// For module-wise pi0 analysis
		else if (mPtHistoMode == "hMPTvsTim") task->SetFillhMassPtTiming(true);  	// For calculation of timing efficiency
		else if (mPtHistoMode == "hMPTnewAsy") task->SetFillNewAsymmClasses(true);
		else mPtHistoMode = "nrmlMptHst"; // if none of the implemented (above) modes is set, the string is set to default
	}
    
	task->SetFillNTupelClusterEnergy(false);  //Neccesary to calculate module dependent energy recal factors
  
	// ~~~~ recalibration options ~~~~
	//task->SetDoClusterEnergyRecalibration(false);
	task->SetRecalibrationOption(recalOption); // look in .cxx for possible options
	task->SetRecalibrateModuleWise(false);
	task->SetModuleWiseRecalibrationFactors(recalFactorMod1,recalFactorMod2,recalFactorMod3); 
	//task->SetModuleWiseRecalibrationFactors(0.9942,0.9822,1.0072); //pp
  
  
	// SelectCollisionCandidates according to collisionCandidates set in Settings (line 14)
	if(collisionCandidates == "kPHI7") {
		task->SelectCollisionCandidates(AliVEvent::kPHI7);
		task->SetSelectedCollCandidatesForOutputName("kPHI7");
	}
	
	if(collisionCandidates == "kINT7") {
		task->SelectCollisionCandidates(AliVEvent::kINT7);
		task->SetSelectedCollCandidatesForOutputName("kINT7");
	}
	
	if(collisionCandidates == "kAny") {
		task->SelectCollisionCandidates(AliVEvent::kAny);
		task->SetSelectedCollCandidatesForOutputName("kAny");
	}
	
	if(collisionCandidates == "kMB") {
		task->SelectCollisionCandidates(AliVEvent::kMB);
		task->SetSelectedCollCandidatesForOutputName("kMB");
	}
	
	if(collisionCandidates == "kERT1") {
		task->SelectCollisionCandidates(AliVEvent::kERT1);
		task->SetSelectedCollCandidatesForOutputName("kERT1");
	}


	// ********************* IMPORTANT: ****************************
	// The OutputfileName cannot be to long!
	// The Gridjobs crash in a ERROR_RE if it is too long
	// It has been successfully tested with a filename length of 135 symbols
	// *************************************************************
	// make OutPutFileName after making all Settings
	TString OutPutFileName = task->MakeOutputFileName();

	mgr->AddTask(task);

	AliAnalysisDataContainer *coutput0 = mgr->CreateContainer(Form("%s:%s", ContName.Data(),OutPutFileName.Data()), TList::Class(),  AliAnalysisManager::kOutputContainer, Form("%s:dirNeutralMeson", mgr->GetCommonFileName()));
	mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
	mgr->ConnectOutput(task,1,coutput0);
	
	return task;
} 
Example #13
0
AliAnalysisTaskHaHFECorrel *AddTaskHaHFECorrel(Double_t period, Double_t MinPtEvent, Double_t MaxPtEvent, Bool_t TRDQA, Bool_t CorrHadron, Bool_t CorrLP, Bool_t MCTruth,  Bool_t IsMC, Bool_t IsAOD, Bool_t UseTender, Int_t ITSnCut,  Int_t TPCnCut, Int_t TPCnCutdEdx,   Double_t PhotElecPtCut, Int_t PhotElecTPCnCut,Bool_t PhotElecITSrefitCut,Double_t InvmassCut, Int_t HTPCnCut,   Bool_t HITSrefitCut, Bool_t HTPCrefitCut, Bool_t UseITS, Double_t SigmaITScut, Double_t SigmaTOFcut, Double_t SigmaTPCcut, const char * ID="")
{
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    Error("AddTaskHaHFECorrel", "No analysis manager found.");
    return 0;
  }

  if (!mgr->GetInputEventHandler()) {
    ::Error("AddTaskHaHFECorrel", "This task requires an input event handler");
    return 0x0;
  }

  TString type = mgr->GetInputEventHandler()->GetDataType();

  /*
  AliMCEventHandler* mcHand = new AliMCEventHandler();
  mgr->SetMCtruthEventHandler(mcHand);
  Bool_t MCthere=kTRUE;
  AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>(mgr->GetMCtruthEventHandler());
  if (!mcH) {
    MCthere=kFALSE;
  }
  */



  gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/pp/ConfigHaHFECorrel.C");
  AliAnalysisTaskHaHFECorrel *taskMB = 
    ConfigHaHFECorrel(period, MinPtEvent, MaxPtEvent, TRDQA, CorrHadron, CorrLP, MCTruth, IsMC, IsAOD, UseTender, ITSnCut, TPCnCut, TPCnCutdEdx, PhotElecPtCut,PhotElecTPCnCut, PhotElecITSrefitCut,  InvmassCut,  HTPCnCut,  HITSrefitCut, HTPCrefitCut, UseITS, SigmaITScut, SigmaTOFcut, SigmaTPCcut, ID);
  if (!taskMB) {
    Error("AddTaskHaHFECorrel", "No task found.");
  }
  taskMB->SelectCollisionCandidates(AliVEvent::kINT7);
  
  // Load correction weights for pi0, eta
  if (IsMC) {
    TH1::AddDirectory(kFALSE);
    printf("Loading Pi0EtaCorrectionFiles\n");
    TString CorrectPi0EtaFile="alien:///alice/cern.ch/user/f/flherrma/HaHFECorrel/Pi0EtaWeights.root";
    TFile *CorrectPi0Eta = TFile::Open(CorrectPi0EtaFile.Data());
    if (CorrectPi0Eta) {    
      TH1F * Pi0W = (TH1F*)CorrectPi0Eta->Get("Pi0Weights");
      TH1F * EtaW = (TH1F*)CorrectPi0Eta->Get("EtaWeights");
      if (Pi0W) taskMB->SetPi0WeightToData(*Pi0W);
      else printf("Could not load Pi0Weights\n");
      if (EtaW)  taskMB->SetEtaWeightToData(*EtaW);
      else printf("Could not load EtaWeights\n");
    }
    else printf("Could not open Pi0Eta correction file \n");
    TH1::AddDirectory(kTRUE);
  }
  TH1::AddDirectory(kFALSE);
  printf("Loading RecEffFiles\n");
  TString RecEffFileName="alien:///alice/cern.ch/user/f/flherrma/HaHFECorrel/RecEff.root";
  TFile *RecEffFile = TFile::Open(RecEffFileName.Data());

  //RecEffFile->ls();
  if (RecEffFile) {    
    TH3F * HadRecEff = (TH3F*)RecEffFile->Get("HadRecEff");
    TH2F * EleRecEff = (TH2F*)RecEffFile->Get("EleRecEff");
    if (HadRecEff) taskMB->SetHadRecEff(*HadRecEff);
    else printf("Could not load HadRecEff\n");
    if (EleRecEff) taskMB->SetEleRecEff(*EleRecEff);
    else printf("Could not load EleRecEff\n");
  }
  else printf("Could not open RecEff correction file \n");
  TH1::AddDirectory(kTRUE);




  mgr->AddTask(taskMB);

  TString containerName1 = mgr->GetCommonFileName();
  containerName1 += ":PWGHF_HaHFECorrel_kINT7_";
  containerName1 += ID;
        
  TString name1 = "histMB_";
  name1 += ID;
        
  AliAnalysisDataContainer *cinput   = mgr->GetCommonInputContainer();
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name1.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName1.Data());
  mgr->ConnectInput(taskMB, 0, cinput);
  mgr->ConnectOutput(taskMB, 1, coutput1);




  return NULL;
}
Example #14
0
AliAnalysisTaskPWGJEQA* AddTaskPWGJEQA(
                                       const char* ntracks            = "usedefault",
                                       const char* nclusters          = "usedefault",
                                       const char* ncells             = "usedefault",
                                       const char *nGenLev            = "mcparticles",
                                       Bool_t      doTrackQA          = kTRUE,
                                       Bool_t      doCaloQA           = kTRUE,
                                       Bool_t      doJetQA            = kTRUE,
                                       Bool_t      doEventQA          = kTRUE,
                                       Double_t    trackPtCut         = 0.15,
                                       Double_t    clusECut           = 0.30,
                                       const char* suffix             = ""
                                       )
{
  
  // Get the pointer to the existing analysis manager via the static access method
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddTaskPWGJEQA", "No analysis manager to connect to.");
    return NULL;
  }
  
  // Check the analysis type using the event handlers connected to the analysis manager
  AliVEventHandler* handler = mgr->GetInputEventHandler();
  if (!handler) {
    ::Error("AddTaskPWGJEQA", "This task requires an input event handler");
    return NULL;
  }
  
  enum EDataType_t {
    kUnknown,
    kESD,
    kAOD
  };
  
  EDataType_t dataType = kUnknown;
  
  if (handler->InheritsFrom("AliESDInputHandler")) {
    dataType = kESD;
  }
  else if (handler->InheritsFrom("AliAODInputHandler")) {
    dataType = kAOD;
  }
  
  // Init the task and do settings
  TString trackName(ntracks);
  TString clusName(nclusters);
  TString cellName(ncells);
  
  if (trackName == "usedefault") {
    if (dataType == kESD) {
      trackName = "Tracks";
    }
    else if (dataType == kAOD) {
      trackName = "tracks";
    }
    else {
      trackName = "";
    }
  }
  
  if (clusName == "usedefault") {
    if (dataType == kESD) {
      clusName = "CaloClusters";
    }
    else if (dataType == kAOD) {
      clusName = "caloClusters";
    }
    else {
      clusName = "";
    }
  }
  
  if (ncells == "usedefault") {
    if (dataType == kESD) {
      cellName = "EMCALCells";
    }
    else if (dataType == kAOD) {
      cellName = "emcalCells";
    }
    else {
      cellName = "";
    }
  }
  
  TString name("AliAnalysisTaskPWGJEQA");
  if (!trackName.IsNull()) {
    name += "_";
    name += trackName;
  }
  if (!clusName.IsNull()) {
    name += "_";
    name += clusName;
  }
  
  if (!cellName.IsNull()) {
    name += "_";
    name += cellName;
  }
   
  if (strcmp(suffix,"")) {
    name += "_";
    name += suffix;
  }
  
  AliAnalysisTaskPWGJEQA* qaTask = new AliAnalysisTaskPWGJEQA(name);
  qaTask->SetVzRange(-10,10);
  qaTask->SetNeedEmcalGeom(kFALSE);
  qaTask->SetCaloCellsName(cellName);
  qaTask->SetDetectorLevelName(trackName);
  if (nGenLev && strcmp(nGenLev,"")!=0) qaTask->SetGeneratorLevelName(nGenLev);
  qaTask->SetDoTrackQA(doTrackQA);
  qaTask->SetDoCaloQA(doCaloQA);
  qaTask->SetDoJetQA(doJetQA);
  qaTask->SetDoEventQA(doEventQA);
  
  // Add the detector-level track container
  if (trackName == "tracks" || trackName == "Tracks") {
    AliTrackContainer* trackCont = qaTask->AddTrackContainer(trackName);
    trackCont->SetFilterHybridTracks(kTRUE);
  }
  else if (!trackName.IsNull()) {
    qaTask->AddParticleContainer(trackName);
  }
  AliParticleContainer *partCont = qaTask->GetParticleContainer(trackName);
  if (partCont) {
    partCont->SetParticlePtCut(trackPtCut);
  }
  
  // Add the generator-level container, if specified
  if (nGenLev && strcmp(nGenLev,"")!=0) {
    AliMCParticleContainer* mcpartCont = qaTask->AddMCParticleContainer(nGenLev);
    mcpartCont->SelectPhysicalPrimaries(kTRUE);
    mcpartCont->SetParticlePtCut(0);
  }

  // Add the cluster container
  AliClusterContainer *clusterCont = qaTask->AddClusterContainer(clusName);
  if (clusterCont) {
    clusterCont->SetClusECut(0.);
    clusterCont->SetClusPtCut(0.);
    clusterCont->SetClusHadCorrEnergyCut(clusECut);
    clusterCont->SetDefaultClusterEnergy(AliVCluster::kHadCorr);
  }

  // Final settings, pass to manager and set the containers
  mgr->AddTask(qaTask);
  
  // Create containers for input/output
  AliAnalysisDataContainer *cinput1  = mgr->GetCommonInputContainer()  ;
  
  TString contName = TString::Format("%s_histos", name.Data());
  TString commonoutput;
  commonoutput = mgr->GetCommonFileName();
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(),
                                                            TList::Class(),AliAnalysisManager::kOutputContainer,
                                                            commonoutput);
  mgr->ConnectInput  (qaTask, 0,  cinput1 );
  mgr->ConnectOutput (qaTask, 1, coutput1 );
  
  return qaTask;
}
Example #15
0
//=========================================================================
AliAnalysisTask *RegisterTaskPID2TRD(Bool_t useMC, Bool_t isAOD, Int_t tpcCls=120, Int_t tpcClsPID = 80,
				     Int_t itsCls=4, Double_t dcaxy=1.0, Double_t dcaz=2.0,
				     Double_t *tpcdEdxcutlow=NULL,
				     Double_t *tpcdEdxcuthigh=NULL,
				     Double_t tofs=3., Int_t tofm=0,
				     Int_t itshitpixel = AliHFEextraCuts::kBoth, Int_t icent=1,
				     Int_t TRDtrigger=0,Int_t trdpidmethod=1, Int_t trdl=6, Int_t trde=4,TString detector){

  gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/pPb/ConfigHFEpPbTRD.C");
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();

  TString detused=detector.Copy();
  TPRegexp(",").Substitute(detused,"","g");
  printf("detectors in use %s %s \n",detector.Data(),detused.Data());

  if (icent == 2) TString cesti("V0M");
  else if (icent == 3) TString cesti("CL1");
  else if (icent == 4) TString cesti("ZNA");
  else TString cesti("V0A");

  Int_t idcaxy = (Int_t)(dcaxy*10.);
  Int_t idcaz = (Int_t)(dcaz*10.);
  Int_t tpclow = 0;
  if(tpcdEdxcutlow) tpclow = (Int_t) (tpcdEdxcutlow[0]*1000.);
  Int_t itofs = (Int_t)(tofs*10.);
  Int_t ipixelany = itshitpixel;

  TString appendix(TString::Format("TPCc%dp%dITS%dr%dz%dTPCs%dTOFs%dm%ipa%dTRDt%dm%il%ie%i%sc%s",tpcCls,
                   tpcClsPID,itsCls,idcaxy,idcaz,tpclow,itofs,tofm,ipixelany,TRDtrigger,trdpidmethod,trdl,trde,detused.Data(),cesti.Data()));
  printf("Add macro appendix %s\n", appendix.Data());

  AliAnalysisTaskHFE *task = ConfigHFEpPbTRD(useMC, isAOD, appendix, tpcCls, tpcClsPID, itsCls, dcaxy, dcaz,
                             tpcdEdxcutlow,tpcdEdxcuthigh, tofs, tofm, itshitpixel, icent, -0.8, 0.8, TRDtrigger,trdpidmethod,trdl,trde,detector);

  if(isAOD)
    task->SetAODAnalysis();
  else
    task->SetESDAnalysis();

  if (useMC)
    task->SetHasMCData(kTRUE);
  else{
    task->SetHasMCData(kFALSE);
  }

  if(TRDtrigger<2) task->SelectCollisionCandidates(AliVEvent::kINT7);
  else task->SelectCollisionCandidates(AliVEvent::kTRD);

  TString containerName = mgr->GetCommonFileName();
  containerName += ":HFEtask";
  containerName += appendix.Data();
  printf("container name: %s\n", containerName.Data());

  //create data containers
  task->ConnectOutput(1, mgr->CreateContainer(Form("HFE_Results_%s", appendix.Data()),
					      TList::Class(), AliAnalysisManager::kOutputContainer, 
					      containerName.Data()));
  task->ConnectOutput(2, mgr->CreateContainer(Form("HFE_QA_%s", appendix.Data()), TList::Class(), 
					      AliAnalysisManager::kOutputContainer, 
					      containerName.Data()));
  mgr->ConnectInput(task,  0, cinput );

  mgr->AddTask(task);
  return NULL;
}
Example #16
0
AliAnalysisTask *AddTaskFlowTPCEMCalEP(Double_t SigmaITScut, Double_t SigmaTOFcut, Double_t SigmaTPCcut, Double_t AssPtCut, Int_t AssTPCnCut, Int_t ITSncut, Bool_t AssITSrefitCut, Int_t TPCnCut, Int_t period, Bool_t UseNewEP, Bool_t UseTender, TString ID="ContName", TString passV0, TString passTPC, Bool_t TimeCut,Bool_t WeightSyst,Bool_t SystTOFcut, Double_t CutM02, Double_t CutM20, Bool_t SScut, Bool_t EnablePileupRejVZEROTPCout)
{
    AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
    if (!mgr) {
        Error("AddTaskFlowTPCEMCalEP", "No analysis manager found.");
        return NULL;
    }
    
    if (!mgr->GetInputEventHandler()) {
        ::Error("AddTaskFlowTPCEMCalEP", "This task requires an input event handler");
        return NULL;
    }
    TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
    //    if (type=="AOD"){
    //        ::Error("AddTaskFlowTPCEMCalEP", "The tasks exits because AODs are in input");
    //        return NULL;
    //    }
    Bool_t MCthere=kFALSE;
    AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>(mgr->GetMCtruthEventHandler());
    if(!mcH){
        MCthere=kFALSE;
    }else{
        MCthere=kTRUE;
    }
    
    if (!UseNewEP){
        //Event plane task
        AliEPSelectionTask *eventplaneTask = new AliEPSelectionTask("EventplaneSelection");
        eventplaneTask->SelectCollisionCandidates(AliVEvent::kMB | AliVEvent::kSemiCentral | AliVEvent::kCentral | AliVEvent::kEMCEGA | AliVEvent::kEMCEJE);
        
        eventplaneTask->SetTrackType("TPC");
        eventplaneTask->SetUsePtWeight();
        eventplaneTask->SetUsePhiWeight();
        eventplaneTask->SetSaveTrackContribution();
        
        mgr->AddTask(eventplaneTask);
        
        TString containerName0 = mgr->GetCommonFileName();
        containerName0 += ":PWGHF_hfeCalEventPlane";
        containerName0 += ID;
        
        TString name0 = "EPStat";
        name0 += ID;
        
        AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
        AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name0.Data(),TList::Class(), AliAnalysisManager::kOutputContainer,containerName0.Data());
        mgr->ConnectInput(eventplaneTask, 0, mgr->GetCommonInputContainer());
        mgr->ConnectOutput(eventplaneTask,1,coutput1);
    }
    
    Bool_t Is2015 = kTRUE;
    
    if(Is2015){
        
        gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/PbPb/ConfigHFE_FLOW_TPCEMCal_EP.C");
        AliAnalysisTaskFlowTPCEMCalEP *taskMB = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
        
        mgr->AddTask(taskMB);
        
        taskMB->SelectCollisionCandidates(AliVEvent::kINT7);
        
        TString containerName1 = mgr->GetCommonFileName();
        containerName1 += ":PWGHF_hfeCalcorrINT7V2";
        containerName1 += ID;
        
        TString name1 = "histMB";
        name1 += ID;
        
        AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
        AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name1.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName1.Data());
        mgr->ConnectInput(taskMB, 0, cinput);
        //        mgr->ConnectInput(taskMB, 1, corrTask);
        mgr->ConnectOutput(taskMB, 1, coutput1);
    }
    
    if(!Is2015){
        gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/PbPb/ConfigHFE_FLOW_TPCEMCal_EP.C");
        
        AliAnalysisTaskFlowTPCEMCalEP *taskMB = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
        AliAnalysisTaskFlowTPCEMCalEP *taskcorrMB = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
        AliAnalysisTaskFlowTPCEMCalEP *taskTR = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
        
        mgr->AddTask(taskcorrMB);
        mgr->AddTask(taskMB);
        mgr->AddTask(taskTR);
        
        // Flattened semi central trigger
        
        taskcorrMB->SelectCollisionCandidates(AliVEvent::kAny);
        
        TString containerName1 = mgr->GetCommonFileName();
        containerName1 += ":PWGHF_hfeCalcorrSemiCentralV2";
        containerName1 += ID;
        
        TString name1 = "histcorrMB";
        name1 += ID;
        
        AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
        AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name1.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName1.Data());
        mgr->ConnectInput(taskcorrMB, 0, cinput);
        mgr->ConnectOutput(taskcorrMB, 1, coutput1);
        
        // Central trigger
        taskMB->SelectCollisionCandidates(AliVEvent::kSemiCentral | AliVEvent::kCentral);
        
        TString containerName2 = mgr->GetCommonFileName();
        containerName2 += ":PWGHF_hfeCalCentralV2";
        containerName2 += ID;
        
        TString name2 = "histMB";
        name2 += ID;
        
        AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
        AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name2.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName2.Data());
        mgr->ConnectInput(taskMB, 0, cinput);
        mgr->ConnectOutput(taskMB, 1, coutput1);
        
        //L1 gamma trigger
        taskTR->SelectCollisionCandidates(AliVEvent::kEMCEGA);
        
        TString containerName3 = mgr->GetCommonFileName();
        containerName3 += ":PWGHF_hfeCalL1GammaV2";
        containerName3 += ID;
        
        TString name3 = "histTR";
        name3 += ID;
        
        AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
        AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name3.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName3.Data());
        mgr->ConnectInput(taskTR, 0, cinput);
        mgr->ConnectOutput(taskTR, 1, coutput1);
        
    }
    
    if(MCthere){
        
        AliAnalysisTaskFlowTPCEMCalEP *taskMC = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
        mgr->AddTask(taskMC);
        
        taskMC->SelectCollisionCandidates(AliVEvent::kMB);
        
        TString containerName4 = mgr->GetCommonFileName();
        containerName4 += ":PWGHF_hfeCalMCV2";
        containerName4 += ID;
        
        TString name4 = "histMC";
        name4 += ID;
        
        AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
        AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name4.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName4.Data());
        mgr->ConnectInput(taskMC, 0, cinput);
        mgr->ConnectOutput(taskMC, 1, coutput1);
    }
    
    
    return NULL;
}
Example #17
0
AliAnalysisTask *RegisterTask(Bool_t useMC, Bool_t isAOD, Int_t tpcCls=120, Int_t tpcClsPID = 80, 
                  Int_t itsCls=4, Double_t dcaxy=1.0, Double_t dcaz=2.0, 
                  Double_t *tpcdEdxcutlow=NULL, 
                  Double_t *tpcdEdxcuthigh=NULL, 
                  //Double_t tpcs=-0.0113, Double_t tpcu=3.09, 
                  Double_t tofs=3., Int_t tofm=0,
                  Int_t itshitpixel = AliHFEextraCuts::kBoth, Int_t icent=1){

  Int_t idcaxy = (Int_t)(dcaxy*10.);
  Int_t idcaz = (Int_t)(dcaz*10.);
  Int_t tpclow = 0;
  if(tpcdEdxcutlow) tpclow = (Int_t) (tpcdEdxcutlow[0]*1000.);
  Int_t itofs = (Int_t)(tofs*10.);
  Int_t ipixelany = itshitpixel;

  printf("Argument passed to function to determine the centrality estimator %i\n", icent);

  if (icent == 2) TString cesti("V0M");
  else if (icent == 3) TString cesti("CL1");
  else if (icent == 4) TString cesti("ZNA");
  else TString cesti("V0A");

  TString appendix(TString::Format("centTPCc%dTPCp%dITS%dDCAr%dz%dTPCs%dTOFs%dm%ipa%dce%s",tpcCls,
				   tpcClsPID,itsCls,idcaxy,idcaz,tpclow,itofs,tofm,ipixelany,cesti.Data()));
  printf("Add macro appendix %s\n", appendix.Data());
  printf("Centrality estimator %s\n", cesti.Data());

  gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/pPb/ConfigHFEpPb.C");
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  AliAnalysisDataContainer *cinput  = mgr->GetCommonInputContainer();
  AliAnalysisTaskHFE *task = ConfigHFEpPb(useMC, isAOD, appendix, tpcCls, tpcClsPID, itsCls, dcaxy, dcaz, 
					  tpcdEdxcutlow,tpcdEdxcuthigh,
					  tofs,tofm,itshitpixel,icent);

  if(isAOD)
    task->SetAODAnalysis();
  else
    task->SetESDAnalysis();
  if (useMC)
    task->SetHasMCData(kTRUE);
  else{
    task->SetHasMCData(kFALSE);
  }
  task->SelectCollisionCandidates(AliVEvent::kINT7);

  TString containerName = mgr->GetCommonFileName();
  containerName += ":HFEtask";
  containerName += appendix.Data();
  printf("container name: %s\n", containerName.Data());
 
  //create data containers
  task->ConnectOutput(1, mgr->CreateContainer(Form("HFE_Results_%s", appendix.Data()), 
					      TList::Class(), AliAnalysisManager::kOutputContainer, 
					      containerName.Data()));
  task->ConnectOutput(2, mgr->CreateContainer(Form("HFE_QA_%s", appendix.Data()), TList::Class(), 
					      AliAnalysisManager::kOutputContainer, 
					      containerName.Data()));
  mgr->ConnectInput(task,  0, cinput );

  mgr->AddTask(task);
  return NULL;
}
Example #18
0
AliAnalysisTaskMuonPerformance *AddTaskMuonPerformance(Bool_t correctClusterResForSystematics = kTRUE,
						       Bool_t fitClusterResiduals = kTRUE)
{
  /// Add AliAnalysisTaskMuonPerformance to the train
  
  // Get the pointer to the existing analysis manager via the static access method.
  //==============================================================================
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) {
    ::Error("AddTaskMuonPerformance", "No analysis manager to connect to.");
    return NULL;
  }   
  
  // This task requires an ESD input handler.
  // Check this using the analysis manager.
  //===============================================================================
  TString type = mgr->GetInputEventHandler()->GetDataType();
  if (!type.Contains("ESD")) {
    ::Error("AddTaskMuonPerformance", "MuonPerformance task needs the manager to have an ESD input handler.");
    return NULL;
  }
  
  TString baseOutName = "muonPerformance.root";
  TString outputfile = mgr->GetCommonFileName();
  if ( ! outputfile.IsNull() ) outputfile += ":MUON_Performances";
  else outputfile = baseOutName;
  
  AliAnalysisDataContainer *coutput1  = mgr->CreateContainer("EffContainer",AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,outputfile);
  AliAnalysisDataContainer *coutput2  = mgr->CreateContainer("TriggerResolution",TObjArray::Class(),AliAnalysisManager::kOutputContainer,outputfile);
  AliAnalysisDataContainer *coutput3  = mgr->CreateContainer("TrackerResolution",TObjArray::Class(),AliAnalysisManager::kOutputContainer,outputfile);
  AliAnalysisDataContainer *coutput4  = mgr->CreateContainer("Efficiency",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  AliAnalysisDataContainer *coutput5  = mgr->CreateContainer("MomentumAtVtx",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  AliAnalysisDataContainer *coutput6  = mgr->CreateContainer("SlopeAtVtx",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  AliAnalysisDataContainer *coutput7  = mgr->CreateContainer("EtaAtVtx",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  AliAnalysisDataContainer *coutput8  = mgr->CreateContainer("PhiAtVtx",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  AliAnalysisDataContainer *coutput9  = mgr->CreateContainer("MomentumAtFirstCl",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  AliAnalysisDataContainer *coutput10 = mgr->CreateContainer("SlopeAtFirstCl",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  AliAnalysisDataContainer *coutput11 = mgr->CreateContainer("DCA",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  AliAnalysisDataContainer *coutput12 = mgr->CreateContainer("Clusters",TObjArray::Class(),AliAnalysisManager::kParamContainer,outputfile);
  
  // Create the task, add it to the manager and configure it.
  //===========================================================================   
  AliAnalysisTaskMuonPerformance *muonPerformanceTask = new AliAnalysisTaskMuonPerformance("muonPerformanceTask");
  mgr->AddTask(muonPerformanceTask);
  muonPerformanceTask->CorrectClusterResForSystematics(correctClusterResForSystematics);
  muonPerformanceTask->FitClusterResiduals(fitClusterResiduals);
  
  // Create ONLY the output containers for the data produced by the task.
  // Get and connect other common input/output containers via the manager as below
  //==============================================================================
  mgr->ConnectInput  (muonPerformanceTask, 0, mgr->GetCommonInputContainer());
  mgr->ConnectOutput (muonPerformanceTask, 1, coutput1);
  mgr->ConnectOutput (muonPerformanceTask, 2, coutput2);
  mgr->ConnectOutput (muonPerformanceTask, 3, coutput3);
  mgr->ConnectOutput (muonPerformanceTask, 4, coutput4);
  mgr->ConnectOutput (muonPerformanceTask, 5, coutput5);
  mgr->ConnectOutput (muonPerformanceTask, 6, coutput6);
  mgr->ConnectOutput (muonPerformanceTask, 7, coutput7);
  mgr->ConnectOutput (muonPerformanceTask, 8, coutput8);
  mgr->ConnectOutput (muonPerformanceTask, 9, coutput9);
  mgr->ConnectOutput (muonPerformanceTask, 10, coutput10);
  mgr->ConnectOutput (muonPerformanceTask, 11, coutput11);
  mgr->ConnectOutput (muonPerformanceTask, 12, coutput12);
  
  return muonPerformanceTask;
}