[u/mrichter/AliRoot.git] / PWGDQ / dielectron / macrosJPSI / ConfigJpsiME_jpsi_PbPb.C

void InitHistograms(AliDielectron *die, Int_t cutDefinition);
void InitHF(AliDielectron* die, Int_t cutDefinition);

void SetupEventCuts(AliDielectron *die, ULong64_t triggers, Int_t cutDefinition);
void SetupTrackCuts(AliDielectron *die, Int_t cutDefinition);
void SetupPairCuts( AliDielectron *die,  Int_t cutDefinition);

void ConfigEvtPlane(AliDielectron *die,  Int_t cutDefinition);
void ConfigBgrd(    AliDielectron *die,  Int_t cutDefinition);

TString names=("NoBins;Zvtx;ZvtxNoKF;ZvtxCent;ZvtxNcontr;ZvtxNcontrPE;ZvtxNcontrPEepTPC;ZvtxNcontrPEepTPCmag;ZvtxepTPC");
enum { kNoBins=0, kZvtx, kZvtxNoKF, kZvtxCent, kZvtxNcontr, kZvtxNcontrPE, kZvtxNcontrPEepTPC, kZvtxNcontrPEepTPCmag, kZvtxepTPC};

TObjArray *arrNames=names.Tokenize(";");
const Int_t nDie=arrNames->GetEntries();

Bool_t  isESD = kTRUE;
Bool_t  hasMC = kFALSE;
TString list  = gSystem->Getenv("LIST");

AliDielectron* ConfigJpsiME_jpsi_PbPb(Int_t cutDefinition, TString prod="", ULong64_t triggers=AliVEvent::kCentral | AliVEvent::kSemiCentral | AliVEvent::kMB)
{
  //
  // Setup the instance of AliDielectron
  //

  // gsi train?
  TString trainRoot = gSystem->Getenv("TRAIN_ROOT");
  Bool_t isGSItrain = (trainRoot.IsNull()?kFALSE:kTRUE); 

  // find mc or not?
  if( list.IsNull()) list=prod;
  if( list.Contains("LHC10h")   || list.Contains("LHC11h")   ) hasMC=kFALSE;
  if( list.Contains("LHC11a10") || list.Contains("LHC12a17") ) hasMC=kTRUE;

  //ESD handler?
  isESD=(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->IsA()==AliESDInputHandler::Class());

  // switch off some configurations
  if(hasMC) { // MONTE CARLO
    switch(cutDefinition) {
      //case kQA:        return 0x0;
    }
  } else { // COLLISION DATA
    switch(cutDefinition) {
      //    case kNoBins:               return 0x0;
      //    case kZvtx:                 return 0x0;
    case kZvtxNoKF:             return 0x0;
      //    case kZvtxCent:             return 0x0;
      //    case kZvtxNcontr:           return 0x0;
    case kZvtxNcontrPE:         return 0x0;
    case kZvtxNcontrPEepTPC:    return 0x0;
    case kZvtxNcontrPEepTPCmag: return 0x0;
      //    case kZvtxepTPC:            return 0x0;
      //    case kQA:  return 0x0;
      //    case kGammas:  return 0x0;
    }
  }


  // task name
  TString name=Form("%02d",cutDefinition);
  if (cutDefinition<arrNames->GetEntriesFast())  name=arrNames->At(cutDefinition)->GetName();
  printf(" Adding %s%s config %s for %s \n",(isESD?"ESD":"AOD"),(hasMC?" MC":""),name.Data(),list.Data());

  // init AliDielectron
  AliDielectron *die = new AliDielectron(Form("%s",name.Data()), Form("ME config: %s",name.Data()));
  die->SetHasMC(hasMC);

  // cut setup
  SetupEventCuts(die,triggers,cutDefinition);
  SetupTrackCuts(die,cutDefinition);
  SetupPairCuts(die,cutDefinition);

  // bgrd estimators
  ConfigBgrd(die,cutDefinition);

  // tpc event plane configuration
  ConfigEvtPlane(die,cutDefinition);

  // prefilter settings
  die->SetPreFilterUnlikeOnly();
  //die->SetPreFilterAllSigns();
  //die->SetNoPairing();

  // KF usgae
  if(cutDefinition==kZvtxNoKF) die->SetUseKF(kFALSE);

  // histogram setup
  InitHistograms(die,cutDefinition);
  printf(" Add %d class types to the histo manager \n",die->GetHistogramList()->GetEntries());

  // HF array setup
  InitHF(die,cutDefinition);


  return die;
}

