[u/mrichter/AliRoot.git] / PWGLF / RESONANCES / macros / mini / ConfigKStarPPb.C

/***************************************************************************
              fbellini@cern.ch - last modified on 17/02/2014

// *** Configuration script for K*, anti-K* analysis with 2013 pPb runs ***
// 
// A configuration script for RSN package needs to define the followings:
//
// (1) decay tree of each resonance to be studied, which is needed to select
//     true pairs and to assign the right mass to all candidate daughters
// (2) cuts at all levels: single daughters, tracks, events
// (3) output objects: histograms or trees
****************************************************************************/
Bool_t ConfigKStarPPb
(  
    AliRsnMiniAnalysisTask *task, 
    Bool_t                 isMC, 
    Bool_t                 isPP,
    const char             *suffix,
    AliRsnCutSet           *cutsPair,
    Int_t                  aodFilterBit = 5,
    Int_t                  customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom,
    AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010,
    AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010,
    Float_t                nsigmaPi = 2.0,
    Float_t                nsigmaKa = 2.0,
    Bool_t                 enableMonitor = kTRUE,
    Bool_t                 IsMcTrueOnly = kFALSE,
    TString                monitorOpt = "",
    Bool_t                 useMixLS = 0,
    Bool_t                 checkReflex = 0,
    AliRsnMiniValue::EType yaxisVar = AliRsnMiniValue::kPt
)
{
  // manage suffix
  if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
  
  // set daughter cuts
  AliRsnCutSetDaughterParticle * cutSetQ;
  AliRsnCutSetDaughterParticle * cutSetPi;
  AliRsnCutSetDaughterParticle * cutSetK;
  
  AliRsnCutTrackQuality * trkQualityCut =  new AliRsnCutTrackQuality("myQualityCut");
  if (SetCustomQualityCut(trkQualityCut, customQualityCutsID, aodFilterBit)) {
    //Set custom quality cuts for systematic checks
    cutSetQ  = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0);
    cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), trkQualityCut, cutPiCandidate, AliPID::kPion, nsigmaPi);
    cutSetK  = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa);
  } else {
    //use defult quality cuts (std 2010 or 2011)
    cutSetQ  = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0, aodFilterBit, kTRUE);
    cutSetQ->SetUse2011StdQualityCuts(kTRUE);
    cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), cutPiCandidate, AliPID::kPion, nsigmaPi, aodFilterBit,kTRUE);
    cutSetPi->SetUse2011StdQualityCuts(kTRUE);
    cutSetK  = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit,kTRUE);
    cutSetK->SetUse2011StdQualityCuts(kTRUE);
   }
  
  Int_t iCutQ = task->AddTrackCuts(cutSetQ);
  Int_t iCutPi = task->AddTrackCuts(cutSetPi);
  Int_t iCutK = task->AddTrackCuts(cutSetK);
  
  if (enableMonitor){
    Printf("======== Cut monitoring enabled");
    gROOT->LoadMacro("$ALICE_ROOT/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
    AddMonitorOutput(isMC, cutSetQ->GetMonitorOutput(), monitorOpt.Data());
    AddMonitorOutput(isMC, cutSetPi->GetMonitorOutput(), monitorOpt.Data());
    AddMonitorOutput(isMC, cutSetK->GetMonitorOutput()), monitorOpt.Data();
  }  
  
  // -- Values ------------------------------------------------------------------------------------
  /* invariant mass   */ Int_t imID   = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
  /* IM resolution    */ Int_t resID  = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
  /* transv. momentum */ Int_t ptID   = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
  /* centrality       */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
  /* pseudorapidity   */ Int_t etaID  = task->CreateValue(AliRsnMiniValue::kEta, kFALSE);
  /* rapidity         */ Int_t yID    = task->CreateValue(AliRsnMiniValue::kY, kFALSE);
  /* 1st daughter pt  */ Int_t fdpt   = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE);
  /* 2nd daughter pt  */ Int_t sdpt   = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE);
  /* 1st daughter p   */ Int_t fdp    = task->CreateValue(AliRsnMiniValue::kFirstDaughterP, kFALSE);
  /* 2nd daughter p   */ Int_t sdp    = task->CreateValue(AliRsnMiniValue::kSecondDaughterP, kFALSE);
  
  // -- Create all needed outputs -----------------------------------------------------------------
  // use an array for more compact writing, which are different on mixing and charges
  // [0] = unlike
  // [1] = mixing
  // [2] = like ++
  // [3] = like --

  Bool_t  use     [12] = {!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly ,isMC,isMC,isMC,isMC, useMixLS , useMixLS    };
  Bool_t  useIM   [12] = { 1        , 1         ,  1       ,  1       ,  1      ,  1      ,  1      ,  1      ,  0      , 0      , 1         , 1           };
  TString name    [12] = {"UnlikePM", "UnlikeMP","MixingPM","MixingMP", "LikePP", "LikeMM","TruesPM","TruesMP", "ResPM" ,"ResMP" , "MixingPP", "MixingMM"  };
  TString comp    [12] = {"PAIR"    , "PAIR"    , "MIX"    , "MIX"    , "PAIR"  , "PAIR"  , "TRUE"  , "TRUE"  , "TRUE"  ,"TRUE"  , "MIX"     , "MIX"       };
  TString output  [12] = {"SPARSE"  , "SPARSE"  , "SPARSE" , "SPARSE" , "SPARSE", "SPARSE", "SPARSE","SPARSE" , "SPARSE","SPARSE", "SPARSE"  , "SPARSE"    };
  Int_t   pdgCode [12] = {313       , 313       , 313      , 313      , 313     , 313     , 313     , -313    ,  313    , -313   ,  313      , 313         };
  Char_t  charge1 [12] = {'+'       , '-'       , '+'      , '-'      , '+'     , '-'     , '+'     ,  '-'    , '+'     , '-'    , '+'       , '-'         };
  Char_t  charge2 [12] = {'-'       , '+'       , '-'      , '+'      , '+'     , '-'     , '-'     ,  '+'    , '-'     , '+'    , '+'       , '-'         };
  Int_t   cutID1  [12] = { iCutK    ,  iCutK    ,  iCutK   ,  iCutK   ,  iCutK  ,  iCutK  ,  iCutK  ,   iCutK ,  iCutK  , iCutK  , iCutK     , iCutK       };
  Int_t   cutID2  [12] = { iCutPi   ,  iCutPi   ,  iCutPi  ,  iCutPi  ,  iCutPi ,  iCutPi ,  iCutPi ,   iCutPi,  iCutPi , iCutPi , iCutPi    , iCutPi      };
  
  for (Int_t i = 0; i < 12; i++) {
    if (!use[i]) continue;
    AliRsnMiniOutput *out = task->CreateOutput(Form("kstar_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
    out->SetCutID(0, cutID1[i]);
    out->SetCutID(1, cutID2[i]);
    out->SetDaughter(0, AliRsnDaughter::kKaon);
    out->SetDaughter(1, AliRsnDaughter::kPion);
    out->SetCharge(0, charge1[i]);
    out->SetCharge(1, charge2[i]);
    out->SetMotherPDG(pdgCode[i]);
    out->SetMotherMass(0.89594);
    out->SetPairCuts(cutsPair);

    // axis X: invmass (or resolution)
    if (useIM[i]) 
      out->AddAxis(imID, 90, 0.6, 1.5);
    else
      out->AddAxis(resID, 200, -0.02, 0.02);
    
    // axis Y: transverse momentum of pair as default - else chosen value
    if (yaxisVar==AliRsnMiniValue::kFirstDaughterPt)
      out->AddAxis(fdpt, 100, 0.0, 10.0);
    else
      if (yaxisVar==AliRsnMiniValue::kSecondDaughterPt)
	out->AddAxis(sdpt, 100, 0.0, 10.0);
      else
	if (yaxisVar==AliRsnMiniValue::kFirstDaughterP)
	  out->AddAxis(fdp, 100, 0.0, 10.0);
	else
	  if (yaxisVar==AliRsnMiniValue::kSecondDaughterP)
	    out->AddAxis(sdp, 100, 0.0, 10.0);
	  else 
	    out->AddAxis(ptID, 200, 0.0, 20.0); //default use mother pt
    
    // axis Z: centrality-multiplicity
    if (!isPP)
      out->AddAxis(centID, 100, 0.0, 100.0);
    else 
      out->AddAxis(centID, 400, 0.0, 400.0);
    // axis W: pseudorapidity
    // out->AddAxis(etaID, 20, -1.0, 1.0);
    // axis J: rapidity
    // out->AddAxis(yID, 10, -0.5, 0.5);
  }   
  
  if (isMC){   
    //get mothers for K* PDG = 313
    AliRsnMiniOutput *outm = task->CreateOutput(Form("Ks_Mother%s", suffix), "SPARSE", "MOTHER");
    outm->SetDaughter(0, AliRsnDaughter::kKaon);
    outm->SetDaughter(1, AliRsnDaughter::kPion);
    outm->SetMotherPDG(313);
    outm->SetMotherMass(0.89594);
    outm->SetPairCuts(cutsPair);
    outm->AddAxis(imID, 90, 0.6, 1.5);
    outm->AddAxis(ptID, 200, 0.0, 20.0);
    if (!isPP){
      outm->AddAxis(centID, 100, 0.0, 100.0);
    }   else    { 
      outm->AddAxis(centID, 400, 0.0, 400.0);
    }
    
    //get mothers for antiK* PDG = -313
    AliRsnMiniOutput *outam = task->CreateOutput(Form("antiKs_Mother%s", suffix), "SPARSE", "MOTHER");
    outam->SetDaughter(0, AliRsnDaughter::kKaon);
    outam->SetDaughter(1, AliRsnDaughter::kPion);
    outam->SetMotherPDG(-313);
    outam->SetMotherMass(0.89594);
    outam->SetPairCuts(cutsPair);
    outam->AddAxis(imID, 90, 0.6, 1.5);
    outam->AddAxis(ptID, 200, 0.0, 20.0);
    if (!isPP){
      outam->AddAxis(centID, 100, 0.0, 100.0);
    }   else    { 
      outam->AddAxis(centID, 400, 0.0, 400.0);
    }
    
    //get phase space of the decay from mothers
    AliRsnMiniOutput *outps = task->CreateOutput(Form("Ks_phaseSpace%s", suffix), "HIST", "TRUE");
    outps->SetDaughter(0, AliRsnDaughter::kKaon);
    outps->SetDaughter(1, AliRsnDaughter::kPion);
    outps->SetCutID(0, iCutK);
    outps->SetCutID(1, iCutPi);
    outps->SetMotherPDG(313);
    outps->SetMotherMass(0.89594);
    outps->SetPairCuts(cutsPair);
    outps->AddAxis(fdpt, 50, 0.0, 5.0);
    outps->AddAxis(sdpt, 50, 0.0, 5.0);
    outps->AddAxis(ptID, 100, 0.0, 10.0);
    
    AliRsnMiniOutput *outaps = task->CreateOutput(Form("antiKs_phaseSpace%s", suffix), "HIST", "TRUE");
    outaps->SetDaughter(0, AliRsnDaughter::kKaon);
    outaps->SetDaughter(1, AliRsnDaughter::kPion);
    outaps->SetCutID(0, iCutK);
    outaps->SetCutID(1, iCutPi);
    outaps->SetMotherPDG(-313);
    outaps->SetMotherMass(0.89594);
    outaps->SetPairCuts(cutsPair);
    outaps->AddAxis(fdpt, 50, 0.0, 5.0);
    outaps->AddAxis(sdpt, 50, 0.0, 5.0);
    outaps->AddAxis(ptID, 100, 0.0, 10.0);
   
    //get reflections
    if (checkReflex) { 

      AliRsnMiniOutput *outreflex = task->CreateOutput(Form("Ks_reflex%s", suffix), "SPARSE", "TRUE");
      outreflex->SetDaughter(0, AliRsnDaughter::kKaon);
      outreflex->SetDaughter(1, AliRsnDaughter::kPion);
      outreflex->SetCutID(0, iCutPi);
      outreflex->SetCutID(1, iCutK);
      outreflex->SetMotherPDG(313);
      outreflex->SetMotherMass(0.89594);
      outreflex->SetPairCuts(cutsPair);
      outreflex->AddAxis(imID, 90, 0.6, 1.5);
      outreflex->AddAxis(ptID, 200, 0.0, 20.0);
      if (!isPP){
	outreflex->AddAxis(centID, 100, 0.0, 100.0);
      }   else    { 
	outreflex->AddAxis(centID, 400, 0.0, 400.0);
      }
      
      AliRsnMiniOutput *outareflex = task->CreateOutput(Form("antiKs_reflex%s", suffix), "SPARSE", "TRUE");
      outareflex->SetDaughter(0, AliRsnDaughter::kKaon);
      outareflex->SetDaughter(1, AliRsnDaughter::kPion);
      outareflex->SetCutID(0, iCutPi);
      outareflex->SetCutID(1, iCutK);
      outareflex->SetMotherPDG(-313);
      outareflex->SetMotherMass(0.89594);
      outareflex->SetPairCuts(cutsPair);
      outareflex->AddAxis(imID, 90, 0.6, 1.5);
      outareflex->AddAxis(ptID, 100, 0.0, 10.0);
      if (!isPP){
	outareflex->AddAxis(centID, 100, 0.0, 100.0);
      }   else    { 
	outareflex->AddAxis(centID, 400, 0.0, 400.0);
      }

    }//end reflections
  }//end MC
  
   return kTRUE;
}

//-------------------------------------------------------  
Bool_t SetCustomQualityCut(AliRsnCutTrackQuality * trkQualityCut, Int_t customQualityCutsID = 0, Int_t customFilterBit = 0)
{
  //Sets configuration for track quality object different from std quality cuts.
  //Returns kTRUE if track quality cut object is successfully defined,
  //returns kFALSE if an invalid set of cuts (customQualityCutsID) is chosen or if the
  //object to be configured does not exist.
  
  /* NOTES FROM PRODUCTION LHC13b pass3 - AOD filtered with v5-03-Rev-20
  //(http://svnweb.cern.ch/world/wsvn/AliRoot/tags/v5-03-Rev-20/ANALYSIS/macros/AddTaskESDFilter.C)

  //filter bit 0: Cuts on primary tracks
  // AliESDtrackCuts* esdTrackCutsL = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();

  //filter bit 4: std but looser dca cut
  // AliESDtrackCuts* esdTrackCutsH = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE);
  // esdTrackCutsH->SetMaxDCAToVertexXY(2.4);
  // esdTrackCutsH->SetMaxDCAToVertexZ(3.2);
  // esdTrackCutsH->SetDCAToVertex2D(kTRUE);

  //filter bit 5:  AliESDtrackCuts::GetStandardITSTPCTrackCuts2011();

   //filter bit 10: standard cuts with tight DCA cut, using cluster cut instead of crossed rows (a la 2010 default)
   //AliESDtrackCuts* esdTrackCutsH2Cluster = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kTRUE, 0);
   */

  if ((!trkQualityCut) || (customQualityCutsID<=0) || (customQualityCutsID>=AliRsnCutSetDaughterParticle::kNcustomQualityCuts)){
    Printf("::::: SetCustomQualityCut:: use default quality cuts specified in task configuration.");
    return kFALSE;
  }
  //for pA 2013
  //trkQualityCut->SetDefaults2011();//with filter bit=10
  //reset filter bit to very loose cuts 
  trkQualityCut->SetAODTestFilterBit(customFilterBit); 
  //apply all other cuts "by hand"
  trkQualityCut->SetCheckOnlyFilterBit(kFALSE);
  trkQualityCut->SetMinNCrossedRowsTPC(70, kTRUE);
  trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.8, kTRUE);
  trkQualityCut->SetMaxChi2TPCConstrainedGlobal(36);//used for ESD only - for AOD does not correspond to any cut
  trkQualityCut->SetTPCmaxChi2(4.0); //already in filter bit 0
  trkQualityCut->SetRejectKinkDaughters(kTRUE); //already in filter bit 0
  trkQualityCut->SetSPDminNClusters(AliESDtrackCuts::kAny);
  trkQualityCut->SetITSmaxChi2(36);
  trkQualityCut->AddStatusFlag(AliESDtrack::kTPCin   , kTRUE);//already in defaults 2011
  trkQualityCut->AddStatusFlag(AliESDtrack::kTPCrefit, kTRUE);//already in defaults 2011
  trkQualityCut->AddStatusFlag(AliESDtrack::kITSrefit, kTRUE);//already in defaults 2011

  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kFilterBitCustom) {
    trkQualityCut->SetCheckOnlyFilterBit(kTRUE);
  } 
  
  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdLooserDCAXY){
    trkQualityCut->SetDCARmax(2.4);
  } else {
    trkQualityCut->SetDCARPtFormula("0.0105+0.0350/pt^1.1");
  }
  
  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdLooserDCAZ){
    trkQualityCut->SetDCAZmax(3.2);
  } else {
    trkQualityCut->SetDCAZmax(2.0); 
  }
  
  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCrossedRows60){
    trkQualityCut->SetMinNCrossedRowsTPC(60, kTRUE);
  }
  
  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCrossedRows80){
    trkQualityCut->SetMinNCrossedRowsTPC(80, kTRUE);
  }
  
  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdRowsToCls075){
    trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.75, kTRUE);
  }
  
  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdRowsToCls085){
    trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.85, kTRUE);
  }
  
  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCls70){
    trkQualityCut->SetAODTestFilterBit(10);
    trkQualityCut->SetTPCminNClusters(70);
  }
  
  if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdChi2TPCCls35){
    trkQualityCut->SetTPCmaxChi2(3.5);
  }
  
  trkQualityCut->SetPtRange(0.15, 20.0);
  trkQualityCut->SetEtaRange(-0.8, 0.8);
  
  Printf(Form("::::: SetCustomQualityCut:: using custom track quality cuts #%i",customQualityCutsID));
  trkQualityCut->Print();
  return kTRUE;
}
Commit	Line	Data
101c097f	1	/***************************************************************************
	2	fbellini@cern.ch - last modified on 17/02/2014
	3
	4	// *** Configuration script for K, anti-K analysis with 2013 pPb runs ***
	5	//
	6	// A configuration script for RSN package needs to define the followings:
	7	//
	8	// (1) decay tree of each resonance to be studied, which is needed to select
	9	// true pairs and to assign the right mass to all candidate daughters
	10	// (2) cuts at all levels: single daughters, tracks, events
	11	// (3) output objects: histograms or trees
	12	****************************************************************************/
