[u/mrichter/AliRoot.git] / PWGDQ / dielectron / AliDielectronEventCuts.cxx

/*************************************************************************
* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/

///////////////////////////////////////////////////////////////////////////
//                Dielectron EventCuts                                  //
//                                                                       //
//                                                                       //
/*
Detailed description


*/
//                                                                       //
///////////////////////////////////////////////////////////////////////////


#include <AliTriggerAnalysis.h>
#include <AliESDVertex.h>
#include <AliAODVertex.h>
#include <AliESDEvent.h>
#include <AliAODEvent.h>
#include <AliMultiplicity.h>
#include <AliCentrality.h>

#include "AliDielectronEventCuts.h"

ClassImp(AliDielectronEventCuts)

AliDielectronEventCuts::AliDielectronEventCuts() :
  AliAnalysisCuts(),
  fVtxZmin(0.),
  fVtxZmax(0.),
  fRequireVtx(kFALSE),
  fMinVtxContributors(0),
  fMultITSTPC(kFALSE),
  fCentMin(1.),
  fCentMax(0.),
  fVtxType(kVtxTracks),
  fRequireV0and(0),
  fTriggerAnalysis(0x0),
  fkVertex(0x0),
  fkVertexAOD(0x0)
{
  //
  // Default Constructor
  //
  
}

//______________________________________________
AliDielectronEventCuts::AliDielectronEventCuts(const char* name, const char* title) :
  AliAnalysisCuts(name, title),
  fVtxZmin(0.),
  fVtxZmax(0.),
  fRequireVtx(kFALSE),
  fMinVtxContributors(0),
  fMultITSTPC(kFALSE),
  fCentMin(1.),
  fCentMax(0.),
  fVtxType(kVtxTracks),
  fRequireV0and(0),
  fTriggerAnalysis(0x0),
  fkVertex(0x0),
  fkVertexAOD(0x0)
{
  //
  // Named Constructor
  //
}

//______________________________________________
AliDielectronEventCuts::~AliDielectronEventCuts()
{
  //
  // Default Destructor
  //
  if (fTriggerAnalysis) delete fTriggerAnalysis;
}