//______________________________________________________________________________________
void SetupEventCuts(AliDielectron *die, ULong64_t triggers, Int_t cutDefinition)
{
  //
  // Setup the event cuts
  //

  // trigger specific centrality cuts (reject trigger inefficiencies)
  Double_t minCent=0.0, maxCent=100.;
  if(!hasMC) {
    switch(triggers) {
    case AliVEvent::kCentral:     minCent= 0.; maxCent= 9.; break;
    case AliVEvent::kSemiCentral: minCent=12.; maxCent=53.; break;
    case AliVEvent::kMB:          minCent= 0.; maxCent=80.; break;
    default:                      minCent= 0.; maxCent=80.; break;
    }
  }

  // VZERO multiplicity vs. number ob global tracks cut
  TF1 *fMean  = new TF1("fMean", "pol1",               0,25e+3);
  fMean->SetParameters(691.633, 1.4892);
  TF1 *fSigma = new TF1("fSigma","[0]+sqrt([1]*x+[2])",0,25e+3);
  fSigma->SetParameters(-83.6599, 36.7677, 69530.7);

  // number of vertex contributors TPC vs. global cut
  TF1* vtxContribUp = new TF1("vtxContribUp","pol1",0.,20000.);
  vtxContribUp->SetParameters(0.,1.38);      //  --> strong cut, removes about 40% of events
  TF1* vtxContribLow= new TF1("vtxContribLow","pol1",0.,20000.);
  vtxContribLow->SetParameters(-100.,1.2);

  AliDielectronEventCuts *eventCuts=new AliDielectronEventCuts("eventCuts","eventCuts");
  if(!isESD) eventCuts->SetVertexType(AliDielectronEventCuts::kVtxAny);
  eventCuts->SetRequireVertex();
  eventCuts->SetMinVtxContributors(1);
  eventCuts->SetVertexZ(-10.,+10.);
  eventCuts->SetCentralityRange(minCent,maxCent);
  
  // apply pile-up event (PE) rejection
  switch(cutDefinition) {
  case kZvtxNcontrPE:
  case kZvtxNcontrPEepTPC:
  case kZvtxNcontrPEepTPCmag:
    eventCuts->SetCutOnV0MultipicityNTrks(fMean, fSigma, 4.0);
    //    eventCuts->SetCutOnNVtxContributorsGloablTPC(vtxContribLow, vtxContribUp);
  }
  eventCuts->Print();
  die->GetEventFilter().AddCuts(eventCuts);

}

//______________________________________________________________________________________
void SetupTrackCuts(AliDielectron *die, Int_t cutDefinition)
{
  //
  // Setup the track cuts
  //

  // Quality cuts
  AliDielectronCutGroup* cuts = new AliDielectronCutGroup("cuts","cuts",AliDielectronCutGroup::kCompAND);
  die->GetTrackFilter().AddCuts(cuts);

  // AOD track filter (needs to be first cut to speed up)
  AliDielectronTrackCuts *trkFilter = new AliDielectronTrackCuts("TrkFilter","TrkFilter");
  trkFilter->SetAODFilterBit(AliDielectronTrackCuts::kTPCqual);
  //  trkFilter->SetMinNCrossedRowsOverFindable(0.6);
  if(!isESD) cuts->AddCut(trkFilter);

  //Pt cut, should make execution a bit faster
  AliDielectronVarCuts *pt = new AliDielectronVarCuts("PtCut","PtCut");
  pt->AddCut(AliDielectronVarManager::kPt,0.85,1e30);    //0.8
  cuts->AddCut(pt);

  // track cuts ESD and AOD
  AliDielectronVarCuts *varCuts = new AliDielectronVarCuts("VarCuts","VarCuts");
  varCuts->AddCut(AliDielectronVarManager::kImpactParXY, -1.0,   1.0);
  varCuts->AddCut(AliDielectronVarManager::kImpactParZ,  -3.0,   3.0);
  varCuts->AddCut(AliDielectronVarManager::kEta,         -0.9,   0.9); // -0.9, 0.9
  varCuts->AddCut(AliDielectronVarManager::kTPCchi2Cl,    0.0,   4.0);
  varCuts->AddCut(AliDielectronVarManager::kNclsTPC,     70.0, 160.0);
  varCuts->AddCut(AliDielectronVarManager::kKinkIndex0,   0.0);
  varCuts->AddCut(AliDielectronVarManager::kTOFbeta,      0.2,   0.9, kTRUE);
  cuts->AddCut(varCuts);
  varCuts->Print();

  AliDielectronTrackCuts *trkCuts = new AliDielectronTrackCuts("TrkCuts","TrkCuts");
  trkCuts->SetITSclusterCut(AliDielectronTrackCuts::kOneOf, 3); // ITS-4 = 1+2+4+8
  trkCuts->SetRequireITSRefit(kTRUE);
  trkCuts->SetRequireTPCRefit(kTRUE);
  cuts->AddCut(trkCuts);

  /* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv PID CUTS vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
  AliDielectronPID *pid = new AliDielectronPID("PID","PID");
  pid->AddCut(AliDielectronPID::kTPC,AliPID::kPion,-100.,4.0,0.,0.,kTRUE);
  pid->AddCut(AliDielectronPID::kTPC,AliPID::kProton,-100.,3.5,0.,0.,kTRUE);
  pid->AddCut(AliDielectronPID::kTPC,AliPID::kElectron,-4.,4.);
  pid->AddCut(AliDielectronPID::kTOF,AliPID::kElectron,-3,3.,0.,0.,kFALSE,AliDielectronPID::kIfAvailable);
  cuts->AddCut(pid);
  /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PID CUTS ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/

  // exclude conversion electrons selected by the tender
  AliDielectronTrackCuts *noconv=new AliDielectronTrackCuts("noConv","noConv");
  noconv->SetV0DaughterCut(AliPID::kElectron,kTRUE);
  //  cuts->AddCut(noconv);

}

//______________________________________________________________________________________
void SetupPairCuts(AliDielectron *die, Int_t cutDefinition)
{
  //
  // Setup the pair cuts
  //

  // conversion rejection
  Double_t gCut = 0.05;
  AliDielectronVarCuts *gammaCuts = new AliDielectronVarCuts("GammaCuts","GammaCuts");
//  gammaCuts->AddCut(AliDielectronVarManager::kOpeningAngle, 0.0,   0.1,  kTRUE);
//  gammaCuts->AddCut(AliDielectronVarManager::kLegDist,      0.0,   0.25, kTRUE);
//  gammaCuts->AddCut(AliDielectronVarManager::kR,            3.0,   90.0, kTRUE);
//  gammaCuts->AddCut(AliDielectronVarManager::kPsiPair,      0.0,   0.05, kTRUE);
//  gammaCuts->AddCut(AliDielectronVarManager::kChi2NDF,      0.0,   10.0, kTRUE);
  gammaCuts->AddCut(AliDielectronVarManager::kM,            0.0,   gCut);
  die->GetPairPreFilter().AddCuts(gammaCuts);

  // rapidity selection
  //  AliDielectronVarCuts *rapCut=new AliDielectronVarCuts("|Y|<.9","|Y|<.9");
  // rapCut->AddCut(AliDielectronVarManager::kY,-0.9,0.9);
  // die->GetPairFilter().AddCuts(rapCut);

}

//______________________________________________________________________________________
void ConfigBgrd(AliDielectron *die, Int_t cutDefinition)
{
  //
  // Configurate the background estimators
  //

  // add mixed events
  AliDielectronMixingHandler *mix=new AliDielectronMixingHandler;

  // mixing handler
  switch(cutDefinition) {
  case kNoBins: /* */ break;
  case kZvtx:
  case kZvtxNoKF:
    mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
    break;
  case kZvtxCent:
    mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
    mix->AddVariable(AliDielectronVarManager::kCentrality,  8,  0.,80.);
    break;
  case kZvtxNcontrPEepTPCmag:
    mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
    mix->AddVariable(AliDielectronVarManager::kNVtxContrib, 32, 0.,3200.);
    mix->AddVariable(AliDielectronVarManager::kTPCrpH2,     8,  TMath::Pi()/-2., TMath::Pi()/2.);
    mix->AddVariable(AliDielectronVarManager::kTPCmagH2,    "0.,20.,50.,80.,110.,150.,500.");
    break;
  case kZvtxNcontrPEepTPC:
    mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
    mix->AddVariable(AliDielectronVarManager::kNVtxContrib, 32, 0.,3200.);
    mix->AddVariable(AliDielectronVarManager::kTPCrpH2,     8,  TMath::Pi()/-2., TMath::Pi()/2.);
    break;
  case kZvtxNcontrPE:
  case kZvtxNcontr:
    mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
    mix->AddVariable(AliDielectronVarManager::kNVtxContrib, 32, 0.,3200.);
    break;
  case kZvtxepTPC:
    mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
    mix->AddVariable(AliDielectronVarManager::kTPCrpH2,     8,  TMath::Pi()/-2., TMath::Pi()/2.);
    mix->AddVariable(AliDielectronVarManager::kTPCmagH2,    "0.,20.,50.,80.,110.,150.,500.");
    break;
  }
  mix->SetMixType(AliDielectronMixingHandler::kOSonly);
  mix->SetDepth(150);
  mix->Print();

  die->SetMixingHandler(mix);
}

