[u/mrichter/AliRoot.git] / ANALYSIS / ANALYSISalice / AliAnalysisUtils.cxx

#include "AliVEvent.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliVVertex.h"
#include "AliLog.h"
#include "AliAODVertex.h"
#include "AliVTrack.h"
#include "AliVEvent.h"
#include <TMatrixDSym.h>
#include <TMath.h>
#include "AliVMultiplicity.h"
#include "AliPPVsMultUtils.h"

#include "AliAnalysisUtils.h"

ClassImp(AliAnalysisUtils)

//______________________________________________________________________
AliAnalysisUtils::AliAnalysisUtils():TObject(),
  fisAOD(kTRUE),
  fMinVtxContr(0),
  fMaxVtxZ(10.),
  fCutOnZVertexSPD(kTRUE),
  fUseMVPlpSelection(kFALSE),
  fUseOutOfBunchPileUp(kFALSE),
  fMinPlpContribMV(5),
  fMaxPlpChi2MV(5.),
  fMinWDistMV(15.),
  fCheckPlpFromDifferentBCMV(kFALSE),
  fMinPlpContribSPD(5),
  fMinPlpZdistSPD(0.8),
  fnSigmaPlpZdistSPD(3.),
  fnSigmaPlpDiamXYSPD(2.),
  fnSigmaPlpDiamZSPD(5.),
  fUseSPDCutInMultBins(kFALSE),
  fASPDCvsTCut(65.),
  fBSPDCvsTCut(4.),
  fPPVsMultUtils(0x0)
{
  // Default contructor
}

//______________________________________________________________________
Bool_t AliAnalysisUtils::IsVertexSelected2013pA(AliVEvent *event)
{
  Bool_t accept = kFALSE;
  
  // Check whether the event is of AOD or ESD type
  AliAODEvent *aod = 0x0;
  AliESDEvent *esd = 0x0;
  aod = dynamic_cast<AliAODEvent*>(event);
  esd = dynamic_cast<AliESDEvent*>(event);

  if(aod) { 
    fisAOD = kTRUE; 
  } else {
    fisAOD = kFALSE;
    if(!esd) {
      AliFatal("Event is neither of AOD nor ESD type");
      return accept;
    }
  }

  const AliVVertex *trkVtx = fisAOD ? 
    dynamic_cast<const AliVVertex*>(aod->GetPrimaryVertex()) : 
    dynamic_cast<const AliVVertex*>(esd->GetPrimaryVertex()) ;
  if(!trkVtx || trkVtx->GetNContributors()<=fMinVtxContr){
    accept = kFALSE;
    return accept;
  }

  TString vtxTtl = trkVtx->GetTitle();
  if (!vtxTtl.Contains("VertexerTracks")) return accept;

  Float_t zvtx = trkVtx->GetZ();
  const AliVVertex* spdVtx = fisAOD ? 
    dynamic_cast<const AliVVertex*>(aod->GetPrimaryVertexSPD()) : 
    dynamic_cast<const AliVVertex*>(esd->GetPrimaryVertexSPD()) ;
  if (spdVtx->GetNContributors()<=fMinVtxContr) return accept;

  TString vtxTyp = spdVtx->GetTitle();
  Double_t cov[6]={0};
  spdVtx->GetCovarianceMatrix(cov);
  Double_t zRes = TMath::Sqrt(cov[5]);
  if (vtxTyp.Contains("vertexer:Z") && (zRes>0.25)) return accept;
  if (fCutOnZVertexSPD && TMath::Abs(spdVtx->GetZ() - trkVtx->GetZ())>0.5) return accept;

  if (TMath::Abs(zvtx) > fMaxVtxZ) return accept;

  return kTRUE;
}

//______________________________________________________________________
Bool_t AliAnalysisUtils::IsFirstEventInChunk(AliVEvent *event)
{

  Bool_t accept = kFALSE;

  // Check whether the event is of AOD or ESD type
  AliAODEvent *aod = 0x0;
  AliESDEvent *esd = 0x0;
  aod = dynamic_cast<AliAODEvent*>(event);
  esd = dynamic_cast<AliESDEvent*>(event);

  if(aod) { 
    fisAOD = kTRUE; 
  } else {
    fisAOD = kFALSE;
    if(!esd) {
      AliFatal("Event is neither of AOD nor ESD type");
      return accept;
    }
  }

  if(fisAOD){
    AliAODHeader *aodheader = 0x0;
    aodheader = dynamic_cast<AliAODHeader*>(aod->GetHeader());
    if(!aodheader) AliFatal("Not a standard AOD");
    if(!aodheader){
      AliFatal("AOD header not there ?!");
      return kFALSE;
    }
    if(aodheader->GetEventNumberESDFile()==0) accept = kTRUE;
  } else {
    if(esd->GetEventNumberInFile()==0) accept = kTRUE;
  }
  
  return accept;
}