//______________________________________________
Bool_t AliDielectronEventCuts::IsSelected(TObject* event)
{
  //
  // check the cuts
  //
  
  if(event->IsA() == AliESDEvent::Class()) return IsSelectedESD(event);
  else if(event->IsA() == AliAODEvent::Class()) return IsSelectedAOD(event);
  else return kFALSE;
}
//____________________________________________________________________
Bool_t AliDielectronEventCuts::IsSelectedESD(TObject* event)
{
  //
  // check the cuts
  //
  
  AliESDEvent *ev=dynamic_cast<AliESDEvent*>(event);
  if (!ev) return kFALSE;

  if (fCentMin<fCentMax){
    AliCentrality *centrality=ev->GetCentrality();
    Double_t centralityF=-1;
    if (centrality) centralityF = centrality->GetCentralityPercentile("V0M");
    if (centralityF<fCentMin || centralityF>=fCentMax) return kFALSE;
  }

  fkVertex=0x0;

  switch(fVtxType){
  case kVtxTracks:
  case kVtxTracksOrSPD:
    fkVertex=ev->GetPrimaryVertexTracks();
    break;
  case kVtxSPD:    fkVertex=ev->GetPrimaryVertexSPD(); break;
  case kVtxTPC:    fkVertex=ev->GetPrimaryVertexTPC(); break;
  case kVtxAny:    fkVertex=ev->GetPrimaryVertex(); break;
  }

  if ((fRequireVtx||fVtxZmin<fVtxZmax||fMinVtxContributors>0)&&!fkVertex) return kFALSE;
  

  if (fMinVtxContributors>0){
    Int_t nCtrb = fkVertex->GetNContributors();
    if (nCtrb<fMinVtxContributors){
      if (fVtxType==kVtxTracksOrSPD){
        fkVertex=ev->GetPrimaryVertexSPD();
        nCtrb = fkVertex->GetNContributors();
        if (nCtrb<fMinVtxContributors) return kFALSE;
      } else {
        return kFALSE;
      }
    }
  }

  if (fVtxZmin<fVtxZmax){
    Double_t zvtx=fkVertex->GetZv();
    if (zvtx<fVtxZmin||zvtx>fVtxZmax) return kFALSE;
  }
  
  if (fRequireV0and){
    if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
    Bool_t v0AND = kFALSE;
    if (fRequireV0and==1){
      Bool_t v0A       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0A);
      Bool_t v0C       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0C);
      v0AND = v0A && v0C;
    }

    if (fRequireV0and==2){
      Bool_t v0AHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kASide, kTRUE) == AliTriggerAnalysis::kV0BB);
      Bool_t v0CHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kCSide, kTRUE) == AliTriggerAnalysis::kV0BB);
      v0AND = v0AHW && v0CHW;
    }

    if (!v0AND) return kFALSE;
  }

  if (fMultITSTPC){
    const AliESDVertex *vtxESDTPC=ev->GetPrimaryVertexTPC();
    const AliMultiplicity *multESD = ev->GetMultiplicity();
    if ( vtxESDTPC && multESD && vtxESDTPC->GetNContributors() < (-10.+0.25*multESD->GetNumberOfITSClusters(0)) )
      return kFALSE;
  }

  
  return kTRUE;
}
//______________________________________________
Bool_t AliDielectronEventCuts::IsSelectedAOD(TObject* event)
{
  //
  // check the cuts
  //
  
  AliAODEvent *ev=dynamic_cast<AliAODEvent*>(event);
  if (!ev) return kFALSE;

  if (fCentMin<fCentMax){
    AliCentrality *centrality=ev->GetCentrality();
    Double_t centralityF=-1;
    if (centrality) centralityF = centrality->GetCentralityPercentile("V0M");
    if (centralityF<fCentMin || centralityF>=fCentMax) return kFALSE;
  }

  fkVertexAOD=0x0;

  switch(fVtxType){
  case kVtxTracks:
    fkVertexAOD=0x0;
    break;
  case kVtxTPC:            fkVertexAOD=GetPrimaryVertexTPC(ev); 
    break;
  case kVtxSPD:
  case kVtxTracksOrSPD:    fkVertexAOD=ev->GetPrimaryVertexSPD();
    break;
  case kVtxAny:            fkVertexAOD=ev->GetPrimaryVertex();
    break;
  }

  if ((fRequireVtx||fVtxZmin<fVtxZmax||fMinVtxContributors>0)&&!fkVertexAOD) return kFALSE;
  
  if (fMinVtxContributors>0){
    Int_t nCtrb = fkVertexAOD->GetNContributors();
    if (nCtrb<fMinVtxContributors){
      // if (fVtxType==kVtxTracksOrSPD){
      //   fkVertexAOD=ev->GetVertex(AliAODVertex::kPrimary);
      //   nCtrb = fkVertexAOD->GetNContributors();
      //   if (nCtrb<fMinVtxContributors) return kFALSE;
      //      } else {
      return kFALSE;
      //}
    }
  }
  

  if (fVtxZmin<fVtxZmax){
    Double_t zvtx=fkVertexAOD->GetZ();
    if (zvtx<fVtxZmin||zvtx>fVtxZmax) return kFALSE;
  }

  /*
  if (fRequireV0and){
    //    if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
    Bool_t v0AND = kFALSE;
    if (fRequireV0and==1){
      Bool_t v0A       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0A);
      Bool_t v0A       = header->GetOfflineTrigger(); //TODO
      Bool_t v0C       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0C);
      v0AND = v0A && v0C;
    }

    if (fRequireV0and==2){
      Bool_t v0AHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kASide, kTRUE) == AliTriggerAnalysis::kV0BB);
      Bool_t v0CHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kCSide, kTRUE) == AliTriggerAnalysis::kV0BB);
      v0AND = v0AHW && v0CHW;
    }

    if (!v0AND) return kFALSE;
  }
  */
  /*  if (fMultITSTPC){
    const AliESDVertex *vtxESDTPC=ev->GetPrimaryVertexTPC();
    const AliMultiplicity *multESD = ev->GetMultiplicity();
    if ( vtxESDTPC && multESD && vtxESDTPC->GetNContributors() < (-10.+0.25*multESD->GetNumberOfITSClusters(0)) )
      return kFALSE;
  }
  */
  
  return kTRUE;
}
Commit	Line	Data
2a14a7b1	1	/*************************************************************************
	2	* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	///////////////////////////////////////////////////////////////////////////
	17	// Dielectron EventCuts //
	18	// //
	19	// //
	20	/*
	21	Detailed description
	22
	23
	24	*/
	25	// //
	26	///////////////////////////////////////////////////////////////////////////
	27
5720c765	28
2a14a7b1	29	#include <AliTriggerAnalysis.h>
2a14a7b1	30	#include <AliESDVertex.h>
d327d9cd	31	#include <AliAODVertex.h>
2a14a7b1	32	#include <AliESDEvent.h>
d327d9cd	33	#include <AliAODEvent.h>
ffbede40	34	#include <AliMultiplicity.h>
ba15fdfb	35	#include <AliCentrality.h>
2a14a7b1	36
	37	#include "AliDielectronEventCuts.h"
	38
	39	ClassImp(AliDielectronEventCuts)
	40
	41	AliDielectronEventCuts::AliDielectronEventCuts() :
	42	AliAnalysisCuts(),
	43	fVtxZmin(0.),
	44	fVtxZmax(0.),
	45	fRequireVtx(kFALSE),
	46	fMinVtxContributors(0),
