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

/***************************************************************************
              fbellini@cern.ch - last modified on 28/11/2013

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