//______________________________________________________________________
Bool_t AliAnalysisUtils::IsPileUpEvent(AliVEvent *event)
{
  Bool_t isPileUp=kFALSE;
  //check for multiple vertices
  if(fUseMVPlpSelection)isPileUp=IsPileUpMV(event);
  else isPileUp=IsPileUpSPD(event);
  //check for different BC 
  if(fUseOutOfBunchPileUp && IsOutOfBunchPileUp(event))isPileUp=kTRUE;
  
  return isPileUp;
}

//______________________________________________________________________
Bool_t AliAnalysisUtils::IsPileUpMV(AliVEvent *event)
{
  // check for multi-vertexer pile-up
  const AliAODEvent *aod = dynamic_cast<const AliAODEvent*>(event);
  const AliESDEvent *esd = dynamic_cast<const AliESDEvent*>(event);
  //
  if (!aod && !esd) {
    AliFatal("Event is neither of AOD nor ESD type");
    return kFALSE;
  }
  //
  const AliVVertex* vtPrm = 0;
  const AliVVertex* vtPlp = 0;
  Int_t nPlp = 0;
  //
  if (aod) {
    if ( !(nPlp=aod->GetNumberOfPileupVerticesTracks()) ) return kFALSE;
    vtPrm = aod->GetPrimaryVertex();
    if (vtPrm == aod->GetPrimaryVertexSPD()) return kTRUE; // there are pile-up vertices but no primary
  }
  else {
    if ( !(nPlp=esd->GetNumberOfPileupVerticesTracks())) return kFALSE;
    vtPrm = esd->GetPrimaryVertexTracks();
    if (((AliESDVertex*)vtPrm)->GetStatus()!=1) return kTRUE; // there are pile-up vertices but no primary
  }
  Int_t bcPrim = vtPrm->GetBC();
  //
  for (Int_t ipl=0;ipl<nPlp;ipl++) {
    vtPlp = aod ? (const AliVVertex*)aod->GetPileupVertexTracks(ipl) : (const AliVVertex*)esd->GetPileupVertexTracks(ipl);
    //
    if (vtPlp->GetNContributors() < fMinPlpContribMV) continue;
    if (vtPlp->GetChi2perNDF() > fMaxPlpChi2MV) continue;
    if(fCheckPlpFromDifferentBCMV)
      {
	Int_t bcPlp = vtPlp->GetBC();
	if (bcPlp!=AliVTrack::kTOFBCNA && TMath::Abs(bcPlp-bcPrim)>2) return kTRUE; // pile-up from other BC
      }
    //
    Double_t wDst = GetWDist(vtPrm,vtPlp);
    if (wDst<fMinWDistMV) continue;
    //
    return kTRUE; // pile-up: well separated vertices
  }
  //
  return kFALSE;
  //
}

//______________________________________________________________________
Bool_t AliAnalysisUtils::IsPileUpSPD(AliVEvent *event)
{
  // check for SPD pile-up
  const AliAODEvent *aod = dynamic_cast<const AliAODEvent*>(event);
  const AliESDEvent *esd = dynamic_cast<const AliESDEvent*>(event);
  //
  if (!aod && !esd) {
    AliFatal("Event is neither of AOD nor ESD type");
    return kFALSE;
  }
  //
  if (aod) return (fUseSPDCutInMultBins)?aod->IsPileupFromSPDInMultBins():aod->IsPileupFromSPD(fMinPlpContribSPD,fMinPlpZdistSPD,fnSigmaPlpZdistSPD,fnSigmaPlpDiamXYSPD,fnSigmaPlpDiamZSPD);
  else return (fUseSPDCutInMultBins)?esd->IsPileupFromSPDInMultBins():esd->IsPileupFromSPD(fMinPlpContribSPD,fMinPlpZdistSPD,fnSigmaPlpZdistSPD,fnSigmaPlpDiamXYSPD,fnSigmaPlpDiamZSPD);
}