ffbede40	47	fMultITSTPC(kFALSE),
ba15fdfb	48	fCentMin(1.),
ba15fdfb	49	fCentMax(0.),
2a14a7b1	50	fVtxType(kVtxTracks),
	51	fRequireV0and(0),
	52	fTriggerAnalysis(0x0),
d327d9cd	53	fkVertex(0x0),
d327d9cd	54	fkVertexAOD(0x0)
2a14a7b1	55	{
	56	//
	57	// Default Constructor
	58	//
	59
	60	}
	61
	62	//______________________________________________
	63	AliDielectronEventCuts::AliDielectronEventCuts(const char* name, const char* title) :
	64	AliAnalysisCuts(name, title),
	65	fVtxZmin(0.),
	66	fVtxZmax(0.),
	67	fRequireVtx(kFALSE),
	68	fMinVtxContributors(0),
ffbede40	69	fMultITSTPC(kFALSE),
ba15fdfb	70	fCentMin(1.),
ba15fdfb	71	fCentMax(0.),
2a14a7b1	72	fVtxType(kVtxTracks),
	73	fRequireV0and(0),
	74	fTriggerAnalysis(0x0),
d327d9cd	75	fkVertex(0x0),
d327d9cd	76	fkVertexAOD(0x0)
2a14a7b1	77	{
	78	//
	79	// Named Constructor
	80	//
	81	}
	82
	83	//______________________________________________
	84	AliDielectronEventCuts::~AliDielectronEventCuts()
	85	{
	86	//
	87	// Default Destructor
	88	//
	89	if (fTriggerAnalysis) delete fTriggerAnalysis;
	90	}
	91
	92	//______________________________________________
	93	Bool_t AliDielectronEventCuts::IsSelected(TObject* event)
	94	{
	95	//
	96	// check the cuts
	97	//
	98
d327d9cd	99	if(event->IsA() == AliESDEvent::Class()) return IsSelectedESD(event);
	100	else if(event->IsA() == AliAODEvent::Class()) return IsSelectedAOD(event);
	101	else return kFALSE;
	102	}
	103	//____________________________________________________________________
	104	Bool_t AliDielectronEventCuts::IsSelectedESD(TObject* event)
	105	{
	106	//
	107	// check the cuts
	108	//
	109
2a14a7b1	110	AliESDEvent ev=dynamic_cast<AliESDEvent>(event);
	111	if (!ev) return kFALSE;
	112
ba15fdfb	113	if (fCentMin<fCentMax){
	114	AliCentrality *centrality=ev->GetCentrality();
	115	Double_t centralityF=-1;
	116	if (centrality) centralityF = centrality->GetCentralityPercentile("V0M");
	117	if (centralityF<fCentMin \|\| centralityF>=fCentMax) return kFALSE;
	118	}
	119
2a14a7b1	120	fkVertex=0x0;
5720c765	121
2a14a7b1	122	switch(fVtxType){
1201a1a9	123	case kVtxTracks:
	124	case kVtxTracksOrSPD:
	125	fkVertex=ev->GetPrimaryVertexTracks();
	126	break;
2a14a7b1	127	case kVtxSPD: fkVertex=ev->GetPrimaryVertexSPD(); break;
	128	case kVtxTPC: fkVertex=ev->GetPrimaryVertexTPC(); break;
	129	case kVtxAny: fkVertex=ev->GetPrimaryVertex(); break;
	130	}
	131
	132	if ((fRequireVtx\|\|fVtxZmin<fVtxZmax\|\|fMinVtxContributors>0)&&!fkVertex) return kFALSE;
	133
2a14a7b1	134
	135	if (fMinVtxContributors>0){
	136	Int_t nCtrb = fkVertex->GetNContributors();
ba15fdfb	137	if (nCtrb<fMinVtxContributors){
	138	if (fVtxType==kVtxTracksOrSPD){
	139	fkVertex=ev->GetPrimaryVertexSPD();
	140	nCtrb = fkVertex->GetNContributors();
	141	if (nCtrb<fMinVtxContributors) return kFALSE;
	142	} else {
	143	return kFALSE;
	144	}
	145	}
2a14a7b1	146	}
2a14a7b1	147
ba15fdfb	148	if (fVtxZmin<fVtxZmax){
	149	Double_t zvtx=fkVertex->GetZv();
	150	if (zvtx<fVtxZmin\|\|zvtx>fVtxZmax) return kFALSE;
	151	}
	152
2a14a7b1	153	if (fRequireV0and){
	154	if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
	155	Bool_t v0AND = kFALSE;
	156	if (fRequireV0and==1){
	157	Bool_t v0A = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0A);
	158	Bool_t v0C = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0C);
	159	v0AND = v0A && v0C;
	160	}
	161
	162	if (fRequireV0and==2){
	163	Bool_t v0AHW = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kASide, kTRUE) == AliTriggerAnalysis::kV0BB);
	164	Bool_t v0CHW = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kCSide, kTRUE) == AliTriggerAnalysis::kV0BB);
	165	v0AND = v0AHW && v0CHW;
	166	}
	167
	168	if (!v0AND) return kFALSE;
	169	}