//______________________________________________________________________________________
void ConfigEvtPlane(AliDielectron *die, Int_t cutDefinition)
{
  //
  // Configurate the TPC event plane 
  //

  if(cutDefinition!=kZvtxNcontrPEepTPC && cutDefinition!=kZvtxNcontrPEepTPCmag && cutDefinition!=kZvtxepTPC ) return;

  Double_t gGap = 0.0;
  AliDielectronVarCuts *poi = new AliDielectronVarCuts("PoI","PoI");
  poi->AddCut(AliDielectronVarManager::kM,2.92,3.20);     // particles of interest, jpsi mass window
  die->GetEventPlanePOIPreFilter().AddCuts(poi);

  // eta gap in tpc event plane
  //AliDielectronVarCuts *etaGap = new AliDielectronVarCuts(AliDielectronVarManager::GetValueName(AliDielectronVarManager::kEta),"etaGap");
  //etaGap->AddCut(AliDielectronVarManager::kEta,-1*gGap,gGap,kTRUE);
  //die->GetEventPlanePreFilter().AddCuts(etaGap);
  //if(cutDefinition==kSubLS) die->SetLikeSignSubEvents();

  die->SetPreFilterEventPlane();
}

//______________________________________________________________________________________
void InitHistograms(AliDielectron *die, Int_t cutDefinition)
{
  //
  // Initialise the histograms
  //

  //Setup histogram Manager
  AliDielectronHistos *histos=new AliDielectronHistos(die->GetName(),die->GetTitle());

  //add histograms to event class
  histos->AddClass("Event");


  switch(cutDefinition) {
  case kNoBins: /* */ break;
  case kZvtxCent:
    histos->UserHistogram("Event","","", 200,-10.,   10.,    AliDielectronVarManager::kZvPrim);
    histos->UserHistogram("Event","","", 100,  0.0, 100.0,   AliDielectronVarManager::kCentrality);
    break;
  case kZvtxNcontrPEepTPCmag:
    histos->UserHistogram("Event","","", 250,  0.,  500.,    AliDielectronVarManager::kTPCmagH2);
  case kZvtxNcontrPEepTPC:
    histos->UserHistogram("Event","","", 16, TMath::Pi()/-2., TMath::Pi()/2.,    AliDielectronVarManager::kTPCrpH2);
  case kZvtxNcontrPE:
  case kZvtxNcontr:
    histos->UserHistogram("Event","","", 200,  0., 4000.,    AliDielectronVarManager::kNVtxContrib);
  case kZvtx:
  case kZvtxNoKF:
    histos->UserHistogram("Event","","", 200,-10.,   10.,    AliDielectronVarManager::kZvPrim);
    break;
  case kZvtxepTPC:
    histos->UserHistogram("Event","","", 200,-10.,   10.,    AliDielectronVarManager::kZvPrim);
    histos->UserHistogram("Event","","", 250,  0.,  500.,    AliDielectronVarManager::kTPCmagH2);
    histos->UserHistogram("Event","","", 16, TMath::Pi()/-2., TMath::Pi()/2.,    AliDielectronVarManager::kTPCrpH2);
    break;
  }

  //Initialise histogram classes
  histos->SetReservedWords("Pair");
  //Pair classes inclusive mixed events
  histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(0)));
  histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(1)));
  histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(2)));
  histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(4)));

  ///// add histograms to Pair classes /////
  histos->UserHistogram("Pair","","",  300,.0,300*0.04, 80,0.,80.,
			AliDielectronVarManager::kM, AliDielectronVarManager::kCentrality); // 40MeV bins, 12GeV/c2
  histos->UserHistogram("Pair","","",  300,.0,300*0.04, 20,0.,20.,
			AliDielectronVarManager::kM, AliDielectronVarManager::kPt); // 40MeV bins, 12GeV/c2

  histos->UserHistogram("Pair","","",  100,-1.,1.,      AliDielectronVarManager::kY);
  histos->UserHistogram("Pair","","",  400,0,20.,       AliDielectronVarManager::kPt);
  histos->UserHistogram("Pair","","",  125,0,0.04*125,  AliDielectronVarManager::kM);

  Int_t maxMixBins = die->GetMixingHandler()->GetNumberOfBins();
  TObjArray *limits  = new TObjArray();
  limits->Add(AliDielectronHelper::MakeLinBinning(125,         0.,          5.));
  limits->Add(AliDielectronHelper::MakeLinBinning( 32,         0.,         80.));
  limits->Add(AliDielectronHelper::MakeLinBinning( 20,         0.,         20.));
  limits->Add(AliDielectronHelper::MakeLinBinning(maxMixBins,  0.,  maxMixBins));

  UInt_t vars[4]={AliDielectronVarManager::kM,
		  AliDielectronVarManager::kCentrality,
		  AliDielectronVarManager::kPt,
		  AliDielectronVarManager::kMixingBin      };
  histos->UserSparse("Pair", 4, limits, vars);


  //legs from pair (fill SE)
  //  for (Int_t i=0; i<3; ++i){
  //  histos->AddClass(Form("Track_Legs_%s",AliDielectron::PairClassName(i)));
  // }
  //Track classes
  //to fill also track info from 2nd event loop until 2
  //for (Int_t i=0; i<2; ++i){
  //  histos->AddClass(Form("Track_%s",AliDielectron::TrackClassName(i)));
  //}


  die->SetHistogramManager(histos);
}
void InitHF(AliDielectron* die, Int_t cutDefinition)
{
  //
  // Setup the HF arrays
  //


  AliDielectronHF *hf=new AliDielectronHF(die->GetName(),die->GetTitle());
  //  if(hasMC) hf->SetStepForMCGenerated();
  hf->SetPairTypes(AliDielectronHF::kAll);
  hf->SetVariable(AliDielectronVarManager::kM, 125, 0.0, 0.04*125);
  hf->AddCutVariable(AliDielectronVarManager::kCentrality, "0.,80.");
  die->SetHistogramArray(hf);
}
Commit	Line	Data
15f4cb18	1	void InitHistograms(AliDielectron *die, Int_t cutDefinition);
ab5dc7f9	2	void InitHF(AliDielectron* die, Int_t cutDefinition);
15f4cb18	3
	4	void SetupEventCuts(AliDielectron *die, ULong64_t triggers, Int_t cutDefinition);
	5	void SetupTrackCuts(AliDielectron *die, Int_t cutDefinition);
	6	void SetupPairCuts( AliDielectron *die, Int_t cutDefinition);
	7
	8	void ConfigEvtPlane(AliDielectron *die, Int_t cutDefinition);
	9	void ConfigBgrd( AliDielectron *die, Int_t cutDefinition);
	10