//______________________________________________________________________
Bool_t AliAnalysisUtils::IsOutOfBunchPileUp(AliVEvent *event)
{
  // check for SPD pile-up
  const AliAODEvent *aod = dynamic_cast<const AliAODEvent*>(event);
  const AliESDEvent *esd = dynamic_cast<const AliESDEvent*>(event);
  //
  if (!aod && !esd) {
    AliFatal("Event is neither of AOD nor ESD type");
    return kFALSE;
  }
  Int_t bc2 = (aod)?((AliVAODHeader*)aod->GetHeader())->GetIRInt2ClosestInteractionMap():esd->GetHeader()->GetIRInt2ClosestInteractionMap();
  if (bc2 != 0)
    return kTRUE;
  
  Int_t bc1 = (aod)?((AliVAODHeader*)aod->GetHeader())->GetIRInt1ClosestInteractionMap():esd->GetHeader()->GetIRInt1ClosestInteractionMap();
  if (bc1 != 0)
    return kTRUE;
  
  return kFALSE;
}


//______________________________________________________________________
Bool_t AliAnalysisUtils::IsSPDClusterVsTrackletBG(AliVEvent *event){
  Int_t nClustersLayer0 = event->GetNumberOfITSClusters(0);
  Int_t nClustersLayer1 = event->GetNumberOfITSClusters(1);
  Int_t nTracklets      = event->GetMultiplicity()->GetNumberOfTracklets();
  if (nClustersLayer0 + nClustersLayer1 > fASPDCvsTCut + nTracklets*fBSPDCvsTCut) return kTRUE;
  return kFALSE;
}


//______________________________________________________________________
Double_t AliAnalysisUtils::GetWDist(const AliVVertex* v0, const AliVVertex* v1)
{
  // calculate sqrt of weighted distance to other vertex
  if (!v0 || !v1) {
    printf("One of vertices is not valid\n");
    return 0;
  }
  static TMatrixDSym vVb(3);
  Double_t dist = -1;
  Double_t dx = v0->GetX()-v1->GetX();
  Double_t dy = v0->GetY()-v1->GetY();
  Double_t dz = v0->GetZ()-v1->GetZ();
  Double_t cov0[6],cov1[6];
  v0->GetCovarianceMatrix(cov0);
  v1->GetCovarianceMatrix(cov1);
  vVb(0,0) = cov0[0]+cov1[0];
  vVb(1,1) = cov0[2]+cov1[2];
  vVb(2,2) = cov0[5]+cov1[5];
  vVb(1,0) = vVb(0,1) = cov0[1]+cov1[1];
  vVb(0,2) = vVb(1,2) = vVb(2,0) = vVb(2,1) = 0.;
  vVb.InvertFast();
  if (!vVb.IsValid()) {printf("Singular Matrix\n"); return dist;}
  dist = vVb(0,0)*dx*dx + vVb(1,1)*dy*dy + vVb(2,2)*dz*dz
    +    2*vVb(0,1)*dx*dy + 2*vVb(0,2)*dx*dz + 2*vVb(1,2)*dy*dz;
  return dist>0 ? TMath::Sqrt(dist) : -1; 

}

//______________________________________________________________________
Float_t AliAnalysisUtils::GetMultiplicityPercentile(AliVEvent *event, TString lMethod ){
  if(!fPPVsMultUtils)
    fPPVsMultUtils=new AliPPVsMultUtils();
  if( (event->InheritsFrom("AliAODEvent")) || (event->InheritsFrom("AliESDEvent")) ) return fPPVsMultUtils->GetMultiplicityPercentile(event,lMethod);
  else {
    AliFatal("Event is neither of AOD nor ESD type"); 
    return -999.;
  }
}
Commit	Line	Data
77c42b43	1	#include "AliVEvent.h"
	2	#include "AliESDEvent.h"
	3	#include "AliAODEvent.h"
	4	#include "AliVVertex.h"
	5	#include "AliLog.h"
	6	#include "AliAODVertex.h"
c9df49b3	7	#include "AliVTrack.h"
	8	#include "AliVEvent.h"
	9	#include <TMatrixDSym.h>
	10	#include <TMath.h>
8c379b7c	11	#include "AliVMultiplicity.h"
beb31786	12	#include "AliPPVsMultUtils.h"
77c42b43	13
	14	#include "AliAnalysisUtils.h"
	15
	16	ClassImp(AliAnalysisUtils)
	17
	18	//______________________________________________________________________
	19	AliAnalysisUtils::AliAnalysisUtils():TObject(),
	20	fisAOD(kTRUE),
	21	fMinVtxContr(0),
	22	fMaxVtxZ(10.),