5e6eaf60	13	Bool_t ConfigKStarPPb
101c097f	14	(
	15	AliRsnMiniAnalysisTask *task,
	16	Bool_t isMC,
	17	Bool_t isPP,
	18	const char *suffix,
	19	AliRsnCutSet *cutsPair,
	20	Int_t aodFilterBit = 5,
	21	Int_t customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom,
	22	AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010,
	23	AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010,
	24	Float_t nsigmaPi = 2.0,
	25	Float_t nsigmaKa = 2.0,
	26	Bool_t enableMonitor = kTRUE,
	27	Bool_t IsMcTrueOnly = kFALSE,
101c097f	28	TString monitorOpt = "",
6d9699e8	29	Bool_t useMixLS = 0,
6d9699e8	30	Bool_t checkReflex = 0,
101c097f	31	AliRsnMiniValue::EType yaxisVar = AliRsnMiniValue::kPt
	32	)
	33	{
	34	// manage suffix
	35	if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
	36
	37	// set daughter cuts
	38	AliRsnCutSetDaughterParticle * cutSetQ;
	39	AliRsnCutSetDaughterParticle * cutSetPi;
	40	AliRsnCutSetDaughterParticle * cutSetK;
	41
	42	AliRsnCutTrackQuality * trkQualityCut = new AliRsnCutTrackQuality("myQualityCut");
	43	if (SetCustomQualityCut(trkQualityCut, customQualityCutsID, aodFilterBit)) {
	44	//Set custom quality cuts for systematic checks
	45	cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0);
	46	cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), trkQualityCut, cutPiCandidate, AliPID::kPion, nsigmaPi);
	47	cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa);
	48	} else {
	49	//use defult quality cuts (std 2010 or 2011)
172286d5	50	cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0, aodFilterBit, kTRUE);
101c097f	51	cutSetQ->SetUse2011StdQualityCuts(kTRUE);
172286d5	52	cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), cutPiCandidate, AliPID::kPion, nsigmaPi, aodFilterBit,kTRUE);
101c097f	53	cutSetPi->SetUse2011StdQualityCuts(kTRUE);
172286d5	54	cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit,kTRUE);
101c097f	55	cutSetK->SetUse2011StdQualityCuts(kTRUE);
	56	}
	57
	58	Int_t iCutQ = task->AddTrackCuts(cutSetQ);
	59	Int_t iCutPi = task->AddTrackCuts(cutSetPi);
	60	Int_t iCutK = task->AddTrackCuts(cutSetK);
	61
	62	if (enableMonitor){
	63	Printf("======== Cut monitoring enabled");
	64	gROOT->LoadMacro("$ALICE_ROOT/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
	65	AddMonitorOutput(isMC, cutSetQ->GetMonitorOutput(), monitorOpt.Data());
	66	AddMonitorOutput(isMC, cutSetPi->GetMonitorOutput(), monitorOpt.Data());
	67	AddMonitorOutput(isMC, cutSetK->GetMonitorOutput()), monitorOpt.Data();
	68	}
	69
	70	// -- Values ------------------------------------------------------------------------------------
	71	/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
	72	/* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
	73	/* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
	74	/* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
	75	/* pseudorapidity */ Int_t etaID = task->CreateValue(AliRsnMiniValue::kEta, kFALSE);
	76	/* rapidity */ Int_t yID = task->CreateValue(AliRsnMiniValue::kY, kFALSE);
	77	/* 1st daughter pt */ Int_t fdpt = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE);
	78	/* 2nd daughter pt */ Int_t sdpt = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE);
	79	/* 1st daughter p */ Int_t fdp = task->CreateValue(AliRsnMiniValue::kFirstDaughterP, kFALSE);
	80	/* 2nd daughter p */ Int_t sdp = task->CreateValue(AliRsnMiniValue::kSecondDaughterP, kFALSE);
	81
	82	// -- Create all needed outputs -----------------------------------------------------------------
	83	// use an array for more compact writing, which are different on mixing and charges
	84	// [0] = unlike
	85	// [1] = mixing
	86	// [2] = like ++
	87	// [3] = like --
	88