ab5dc7f9	11	TString names=("NoBins;Zvtx;ZvtxNoKF;ZvtxCent;ZvtxNcontr;ZvtxNcontrPE;ZvtxNcontrPEepTPC;ZvtxNcontrPEepTPCmag;ZvtxepTPC");
ab5dc7f9	12	enum { kNoBins=0, kZvtx, kZvtxNoKF, kZvtxCent, kZvtxNcontr, kZvtxNcontrPE, kZvtxNcontrPEepTPC, kZvtxNcontrPEepTPCmag, kZvtxepTPC};
15f4cb18	13
	14	TObjArray *arrNames=names.Tokenize(";");
	15	const Int_t nDie=arrNames->GetEntries();
	16
	17	Bool_t isESD = kTRUE;
	18	Bool_t hasMC = kFALSE;
	19	TString list = gSystem->Getenv("LIST");
	20
	21	AliDielectron* ConfigJpsiME_jpsi_PbPb(Int_t cutDefinition, TString prod="", ULong64_t triggers=AliVEvent::kCentral \| AliVEvent::kSemiCentral \| AliVEvent::kMB)
	22	{
	23	//
	24	// Setup the instance of AliDielectron
	25	//
	26
	27	// gsi train?
	28	TString trainRoot = gSystem->Getenv("TRAIN_ROOT");
	29	Bool_t isGSItrain = (trainRoot.IsNull()?kFALSE:kTRUE);
	30
	31	// find mc or not?
	32	if( list.IsNull()) list=prod;
	33	if( list.Contains("LHC10h") \|\| list.Contains("LHC11h") ) hasMC=kFALSE;
	34	if( list.Contains("LHC11a10") \|\| list.Contains("LHC12a17") ) hasMC=kTRUE;
	35
	36	//ESD handler?
	37	isESD=(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->IsA()==AliESDInputHandler::Class());
	38
ab5dc7f9	39	// switch off some configurations
	40	if(hasMC) { // MONTE CARLO
	41	switch(cutDefinition) {
	42	//case kQA: return 0x0;
	43	}
	44	} else { // COLLISION DATA
	45	switch(cutDefinition) {
	46	// case kNoBins: return 0x0;
	47	// case kZvtx: return 0x0;
	48	case kZvtxNoKF: return 0x0;
	49	// case kZvtxCent: return 0x0;
	50	// case kZvtxNcontr: return 0x0;
	51	case kZvtxNcontrPE: return 0x0;
	52	case kZvtxNcontrPEepTPC: return 0x0;
	53	case kZvtxNcontrPEepTPCmag: return 0x0;
	54	// case kZvtxepTPC: return 0x0;
	55	// case kQA: return 0x0;
	56	// case kGammas: return 0x0;
	57	}
	58	}
	59
	60
15f4cb18	61	// task name
	62	TString name=Form("%02d",cutDefinition);
	63	if (cutDefinition<arrNames->GetEntriesFast()) name=arrNames->At(cutDefinition)->GetName();
	64	printf(" Adding %s%s config %s for %s \n",(isESD?"ESD":"AOD"),(hasMC?" MC":""),name.Data(),list.Data());
	65
	66	// init AliDielectron
	67	AliDielectron *die = new AliDielectron(Form("%s",name.Data()), Form("ME config: %s",name.Data()));
	68	die->SetHasMC(hasMC);
	69
	70	// cut setup
	71	SetupEventCuts(die,triggers,cutDefinition);
	72	SetupTrackCuts(die,cutDefinition);
	73	SetupPairCuts(die,cutDefinition);
	74
15f4cb18	75	// bgrd estimators
	76	ConfigBgrd(die,cutDefinition);
	77
	78	// tpc event plane configuration
	79	ConfigEvtPlane(die,cutDefinition);
	80
	81	// prefilter settings
	82	die->SetPreFilterUnlikeOnly();
	83	//die->SetPreFilterAllSigns();
	84	//die->SetNoPairing();
	85
1c96a71e	86	// KF usgae
	87	if(cutDefinition==kZvtxNoKF) die->SetUseKF(kFALSE);
	88
ab5dc7f9	89	// histogram setup
	90	InitHistograms(die,cutDefinition);
	91	printf(" Add %d class types to the histo manager \n",die->GetHistogramList()->GetEntries());
	92
	93	// HF array setup
	94	InitHF(die,cutDefinition);
	95
	96
15f4cb18	97	return die;
	98	}
	99
	100	//______________________________________________________________________________________
	101	void SetupEventCuts(AliDielectron *die, ULong64_t triggers, Int_t cutDefinition)
	102	{
	103	//
	104	// Setup the event cuts
	105	//
	106
	107	// trigger specific centrality cuts (reject trigger inefficiencies)
	108	Double_t minCent=0.0, maxCent=100.;
	109	if(!hasMC) {
	110	switch(triggers) {
	111	case AliVEvent::kCentral: minCent= 0.; maxCent= 9.; break;
	112	case AliVEvent::kSemiCentral: minCent=12.; maxCent=53.; break;
	113	case AliVEvent::kMB: minCent= 0.; maxCent=80.; break;
	114	default: minCent= 0.; maxCent=80.; break;
	115	}
	116	}
	117
	118	// VZERO multiplicity vs. number ob global tracks cut
	119	TF1 *fMean = new TF1("fMean", "pol1", 0,25e+3);
	120	fMean->SetParameters(691.633, 1.4892);
	121	TF1 fSigma = new TF1("fSigma","[0]+sqrt([1]x+[2])",0,25e+3);
	122	fSigma->SetParameters(-83.6599, 36.7677, 69530.7);
	123
	124	// number of vertex contributors TPC vs. global cut
	125	TF1* vtxContribUp = new TF1("vtxContribUp","pol1",0.,20000.);
	126	vtxContribUp->SetParameters(0.,1.38); // --> strong cut, removes about 40% of events
	127	TF1* vtxContribLow= new TF1("vtxContribLow","pol1",0.,20000.);
	128	vtxContribLow->SetParameters(-100.,1.2);
	129
	130	AliDielectronEventCuts *eventCuts=new AliDielectronEventCuts("eventCuts","eventCuts");
	131	if(!isESD) eventCuts->SetVertexType(AliDielectronEventCuts::kVtxAny);
	132	eventCuts->SetRequireVertex();
	133	eventCuts->SetMinVtxContributors(1);
	134	eventCuts->SetVertexZ(-10.,+10.);
	135	eventCuts->SetCentralityRange(minCent,maxCent);
	136
	137	// apply pile-up event (PE) rejection
	138	switch(cutDefinition) {
	139	case kZvtxNcontrPE:
	140	case kZvtxNcontrPEepTPC:
	141	case kZvtxNcontrPEepTPCmag:
	142	eventCuts->SetCutOnV0MultipicityNTrks(fMean, fSigma, 4.0);
	143	// eventCuts->SetCutOnNVtxContributorsGloablTPC(vtxContribLow, vtxContribUp);
	144	}
	145	eventCuts->Print();
	146	die->GetEventFilter().AddCuts(eventCuts);
	147
	148	}
	149
	150	//______________________________________________________________________________________
	151	void SetupTrackCuts(AliDielectron *die, Int_t cutDefinition)
	152	{
	153	//
	154	// Setup the track cuts
	155	//
	156
	157	// Quality cuts
	158	AliDielectronCutGroup* cuts = new AliDielectronCutGroup("cuts","cuts",AliDielectronCutGroup::kCompAND);
	159	die->GetTrackFilter().AddCuts(cuts);
	160
161	// AOD track filter (needs to be first cut to speed up)
162	AliDielectronTrackCuts *trkFilter = new AliDielectronTrackCuts("TrkFilter","TrkFilter");
163	trkFilter->SetAODFilterBit(AliDielectronTrackCuts::kTPCqual);
164	// trkFilter->SetMinNCrossedRowsOverFindable(0.6);
165	if(!isESD) cuts->AddCut(trkFilter);
166
167	//Pt cut, should make execution a bit faster
168	AliDielectronVarCuts *pt = new AliDielectronVarCuts("PtCut","PtCut");
ab5dc7f9	169	pt->AddCut(AliDielectronVarManager::kPt,0.85,1e30); //0.8
15f4cb18	170	cuts->AddCut(pt);
	171
	172	// track cuts ESD and AOD
	173	AliDielectronVarCuts *varCuts = new AliDielectronVarCuts("VarCuts","VarCuts");
	174	varCuts->AddCut(AliDielectronVarManager::kImpactParXY, -1.0, 1.0);
	175	varCuts->AddCut(AliDielectronVarManager::kImpactParZ, -3.0, 3.0);
	176	varCuts->AddCut(AliDielectronVarManager::kEta, -0.9, 0.9); // -0.9, 0.9
	177	varCuts->AddCut(AliDielectronVarManager::kTPCchi2Cl, 0.0, 4.0);
	178	varCuts->AddCut(AliDielectronVarManager::kNclsTPC, 70.0, 160.0);
	179	varCuts->AddCut(AliDielectronVarManager::kKinkIndex0, 0.0);
	180	varCuts->AddCut(AliDielectronVarManager::kTOFbeta, 0.2, 0.9, kTRUE);
	181	cuts->AddCut(varCuts);
	182	varCuts->Print();
	183
	184	AliDielectronTrackCuts *trkCuts = new AliDielectronTrackCuts("TrkCuts","TrkCuts");
	185	trkCuts->SetITSclusterCut(AliDielectronTrackCuts::kOneOf, 3); // ITS-4 = 1+2+4+8
	186	trkCuts->SetRequireITSRefit(kTRUE);
	187	trkCuts->SetRequireTPCRefit(kTRUE);
	188	cuts->AddCut(trkCuts);
	189
	190	/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv PID CUTS vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
	191	AliDielectronPID *pid = new AliDielectronPID("PID","PID");
	192	pid->AddCut(AliDielectronPID::kTPC,AliPID::kPion,-100.,4.0,0.,0.,kTRUE);
	193	pid->AddCut(AliDielectronPID::kTPC,AliPID::kProton,-100.,3.5,0.,0.,kTRUE);
	194	pid->AddCut(AliDielectronPID::kTPC,AliPID::kElectron,-4.,4.);
	195	pid->AddCut(AliDielectronPID::kTOF,AliPID::kElectron,-3,3.,0.,0.,kFALSE,AliDielectronPID::kIfAvailable);
	196	cuts->AddCut(pid);
	197	/* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PID CUTS ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
	198
	199	// exclude conversion electrons selected by the tender
	200	AliDielectronTrackCuts *noconv=new AliDielectronTrackCuts("noConv","noConv");
	201	noconv->SetV0DaughterCut(AliPID::kElectron,kTRUE);
	202	// cuts->AddCut(noconv);
	203
	204	}
	205
	206	//______________________________________________________________________________________
	207	void SetupPairCuts(AliDielectron *die, Int_t cutDefinition)
	208	{
	209	//
	210	// Setup the pair cuts
	211	//
	212
	213	// conversion rejection
	214	Double_t gCut = 0.05;
	215	AliDielectronVarCuts *gammaCuts = new AliDielectronVarCuts("GammaCuts","GammaCuts");
	216	// gammaCuts->AddCut(AliDielectronVarManager::kOpeningAngle, 0.0, 0.1, kTRUE);
	217	// gammaCuts->AddCut(AliDielectronVarManager::kLegDist, 0.0, 0.25, kTRUE);
	218	// gammaCuts->AddCut(AliDielectronVarManager::kR, 3.0, 90.0, kTRUE);
	219	// gammaCuts->AddCut(AliDielectronVarManager::kPsiPair, 0.0, 0.05, kTRUE);
	220	// gammaCuts->AddCut(AliDielectronVarManager::kChi2NDF, 0.0, 10.0, kTRUE);
	221	gammaCuts->AddCut(AliDielectronVarManager::kM, 0.0, gCut);
	222	die->GetPairPreFilter().AddCuts(gammaCuts);
	223
	224	// rapidity selection
	225	// AliDielectronVarCuts *rapCut=new AliDielectronVarCuts("\|Y\|<.9","\|Y\|<.9");
	226	// rapCut->AddCut(AliDielectronVarManager::kY,-0.9,0.9);
	227	// die->GetPairFilter().AddCuts(rapCut);
	228
	229	}
	230
	231	//______________________________________________________________________________________
	232	void ConfigBgrd(AliDielectron *die, Int_t cutDefinition)
	233	{
234	//
235	// Configurate the background estimators
236	//
237
238	// add mixed events
239	AliDielectronMixingHandler *mix=new AliDielectronMixingHandler;
240
241	// mixing handler
242	switch(cutDefinition) {
243	case kNoBins: /* */ break;
244	case kZvtx:
1c96a71e	245	case kZvtxNoKF:
15f4cb18	246	mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
	247	break;
	248	case kZvtxCent:
	249	mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
	250	mix->AddVariable(AliDielectronVarManager::kCentrality, 8, 0.,80.);
	251	break;
	252	case kZvtxNcontrPEepTPCmag:
ab5dc7f9	253	mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
	254	mix->AddVariable(AliDielectronVarManager::kNVtxContrib, 32, 0.,3200.);
	255	mix->AddVariable(AliDielectronVarManager::kTPCrpH2, 8, TMath::Pi()/-2., TMath::Pi()/2.);
15f4cb18	256	mix->AddVariable(AliDielectronVarManager::kTPCmagH2, "0.,20.,50.,80.,110.,150.,500.");
ab5dc7f9	257	break;
15f4cb18	258	case kZvtxNcontrPEepTPC:
ab5dc7f9	259	mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
ab5dc7f9	260	mix->AddVariable(AliDielectronVarManager::kNVtxContrib, 32, 0.,3200.);
15f4cb18	261	mix->AddVariable(AliDielectronVarManager::kTPCrpH2, 8, TMath::Pi()/-2., TMath::Pi()/2.);
ab5dc7f9	262	break;
15f4cb18	263	case kZvtxNcontrPE:
15f4cb18	264	case kZvtxNcontr:
ab5dc7f9	265	mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
15f4cb18	266	mix->AddVariable(AliDielectronVarManager::kNVtxContrib, 32, 0.,3200.);
ab5dc7f9	267	break;
ab5dc7f9	268	case kZvtxepTPC:
15f4cb18	269	mix->AddVariable(AliDielectronVarManager::kZvPrim, "-10.,-5.,-4.,-3.,-2.,-1.,0.,1.,2.,3.,4.,5.,10.");
ab5dc7f9	270	mix->AddVariable(AliDielectronVarManager::kTPCrpH2, 8, TMath::Pi()/-2., TMath::Pi()/2.);
ab5dc7f9	271	mix->AddVariable(AliDielectronVarManager::kTPCmagH2, "0.,20.,50.,80.,110.,150.,500.");
15f4cb18	272	break;
	273	}
	274	mix->SetMixType(AliDielectronMixingHandler::kOSonly);
	275	mix->SetDepth(150);
	276	mix->Print();
	277
	278	die->SetMixingHandler(mix);
	279	}
	280
	281	//______________________________________________________________________________________
	282	void ConfigEvtPlane(AliDielectron *die, Int_t cutDefinition)
	283	{
	284	//
	285	// Configurate the TPC event plane
	286	//
	287
ab5dc7f9	288	if(cutDefinition!=kZvtxNcontrPEepTPC && cutDefinition!=kZvtxNcontrPEepTPCmag && cutDefinition!=kZvtxepTPC ) return;
15f4cb18	289
	290	Double_t gGap = 0.0;
	291	AliDielectronVarCuts *poi = new AliDielectronVarCuts("PoI","PoI");
	292	poi->AddCut(AliDielectronVarManager::kM,2.92,3.20); // particles of interest, jpsi mass window
	293	die->GetEventPlanePOIPreFilter().AddCuts(poi);
	294
	295	// eta gap in tpc event plane
	296	//AliDielectronVarCuts *etaGap = new AliDielectronVarCuts(AliDielectronVarManager::GetValueName(AliDielectronVarManager::kEta),"etaGap");
	297	//etaGap->AddCut(AliDielectronVarManager::kEta,-1*gGap,gGap,kTRUE);
	298	//die->GetEventPlanePreFilter().AddCuts(etaGap);
	299	//if(cutDefinition==kSubLS) die->SetLikeSignSubEvents();
	300
	301	die->SetPreFilterEventPlane();
	302	}
	303
	304	//______________________________________________________________________________________
	305	void InitHistograms(AliDielectron *die, Int_t cutDefinition)
	306	{
	307	//
	308	// Initialise the histograms
	309	//
	310
	311	//Setup histogram Manager
	312	AliDielectronHistos *histos=new AliDielectronHistos(die->GetName(),die->GetTitle());
	313
	314	//add histograms to event class
	315	histos->AddClass("Event");
	316
	317
	318	switch(cutDefinition) {
	319	case kNoBins: /* */ break;
	320	case kZvtxCent:
	321	histos->UserHistogram("Event","","", 200,-10., 10., AliDielectronVarManager::kZvPrim);
	322	histos->UserHistogram("Event","","", 100, 0.0, 100.0, AliDielectronVarManager::kCentrality);
	323	break;
	324	case kZvtxNcontrPEepTPCmag:
	325	histos->UserHistogram("Event","","", 250, 0., 500., AliDielectronVarManager::kTPCmagH2);
	326	case kZvtxNcontrPEepTPC:
	327	histos->UserHistogram("Event","","", 16, TMath::Pi()/-2., TMath::Pi()/2., AliDielectronVarManager::kTPCrpH2);
	328	case kZvtxNcontrPE:
	329	case kZvtxNcontr:
	330	histos->UserHistogram("Event","","", 200, 0., 4000., AliDielectronVarManager::kNVtxContrib);
	331	case kZvtx:
1c96a71e	332	case kZvtxNoKF:
15f4cb18	333	histos->UserHistogram("Event","","", 200,-10., 10., AliDielectronVarManager::kZvPrim);
15f4cb18	334	break;
ab5dc7f9	335	case kZvtxepTPC:
	336	histos->UserHistogram("Event","","", 200,-10., 10., AliDielectronVarManager::kZvPrim);
	337	histos->UserHistogram("Event","","", 250, 0., 500., AliDielectronVarManager::kTPCmagH2);
	338	histos->UserHistogram("Event","","", 16, TMath::Pi()/-2., TMath::Pi()/2., AliDielectronVarManager::kTPCrpH2);
	339	break;
15f4cb18	340	}
	341
	342	//Initialise histogram classes
	343	histos->SetReservedWords("Pair");
	344	//Pair classes inclusive mixed events
	345	histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(0)));
	346	histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(1)));
	347	histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(2)));
	348	histos->AddClass(Form("Pair_%s",AliDielectron::PairClassName(4)));
	349
	350	///// add histograms to Pair classes /////