c9df49b3	23	fCutOnZVertexSPD(kTRUE),
	24	fUseMVPlpSelection(kFALSE),
	25	fUseOutOfBunchPileUp(kFALSE),
	26	fMinPlpContribMV(5),
	27	fMaxPlpChi2MV(5.),
	28	fMinWDistMV(15.),
	29	fCheckPlpFromDifferentBCMV(kFALSE),
	30	fMinPlpContribSPD(5),
	31	fMinPlpZdistSPD(0.8),
	32	fnSigmaPlpZdistSPD(3.),
	33	fnSigmaPlpDiamXYSPD(2.),
	34	fnSigmaPlpDiamZSPD(5.),
8c379b7c	35	fUseSPDCutInMultBins(kFALSE),
8c379b7c	36	fASPDCvsTCut(65.),
beb31786	37	fBSPDCvsTCut(4.),
beb31786	38	fPPVsMultUtils(0x0)
77c42b43	39	{
	40	// Default contructor
	41	}
	42
	43	//______________________________________________________________________
	44	Bool_t AliAnalysisUtils::IsVertexSelected2013pA(AliVEvent *event)
	45	{
	46	Bool_t accept = kFALSE;
c9df49b3	47
77c42b43	48	// Check whether the event is of AOD or ESD type
	49	AliAODEvent *aod = 0x0;
	50	AliESDEvent *esd = 0x0;
	51	aod = dynamic_cast<AliAODEvent*>(event);
	52	esd = dynamic_cast<AliESDEvent*>(event);
	53
	54	if(aod) {
	55	fisAOD = kTRUE;
	56	} else {
	57	fisAOD = kFALSE;
	58	if(!esd) {
	59	AliFatal("Event is neither of AOD nor ESD type");
	60	return accept;
	61	}
	62	}
	63
	64	const AliVVertex *trkVtx = fisAOD ?
	65	dynamic_cast<const AliVVertex*>(aod->GetPrimaryVertex()) :
	66	dynamic_cast<const AliVVertex*>(esd->GetPrimaryVertex()) ;
	67	if(!trkVtx \|\| trkVtx->GetNContributors()<=fMinVtxContr){
	68	accept = kFALSE;
	69	return accept;
	70	}
	71
	72	TString vtxTtl = trkVtx->GetTitle();
	73	if (!vtxTtl.Contains("VertexerTracks")) return accept;
	74
	75	Float_t zvtx = trkVtx->GetZ();
	76	const AliVVertex* spdVtx = fisAOD ?
	77	dynamic_cast<const AliVVertex*>(aod->GetPrimaryVertexSPD()) :
	78	dynamic_cast<const AliVVertex*>(esd->GetPrimaryVertexSPD()) ;
	79	if (spdVtx->GetNContributors()<=fMinVtxContr) return accept;
	80
	81	TString vtxTyp = spdVtx->GetTitle();
	82	Double_t cov[6]={0};
	83	spdVtx->GetCovarianceMatrix(cov);
	84	Double_t zRes = TMath::Sqrt(cov[5]);
	85	if (vtxTyp.Contains("vertexer:Z") && (zRes>0.25)) return accept;
	86	if (fCutOnZVertexSPD && TMath::Abs(spdVtx->GetZ() - trkVtx->GetZ())>0.5) return accept;
	87
	88	if (TMath::Abs(zvtx) > fMaxVtxZ) return accept;
	89
	90	return kTRUE;
	91	}
	92
	93	//______________________________________________________________________
	94	Bool_t AliAnalysisUtils::IsFirstEventInChunk(AliVEvent *event)
	95	{
	96
	97	Bool_t accept = kFALSE;
	98
	99	// Check whether the event is of AOD or ESD type
	100	AliAODEvent *aod = 0x0;
	101	AliESDEvent *esd = 0x0;
	102	aod = dynamic_cast<AliAODEvent*>(event);
	103	esd = dynamic_cast<AliESDEvent*>(event);
	104
	105	if(aod) {
	106	fisAOD = kTRUE;
	107	} else {
	108	fisAOD = kFALSE;
	109	if(!esd) {
	110	AliFatal("Event is neither of AOD nor ESD type");
	111	return accept;
112	}
113	}
114
115	if(fisAOD){
116	AliAODHeader *aodheader = 0x0;
0a918d8d	117	aodheader = dynamic_cast<AliAODHeader*>(aod->GetHeader());
0a918d8d	118	if(!aodheader) AliFatal("Not a standard AOD");
77c42b43	119	if(!aodheader){
	120	AliFatal("AOD header not there ?!");
	121	return kFALSE;
	122	}
	123	if(aodheader->GetEventNumberESDFile()==0) accept = kTRUE;
	124	} else {
	125	if(esd->GetEventNumberInFile()==0) accept = kTRUE;
	126	}
c9df49b3	127
77c42b43	128	return accept;
77c42b43	129	}
c9df49b3	130
	131	//______________________________________________________________________
	132	Bool_t AliAnalysisUtils::IsPileUpEvent(AliVEvent *event)
	133	{
	134	Bool_t isPileUp=kFALSE;
	135	//check for multiple vertices
	136	if(fUseMVPlpSelection)isPileUp=IsPileUpMV(event);
	137	else isPileUp=IsPileUpSPD(event);
	138	//check for different BC
	139	if(fUseOutOfBunchPileUp && IsOutOfBunchPileUp(event))isPileUp=kTRUE;
	140
	141	return isPileUp;
	142	}
	143
	144	//______________________________________________________________________
	145	Bool_t AliAnalysisUtils::IsPileUpMV(AliVEvent *event)
	146	{
	147	// check for multi-vertexer pile-up
	148	const AliAODEvent aod = dynamic_cast<const AliAODEvent>(event);
	149	const AliESDEvent esd = dynamic_cast<const AliESDEvent>(event);
	150	//
	151	if (!aod && !esd) {
	152	AliFatal("Event is neither of AOD nor ESD type");
	153	return kFALSE;
	154	}
	155	//
	156	const AliVVertex* vtPrm = 0;
	157	const AliVVertex* vtPlp = 0;
	158	Int_t nPlp = 0;
	159	//
	160	if (aod) {
	161	if ( !(nPlp=aod->GetNumberOfPileupVerticesTracks()) ) return kFALSE;
	162	vtPrm = aod->GetPrimaryVertex();
	163	if (vtPrm == aod->GetPrimaryVertexSPD()) return kTRUE; // there are pile-up vertices but no primary
	164	}
	165	else {
	166	if ( !(nPlp=esd->GetNumberOfPileupVerticesTracks())) return kFALSE;
	167	vtPrm = esd->GetPrimaryVertexTracks();
	168	if (((AliESDVertex*)vtPrm)->GetStatus()!=1) return kTRUE; // there are pile-up vertices but no primary
	169	}
	170	Int_t bcPrim = vtPrm->GetBC();
	171	//
	172	for (Int_t ipl=0;ipl<nPlp;ipl++) {
	173	vtPlp = aod ? (const AliVVertex)aod->GetPileupVertexTracks(ipl) : (const AliVVertex)esd->GetPileupVertexTracks(ipl);
	174	//
	175	if (vtPlp->GetNContributors() < fMinPlpContribMV) continue;
	176	if (vtPlp->GetChi2perNDF() > fMaxPlpChi2MV) continue;
	177	if(fCheckPlpFromDifferentBCMV)
	178	{
	179	Int_t bcPlp = vtPlp->GetBC();
	180	if (bcPlp!=AliVTrack::kTOFBCNA && TMath::Abs(bcPlp-bcPrim)>2) return kTRUE; // pile-up from other BC
	181	}
	182	//
	183	Double_t wDst = GetWDist(vtPrm,vtPlp);
	184	if (wDst<fMinWDistMV) continue;
	185	//
	186	return kTRUE; // pile-up: well separated vertices
	187	}
	188	//
	189	return kFALSE;
	190	//
	191	}
	192
	193	//______________________________________________________________________