ffbede40	170
	171	if (fMultITSTPC){
	172	const AliESDVertex *vtxESDTPC=ev->GetPrimaryVertexTPC();
	173	const AliMultiplicity *multESD = ev->GetMultiplicity();
	174	if ( vtxESDTPC && multESD && vtxESDTPC->GetNContributors() < (-10.+0.25*multESD->GetNumberOfITSClusters(0)) )
	175	return kFALSE;
	176	}
ba15fdfb	177
2a14a7b1	178
d327d9cd	179	return kTRUE;
	180	}
	181	//______________________________________________
	182	Bool_t AliDielectronEventCuts::IsSelectedAOD(TObject* event)
	183	{
	184	//
	185	// check the cuts
	186	//
	187
	188	AliAODEvent ev=dynamic_cast<AliAODEvent>(event);
	189	if (!ev) return kFALSE;
	190
	191	if (fCentMin<fCentMax){
	192	AliCentrality *centrality=ev->GetCentrality();
	193	Double_t centralityF=-1;
	194	if (centrality) centralityF = centrality->GetCentralityPercentile("V0M");
	195	if (centralityF<fCentMin \|\| centralityF>=fCentMax) return kFALSE;
	196	}
	197
	198	fkVertexAOD=0x0;
	199
	200	switch(fVtxType){
	201	case kVtxTracks:
d327d9cd	202	fkVertexAOD=0x0;
d327d9cd	203	break;
a823f01b	204	case kVtxTPC: fkVertexAOD=GetPrimaryVertexTPC(ev);
a823f01b	205	break;
d327d9cd	206	case kVtxSPD:
a823f01b	207	case kVtxTracksOrSPD: fkVertexAOD=ev->GetPrimaryVertexSPD();
d327d9cd	208	break;
a823f01b	209	case kVtxAny: fkVertexAOD=ev->GetPrimaryVertex();
d327d9cd	210	break;
	211	}
	212
	213	if ((fRequireVtx\|\|fVtxZmin<fVtxZmax\|\|fMinVtxContributors>0)&&!fkVertexAOD) return kFALSE;
	214
	215	if (fMinVtxContributors>0){
	216	Int_t nCtrb = fkVertexAOD->GetNContributors();
	217	if (nCtrb<fMinVtxContributors){
a823f01b	218	// if (fVtxType==kVtxTracksOrSPD){
	219	// fkVertexAOD=ev->GetVertex(AliAODVertex::kPrimary);
	220	// nCtrb = fkVertexAOD->GetNContributors();
	221	// if (nCtrb<fMinVtxContributors) return kFALSE;
	222	// } else {
	223	return kFALSE;
	224	//}
d327d9cd	225	}
d327d9cd	226	}
a823f01b	227
d327d9cd	228
	229	if (fVtxZmin<fVtxZmax){
	230	Double_t zvtx=fkVertexAOD->GetZ();
	231	if (zvtx<fVtxZmin\|\|zvtx>fVtxZmax) return kFALSE;
	232	}
a823f01b	233
d327d9cd	234	/*
	235	if (fRequireV0and){
	236	// if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
	237	Bool_t v0AND = kFALSE;
	238	if (fRequireV0and==1){
	239	Bool_t v0A = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0A);
	240	Bool_t v0A = header->GetOfflineTrigger(); //TODO
	241	Bool_t v0C = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0C);
	242	v0AND = v0A && v0C;
	243	}
	244
	245	if (fRequireV0and==2){
	246	Bool_t v0AHW = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kASide, kTRUE) == AliTriggerAnalysis::kV0BB);
	247	Bool_t v0CHW = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kCSide, kTRUE) == AliTriggerAnalysis::kV0BB);
	248	v0AND = v0AHW && v0CHW;
	249	}
	250
	251	if (!v0AND) return kFALSE;
	252	}
	253	*/
	254	/* if (fMultITSTPC){
	255	const AliESDVertex *vtxESDTPC=ev->GetPrimaryVertexTPC();
	256	const AliMultiplicity *multESD = ev->GetMultiplicity();
	257	if ( vtxESDTPC && multESD && vtxESDTPC->GetNContributors() < (-10.+0.25*multESD->GetNumberOfITSClusters(0)) )
	258	return kFALSE;
	259	}
	260	*/
	261
2a14a7b1	262	return kTRUE;
	263	}
	264