1c96a71e	351	histos->UserHistogram("Pair","","", 300,.0,300*0.04, 80,0.,80.,
	352	AliDielectronVarManager::kM, AliDielectronVarManager::kCentrality); // 40MeV bins, 12GeV/c2
	353	histos->UserHistogram("Pair","","", 300,.0,300*0.04, 20,0.,20.,
	354	AliDielectronVarManager::kM, AliDielectronVarManager::kPt); // 40MeV bins, 12GeV/c2
	355
15f4cb18	356	histos->UserHistogram("Pair","","", 100,-1.,1., AliDielectronVarManager::kY);
15f4cb18	357	histos->UserHistogram("Pair","","", 400,0,20., AliDielectronVarManager::kPt);
ab5dc7f9	358	histos->UserHistogram("Pair","","", 125,0,0.04*125, AliDielectronVarManager::kM);
	359
	360	Int_t maxMixBins = die->GetMixingHandler()->GetNumberOfBins();
	361	TObjArray *limits = new TObjArray();
	362	limits->Add(AliDielectronHelper::MakeLinBinning(125, 0., 5.));
	363	limits->Add(AliDielectronHelper::MakeLinBinning( 32, 0., 80.));
	364	limits->Add(AliDielectronHelper::MakeLinBinning( 20, 0., 20.));
	365	limits->Add(AliDielectronHelper::MakeLinBinning(maxMixBins, 0., maxMixBins));
	366
	367	UInt_t vars[4]={AliDielectronVarManager::kM,
	368	AliDielectronVarManager::kCentrality,
	369	AliDielectronVarManager::kPt,
	370	AliDielectronVarManager::kMixingBin };
	371	histos->UserSparse("Pair", 4, limits, vars);
	372
15f4cb18	373
	374
	375	//legs from pair (fill SE)
	376	// for (Int_t i=0; i<3; ++i){
	377	// histos->AddClass(Form("Track_Legs_%s",AliDielectron::PairClassName(i)));
	378	// }
	379	//Track classes
	380	//to fill also track info from 2nd event loop until 2
	381	//for (Int_t i=0; i<2; ++i){
	382	// histos->AddClass(Form("Track_%s",AliDielectron::TrackClassName(i)));
	383	//}
	384
	385
	386	die->SetHistogramManager(histos);
	387	}
ab5dc7f9	388	void InitHF(AliDielectron* die, Int_t cutDefinition)
	389	{
	390	//
	391	// Setup the HF arrays
	392	//
	393
	394
	395	AliDielectronHF *hf=new AliDielectronHF(die->GetName(),die->GetTitle());
	396	// if(hasMC) hf->SetStepForMCGenerated();
	397	hf->SetPairTypes(AliDielectronHF::kAll);
	398	hf->SetVariable(AliDielectronVarManager::kM, 125, 0.0, 0.04*125);
	399	hf->AddCutVariable(AliDielectronVarManager::kCentrality, "0.,80.");
	400	die->SetHistogramArray(hf);
	401	}
	402