194	Bool_t AliAnalysisUtils::IsPileUpSPD(AliVEvent *event)
195	{
196	// check for SPD pile-up
197	const AliAODEvent aod = dynamic_cast<const AliAODEvent>(event);
198	const AliESDEvent esd = dynamic_cast<const AliESDEvent>(event);
199	//
200	if (!aod && !esd) {
201	AliFatal("Event is neither of AOD nor ESD type");
202	return kFALSE;
203	}
204	//
205	if (aod) return (fUseSPDCutInMultBins)?aod->IsPileupFromSPDInMultBins():aod->IsPileupFromSPD(fMinPlpContribSPD,fMinPlpZdistSPD,fnSigmaPlpZdistSPD,fnSigmaPlpDiamXYSPD,fnSigmaPlpDiamZSPD);
206	else return (fUseSPDCutInMultBins)?esd->IsPileupFromSPDInMultBins():esd->IsPileupFromSPD(fMinPlpContribSPD,fMinPlpZdistSPD,fnSigmaPlpZdistSPD,fnSigmaPlpDiamXYSPD,fnSigmaPlpDiamZSPD);
207	}
208
209	//______________________________________________________________________
210	Bool_t AliAnalysisUtils::IsOutOfBunchPileUp(AliVEvent *event)
211	{
212	// check for SPD pile-up
213	const AliAODEvent aod = dynamic_cast<const AliAODEvent>(event);
214	const AliESDEvent esd = dynamic_cast<const AliESDEvent>(event);
215	//
216	if (!aod && !esd) {
217	AliFatal("Event is neither of AOD nor ESD type");
218	return kFALSE;
219	}
0a918d8d	220	Int_t bc2 = (aod)?((AliVAODHeader*)aod->GetHeader())->GetIRInt2ClosestInteractionMap():esd->GetHeader()->GetIRInt2ClosestInteractionMap();
c9df49b3	221	if (bc2 != 0)
	222	return kTRUE;
	223
0a918d8d	224	Int_t bc1 = (aod)?((AliVAODHeader*)aod->GetHeader())->GetIRInt1ClosestInteractionMap():esd->GetHeader()->GetIRInt1ClosestInteractionMap();
c9df49b3	225	if (bc1 != 0)
	226	return kTRUE;
	227
	228	return kFALSE;
	229	}
	230