6d9699e8	89	Bool_t use [12] = {!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly ,isMC,isMC,isMC,isMC, useMixLS , useMixLS };
	90	Bool_t useIM [12] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 , 1 , 1 };
	91	TString name [12] = {"UnlikePM", "UnlikeMP","MixingPM","MixingMP", "LikePP", "LikeMM","TruesPM","TruesMP", "ResPM" ,"ResMP" , "MixingPP", "MixingMM" };
	92	TString comp [12] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" ,"TRUE" , "MIX" , "MIX" };
	93	TString output [12] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE", "SPARSE", "SPARSE","SPARSE" , "SPARSE","SPARSE", "SPARSE" , "SPARSE" };
	94	Int_t pdgCode [12] = {313 , 313 , 313 , 313 , 313 , 313 , 313 , -313 , 313 , -313 , 313 , 313 };
	95	Char_t charge1 [12] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' };
	96	Char_t charge2 [12] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' , '+' , '-' };
	97	Int_t cutID1 [12] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK };
	98	Int_t cutID2 [12] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi, iCutPi , iCutPi , iCutPi , iCutPi };
101c097f	99
	100	for (Int_t i = 0; i < 12; i++) {
	101	if (!use[i]) continue;
	102	AliRsnMiniOutput *out = task->CreateOutput(Form("kstar_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
	103	out->SetCutID(0, cutID1[i]);
	104	out->SetCutID(1, cutID2[i]);
	105	out->SetDaughter(0, AliRsnDaughter::kKaon);
	106	out->SetDaughter(1, AliRsnDaughter::kPion);
	107	out->SetCharge(0, charge1[i]);
	108	out->SetCharge(1, charge2[i]);
6d9699e8	109	out->SetMotherPDG(pdgCode[i]);
101c097f	110	out->SetMotherMass(0.89594);
	111	out->SetPairCuts(cutsPair);
	112
	113	// axis X: invmass (or resolution)
	114	if (useIM[i])
	115	out->AddAxis(imID, 90, 0.6, 1.5);
	116	else
	117	out->AddAxis(resID, 200, -0.02, 0.02);
	118
	119	// axis Y: transverse momentum of pair as default - else chosen value
	120	if (yaxisVar==AliRsnMiniValue::kFirstDaughterPt)
	121	out->AddAxis(fdpt, 100, 0.0, 10.0);
	122	else
	123	if (yaxisVar==AliRsnMiniValue::kSecondDaughterPt)
	124	out->AddAxis(sdpt, 100, 0.0, 10.0);
	125	else
	126	if (yaxisVar==AliRsnMiniValue::kFirstDaughterP)
	127	out->AddAxis(fdp, 100, 0.0, 10.0);
	128	else
	129	if (yaxisVar==AliRsnMiniValue::kSecondDaughterP)
	130	out->AddAxis(sdp, 100, 0.0, 10.0);
	131	else
	132	out->AddAxis(ptID, 200, 0.0, 20.0); //default use mother pt
	133
	134	// axis Z: centrality-multiplicity
	135	if (!isPP)
	136	out->AddAxis(centID, 100, 0.0, 100.0);
	137	else
	138	out->AddAxis(centID, 400, 0.0, 400.0);
101c097f	139	// axis W: pseudorapidity
	140	// out->AddAxis(etaID, 20, -1.0, 1.0);
	141	// axis J: rapidity
	142	// out->AddAxis(yID, 10, -0.5, 0.5);
101c097f	143	}
	144
	145	if (isMC){
6d9699e8	146	//get mothers for K* PDG = 313
6d9699e8	147	AliRsnMiniOutput *outm = task->CreateOutput(Form("Ks_Mother%s", suffix), "SPARSE", "MOTHER");
101c097f	148	outm->SetDaughter(0, AliRsnDaughter::kKaon);
101c097f	149	outm->SetDaughter(1, AliRsnDaughter::kPion);
6d9699e8	150	outm->SetMotherPDG(313);
101c097f	151	outm->SetMotherMass(0.89594);
101c097f	152	outm->SetPairCuts(cutsPair);
101c097f	153	outm->AddAxis(imID, 90, 0.6, 1.5);
	154	outm->AddAxis(ptID, 200, 0.0, 20.0);
	155	if (!isPP){
	156	outm->AddAxis(centID, 100, 0.0, 100.0);
	157	} else {
	158	outm->AddAxis(centID, 400, 0.0, 400.0);
	159	}
6d9699e8	160
	161	//get mothers for antiK* PDG = -313
	162	AliRsnMiniOutput *outam = task->CreateOutput(Form("antiKs_Mother%s", suffix), "SPARSE", "MOTHER");
	163	outam->SetDaughter(0, AliRsnDaughter::kKaon);
	164	outam->SetDaughter(1, AliRsnDaughter::kPion);
	165	outam->SetMotherPDG(-313);
	166	outam->SetMotherMass(0.89594);
	167	outam->SetPairCuts(cutsPair);
	168	outam->AddAxis(imID, 90, 0.6, 1.5);
	169	outam->AddAxis(ptID, 200, 0.0, 20.0);
	170	if (!isPP){
	171	outam->AddAxis(centID, 100, 0.0, 100.0);
	172	} else {
	173	outam->AddAxis(centID, 400, 0.0, 400.0);
	174	}
	175
	176	//get phase space of the decay from mothers
	177	AliRsnMiniOutput *outps = task->CreateOutput(Form("Ks_phaseSpace%s", suffix), "HIST", "TRUE");
	178	outps->SetDaughter(0, AliRsnDaughter::kKaon);
	179	outps->SetDaughter(1, AliRsnDaughter::kPion);
	180	outps->SetCutID(0, iCutK);
	181	outps->SetCutID(1, iCutPi);
	182	outps->SetMotherPDG(313);
	183	outps->SetMotherMass(0.89594);
	184	outps->SetPairCuts(cutsPair);
	185	outps->AddAxis(fdpt, 50, 0.0, 5.0);
	186	outps->AddAxis(sdpt, 50, 0.0, 5.0);
	187	outps->AddAxis(ptID, 100, 0.0, 10.0);
	188
	189	AliRsnMiniOutput *outaps = task->CreateOutput(Form("antiKs_phaseSpace%s", suffix), "HIST", "TRUE");
	190	outaps->SetDaughter(0, AliRsnDaughter::kKaon);
	191	outaps->SetDaughter(1, AliRsnDaughter::kPion);
	192	outaps->SetCutID(0, iCutK);
	193	outaps->SetCutID(1, iCutPi);
	194	outaps->SetMotherPDG(-313);
	195	outaps->SetMotherMass(0.89594);
	196	outaps->SetPairCuts(cutsPair);
	197	outaps->AddAxis(fdpt, 50, 0.0, 5.0);
	198	outaps->AddAxis(sdpt, 50, 0.0, 5.0);
	199	outaps->AddAxis(ptID, 100, 0.0, 10.0);
	200
	201	//get reflections
	202	if (checkReflex) {
	203
	204	AliRsnMiniOutput *outreflex = task->CreateOutput(Form("Ks_reflex%s", suffix), "SPARSE", "TRUE");
	205	outreflex->SetDaughter(0, AliRsnDaughter::kKaon);
	206	outreflex->SetDaughter(1, AliRsnDaughter::kPion);
	207	outreflex->SetCutID(0, iCutPi);
	208	outreflex->SetCutID(1, iCutK);
	209	outreflex->SetMotherPDG(313);
	210	outreflex->SetMotherMass(0.89594);
	211	outreflex->SetPairCuts(cutsPair);
	212	outreflex->AddAxis(imID, 90, 0.6, 1.5);
	213	outreflex->AddAxis(ptID, 200, 0.0, 20.0);
	214	if (!isPP){
	215	outreflex->AddAxis(centID, 100, 0.0, 100.0);
	216	} else {
	217	outreflex->AddAxis(centID, 400, 0.0, 400.0);
	218	}
	219
	220	AliRsnMiniOutput *outareflex = task->CreateOutput(Form("antiKs_reflex%s", suffix), "SPARSE", "TRUE");
	221	outareflex->SetDaughter(0, AliRsnDaughter::kKaon);
	222	outareflex->SetDaughter(1, AliRsnDaughter::kPion);
	223	outareflex->SetCutID(0, iCutPi);
224	outareflex->SetCutID(1, iCutK);
225	outareflex->SetMotherPDG(-313);
226	outareflex->SetMotherMass(0.89594);
227	outareflex->SetPairCuts(cutsPair);
228	outareflex->AddAxis(imID, 90, 0.6, 1.5);
229	outareflex->AddAxis(ptID, 100, 0.0, 10.0);
230	if (!isPP){
231	outareflex->AddAxis(centID, 100, 0.0, 100.0);
232	} else {
233	outareflex->AddAxis(centID, 400, 0.0, 400.0);
234	}
235
236	}//end reflections
237	}//end MC
238
239	return kTRUE;
101c097f	240	}
	241
	242	//-------------------------------------------------------
	243	Bool_t SetCustomQualityCut(AliRsnCutTrackQuality * trkQualityCut, Int_t customQualityCutsID = 0, Int_t customFilterBit = 0)
	244	{
	245	//Sets configuration for track quality object different from std quality cuts.
	246	//Returns kTRUE if track quality cut object is successfully defined,
	247	//returns kFALSE if an invalid set of cuts (customQualityCutsID) is chosen or if the
	248	//object to be configured does not exist.
	249
	250	/* NOTES FROM PRODUCTION LHC13b pass3 - AOD filtered with v5-03-Rev-20
	251	//(http://svnweb.cern.ch/world/wsvn/AliRoot/tags/v5-03-Rev-20/ANALYSIS/macros/AddTaskESDFilter.C)
	252
	253	//filter bit 0: Cuts on primary tracks
	254	// AliESDtrackCuts* esdTrackCutsL = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	255
	256	//filter bit 4: std but looser dca cut
	257	// AliESDtrackCuts* esdTrackCutsH = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE);
	258	// esdTrackCutsH->SetMaxDCAToVertexXY(2.4);
	259	// esdTrackCutsH->SetMaxDCAToVertexZ(3.2);
	260	// esdTrackCutsH->SetDCAToVertex2D(kTRUE);
	261
	262	//filter bit 5: AliESDtrackCuts::GetStandardITSTPCTrackCuts2011();
	263
	264	//filter bit 10: standard cuts with tight DCA cut, using cluster cut instead of crossed rows (a la 2010 default)
	265	//AliESDtrackCuts* esdTrackCutsH2Cluster = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kTRUE, 0);
	266	*/
	267
	268	if ((!trkQualityCut) \|\| (customQualityCutsID<=0) \|\| (customQualityCutsID>=AliRsnCutSetDaughterParticle::kNcustomQualityCuts)){
	269	Printf("::::: SetCustomQualityCut:: use default quality cuts specified in task configuration.");
	270	return kFALSE;
	271	}
	272	//for pA 2013
	273	//trkQualityCut->SetDefaults2011();//with filter bit=10
	274	//reset filter bit to very loose cuts
	275	trkQualityCut->SetAODTestFilterBit(customFilterBit);
	276	//apply all other cuts "by hand"
	277	trkQualityCut->SetCheckOnlyFilterBit(kFALSE);
33131d21	278	trkQualityCut->SetMinNCrossedRowsTPC(70, kTRUE);
33131d21	279	trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.8, kTRUE);
101c097f	280	trkQualityCut->SetMaxChi2TPCConstrainedGlobal(36);//used for ESD only - for AOD does not correspond to any cut
	281	trkQualityCut->SetTPCmaxChi2(4.0); //already in filter bit 0
	282	trkQualityCut->SetRejectKinkDaughters(kTRUE); //already in filter bit 0
	283	trkQualityCut->SetSPDminNClusters(AliESDtrackCuts::kAny);
	284	trkQualityCut->SetITSmaxChi2(36);
	285	trkQualityCut->AddStatusFlag(AliESDtrack::kTPCin , kTRUE);//already in defaults 2011
	286	trkQualityCut->AddStatusFlag(AliESDtrack::kTPCrefit, kTRUE);//already in defaults 2011
	287	trkQualityCut->AddStatusFlag(AliESDtrack::kITSrefit, kTRUE);//already in defaults 2011
	288
	289	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kFilterBitCustom) {
	290	trkQualityCut->SetCheckOnlyFilterBit(kTRUE);
	291	}
	292
	293	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdLooserDCAXY){
	294	trkQualityCut->SetDCARmax(2.4);
	295	} else {
	296	trkQualityCut->SetDCARPtFormula("0.0105+0.0350/pt^1.1");
	297	}
	298
	299	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdLooserDCAZ){
	300	trkQualityCut->SetDCAZmax(3.2);
	301	} else {
	302	trkQualityCut->SetDCAZmax(2.0);
	303	}
	304
	305	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCrossedRows60){
33131d21	306	trkQualityCut->SetMinNCrossedRowsTPC(60, kTRUE);
101c097f	307	}
	308
	309	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCrossedRows80){
33131d21	310	trkQualityCut->SetMinNCrossedRowsTPC(80, kTRUE);
101c097f	311	}
	312
	313	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdRowsToCls075){
33131d21	314	trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.75, kTRUE);
101c097f	315	}
	316
	317	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdRowsToCls085){
33131d21	318	trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(0.85, kTRUE);
101c097f	319	}
	320
	321	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdCls70){
	322	trkQualityCut->SetAODTestFilterBit(10);
	323	trkQualityCut->SetTPCminNClusters(70);
	324	}
	325
	326	if (customQualityCutsID==AliRsnCutSetDaughterParticle::kStdChi2TPCCls35){
	327	trkQualityCut->SetTPCmaxChi2(3.5);
	328	}
	329
	330	trkQualityCut->SetPtRange(0.15, 20.0);
	331	trkQualityCut->SetEtaRange(-0.8, 0.8);
	332
	333	Printf(Form("::::: SetCustomQualityCut:: using custom track quality cuts #%i",customQualityCutsID));
	334	trkQualityCut->Print();
	335	return kTRUE;
	336	}