8c379b7c	231
	232	//______________________________________________________________________
	233	Bool_t AliAnalysisUtils::IsSPDClusterVsTrackletBG(AliVEvent *event){
	234	Int_t nClustersLayer0 = event->GetNumberOfITSClusters(0);
	235	Int_t nClustersLayer1 = event->GetNumberOfITSClusters(1);
	236	Int_t nTracklets = event->GetMultiplicity()->GetNumberOfTracklets();
	237	if (nClustersLayer0 + nClustersLayer1 > fASPDCvsTCut + nTracklets*fBSPDCvsTCut) return kTRUE;
	238	return kFALSE;
	239	}
	240
	241
c9df49b3	242	//______________________________________________________________________
	243	Double_t AliAnalysisUtils::GetWDist(const AliVVertex* v0, const AliVVertex* v1)
	244	{
	245	// calculate sqrt of weighted distance to other vertex
	246	if (!v0 \|\| !v1) {
	247	printf("One of vertices is not valid\n");
	248	return 0;
	249	}
	250	static TMatrixDSym vVb(3);
	251	Double_t dist = -1;
	252	Double_t dx = v0->GetX()-v1->GetX();
	253	Double_t dy = v0->GetY()-v1->GetY();
	254	Double_t dz = v0->GetZ()-v1->GetZ();
	255	Double_t cov0[6],cov1[6];
	256	v0->GetCovarianceMatrix(cov0);
	257	v1->GetCovarianceMatrix(cov1);
	258	vVb(0,0) = cov0[0]+cov1[0];
	259	vVb(1,1) = cov0[2]+cov1[2];
	260	vVb(2,2) = cov0[5]+cov1[5];
	261	vVb(1,0) = vVb(0,1) = cov0[1]+cov1[1];
	262	vVb(0,2) = vVb(1,2) = vVb(2,0) = vVb(2,1) = 0.;
	263	vVb.InvertFast();
	264	if (!vVb.IsValid()) {printf("Singular Matrix\n"); return dist;}
	265	dist = vVb(0,0)dxdx + vVb(1,1)dydy + vVb(2,2)dzdz
	266	+ 2vVb(0,1)dxdy + 2vVb(0,2)dxdz + 2vVb(1,2)dy*dz;
	267	return dist>0 ? TMath::Sqrt(dist) : -1;
	268
	269	}
8c379b7c	270
beb31786	271	//______________________________________________________________________
	272	Float_t AliAnalysisUtils::GetMultiplicityPercentile(AliVEvent *event, TString lMethod ){
	273	if(!fPPVsMultUtils)
	274	fPPVsMultUtils=new AliPPVsMultUtils();
	275	if( (event->InheritsFrom("AliAODEvent")) \|\| (event->InheritsFrom("AliESDEvent")) ) return fPPVsMultUtils->GetMultiplicityPercentile(event,lMethod);
	276	else {
	277	AliFatal("Event is neither of AOD nor ESD type");
	278	return -999.;
	279	}
	280	}