ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/
//
// AliCDMesonUtils
// for
// AliAnalysisTaskCDMeson
//
//  Author:
//  Xianguo Lu <lu@physi.uni-heidelberg.de>
//  continued by
//  Felix Reidt <Felix.Reidt@cern.ch>

#include <TH1.h>
#include <TH2.h>
#include <TGeoMatrix.h>
#include <THnSparse.h>
#include <TLorentzVector.h>
#include <TRandom3.h>
#include <TParticle.h>
#include <TObjArray.h>

#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliCDBStorage.h"
#include "AliESDEvent.h"
#include "AliPIDResponse.h"
#include "AliVTrack.h"
#include "AliVParticle.h"
#include "AliESDtrack.h"
#include "AliESDtrackCuts.h"
#include "AliESDFMD.h"
#include "AliESDVZERO.h"
#include "AliGeomManager.h"
#include "AliITSAlignMille2Module.h"
#include "AliITSsegmentationSPD.h"
#include "AliMultiplicity.h"
#include "AliPIDResponse.h"
#include "AliSPDUtils.h"
#include "AliTriggerAnalysis.h"
#include "AliVZEROTriggerData.h"
#include "AliVZEROCalibData.h"

#include "AliAODTracklets.h"
#include "AliAODEvent.h"

#include "AliCDMesonBase.h"
#include "AliCDMesonTracks.h"

#include "AliCDMesonUtils.h"


//==============================================================================
//------------------------------------------------------------------------------
void AliCDMesonUtils::GetMassPtCtsOA(Int_t pid,
                                     const TVector3* momenta[], Double_t & mass,
                                     Double_t &pt, Double_t &cts, Double_t &oa)
{
	//
	// Get Mass Pt Cts OA
	//

	Double_t tmpp1[3], tmpp2[3];
	momenta[0]->GetXYZ(tmpp1);
	momenta[1]->GetXYZ(tmpp2);

	Double_t masstrk = -999;
	if(pid==AliCDMesonBase::kBinPionE || pid==AliCDMesonBase::kBinPion ||
	   pid==AliCDMesonBase::kBinSinglePion)
		masstrk = AliPID::ParticleMass(AliPID::kPion);
	else if(pid==AliCDMesonBase::kBinKaonE || pid==AliCDMesonBase::kBinKaon ||
	        pid==AliCDMesonBase::kBinSingleKaon)
		masstrk = AliPID::ParticleMass(AliPID::kKaon);
	else if(pid==AliCDMesonBase::kBinProtonE || pid==AliCDMesonBase::kBinProton ||
	        pid==AliCDMesonBase::kBinSingleProton)
		masstrk = AliPID::ParticleMass(AliPID::kProton);
	else if(pid==AliCDMesonBase::kBinElectronE ||
	        pid==AliCDMesonBase::kBinElectron ||
	        pid==AliCDMesonBase::kBinSingleElectron)
		masstrk = AliPID::ParticleMass(AliPID::kElectron);
	else
		masstrk = AliPID::ParticleMass(AliPID::kPion);

	const TLorentzVector sumv = GetKinematics(tmpp1, tmpp2, masstrk, masstrk,
	                                          cts);
	mass = sumv.M();
	pt = sumv.Pt();

	oa = GetOA(tmpp1, tmpp2);
}


//------------------------------------------------------------------------------
void AliCDMesonUtils::GetPWAinfo(Int_t pid, const AliVTrack *trks[],
                                 Float_t& theta, Float_t& phi, Float_t& mass,
                                 Float_t momentum[])
{
	// transforms the coordiante system to the helicity frame and determines
	// invariant mass and 3-vector of the two track system
	//

	Double_t tmpp1[3], tmpp2[3]; // 3-vectors of the daughter tracks
	trks[0]->GetPxPyPz(tmpp1);
	trks[1]->GetPxPyPz(tmpp2);

	// determine mass of the daugther tracks
	Double_t masstrk = -999;
	if(pid==AliCDMesonBase::kBinPion || pid==AliCDMesonBase::kBinSinglePion)
		masstrk = AliPID::ParticleMass(AliPID::kPion);
	else if(pid==AliCDMesonBase::kBinKaon || pid==AliCDMesonBase::kBinSingleKaon)
		masstrk = AliPID::ParticleMass(AliPID::kKaon);
	else if(pid==AliCDMesonBase::kBinProton ||
	        pid==AliCDMesonBase::kBinSingleProton)
		masstrk = AliPID::ParticleMass(AliPID::kProton);
	else if(pid==AliCDMesonBase::kBinElectron ||
	        pid==AliCDMesonBase::kBinSingleElectron)
		masstrk = AliPID::ParticleMass(AliPID::kElectron);
	else
		masstrk = AliPID::ParticleMass(AliPID::kPion);

	TLorentzVector va, vb; // 4-vectors of the two tracks
	va.SetXYZM(tmpp1[0], tmpp1[1], tmpp1[2], masstrk);
	vb.SetXYZM(tmpp2[0], tmpp2[1], tmpp2[2], masstrk);

	TLorentzVector sumv = va+vb; // 4-vector of the pair
	TVector3 sumXZ(sumv.X(), 0, sumv.Z()); // its projection to the xz-plane

	// mass and momentum
	mass = sumv.M();
	momentum[0] = sumv.X();
	momentum[1] = sumv.Y();
	momentum[2] = sumv.Z();

	// coordinate axis vectors
	const TVector3 x(1.,0,0);
	const TVector3 y(0,1.,0);
	const TVector3 z(0,0,1.);

	const Double_t alpha = -z.Angle(sumXZ);

	sumXZ.Rotate(alpha, y);
	sumv.Rotate(alpha, y);
	va.Rotate(alpha, y);
	vb.Rotate(alpha, y);

	const Double_t beta = z.Angle(sumv.Vect());
	sumv.Rotate(beta, x);
	va.Rotate(beta, x);
	vb.Rotate(beta, x);


	const TVector3 bv = -sumv.BoostVector();
	va.Boost(bv);
	vb.Boost(bv);

	// angles
	theta = va.Theta();
	phi = va.Phi();
}

//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetEventType(const AliESDEvent *ESDEvent)
{
	// checks of which type a event is:
	// beam-beam interaction (I), beam-gas (A/C), empty (E)
	//

	TString firedTriggerClasses = ESDEvent->GetFiredTriggerClasses();

	if (firedTriggerClasses.Contains("CINT1A-ABCE-NOPF-ALL")) { // A
		return AliCDMesonBase::kBinEventA;
	}
	if (firedTriggerClasses.Contains("CINT1C-ABCE-NOPF-ALL")) { // C
		return AliCDMesonBase::kBinEventC;
	}
	if (firedTriggerClasses.Contains("CINT1B-ABCE-NOPF-ALL")) { // I
		return AliCDMesonBase::kBinEventI;
	}
	if (firedTriggerClasses.Contains("CINT1-E-NOPF-ALL")) { // E
		return AliCDMesonBase::kBinEventE;
	}
	if (firedTriggerClasses.Contains("CDG5-E")) { // E
		return AliCDMesonBase::kBinEventE;
	}
	if (firedTriggerClasses.Contains("CDG5-I")) { // I
		return AliCDMesonBase::kBinEventI;
	}
	if (firedTriggerClasses.Contains("CDG5-AC")) { // AC
		return AliCDMesonBase::kBinEventAC;
	}
	return AliCDMesonBase::kBinEventUnknown;
}


//------------------------------------------------------------------------------
void AliCDMesonUtils::SwapTrack(const AliVTrack* trks[])
{
	//
	// swap two esdtracks, needed since only the properties of one a stored and
	// AliRoot sorts them
	//

	TRandom3 tmprd(0);
	if(tmprd.Rndm()>0.5)
		return;

	const AliVTrack* tmpt = trks[0];
	trks[0]=trks[1];
	trks[1]=tmpt;
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetCombCh(const AliVTrack * trks[])
{
	//
	// get combination of charges
	//

	const Double_t ch1 = trks[0]->Charge();
	const Double_t ch2 = trks[1]->Charge();

	if(ch1*ch2<0){
		return AliCDMesonBase::kBinPM;
	}
	else 
		return AliCDMesonBase::kBinPPMM;
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetCombPID(AliPIDResponse* pid, const AliVTrack* trks[],
                                  Int_t mode, TH2* comb2trkPID /*= 0x0 */)
{
	//
	// Get PID for a two track system (data)
	//

	if (!pid){
		return AliCDMesonBase::kBinPIDUnknown;
	}

	// get PID for the single tracks
	Int_t kpid[2];
	for(Int_t ii=0; ii<2; ii++){
		kpid[ii] = GetPID(pid, trks[ii], mode);
	}

	// PID QA histogram
	if (comb2trkPID) {
		comb2trkPID->Fill(kpid[0], kpid[1]);
	}

	return CombinePID(kpid);
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetCombPID(const TParticle* particles[],
                                  TH2 *comb2trkPID /* = 0x0 */)
{
	//
	// Get PID for a two track system (MC)
	//

	// get PID for the single tracks
	Int_t kpid[2];
	for(Int_t ii=0; ii<2; ii++){
		kpid[ii] = GetPID(particles[ii]->GetPdgCode());
	}

	// PID QA histogram
	if (comb2trkPID) {
		comb2trkPID->Fill(kpid[0], kpid[1]);
	}

	return CombinePID(kpid);
}


//------------------------------------------------------------------------------
void AliCDMesonUtils::GetSPDTrackletMult(const AliESDEvent *ESDEvent,
                                         Int_t& sum, Int_t& forwardA,
                                         Int_t& forwardC, Int_t& central)
{
	// obtain the multiplicity for eta < -.9 (forwardC), eta > 0.9 (fowardA), in
	// the central barrel (central) and its sum from SPD tracklets with the
	// AliMultiplicity class
	// code simular to PWGPP/ITS/AliAnalysisTaskSPD.cxx

	sum = forwardA = forwardC = central = 0; // initialize values

	const AliMultiplicity *mult = ESDEvent->GetMultiplicity();
	for (Int_t iTracklet = 0; iTracklet < mult->GetNumberOfTracklets();
	     iTracklet++) {
		float_t eta = mult->GetEta(iTracklet);
		if (eta < -0.9) {
			forwardC++;
		}
		else if (eta < 0.9) {
			central++;
		}
		else {
			forwardA++;
		}
		sum++;
	}
}


//------------------------------------------------------------------------------
Bool_t AliCDMesonUtils::CutEvent(const AliESDEvent *ESDEvent, TH1 *hspd,
                                 TH1 *hpriv, TH1 *hpriVtxPos, TH1 *hpriVtxDist,
                                 TH2 *hfo, TH1* hfochans, Int_t &kfo,
                                 Int_t &nip, Int_t &nop, TH1 *hpriVtxX,
                                 TH1 *hpriVtxY, TH1 *hpriVtxZ)
{
	//
	// CutEvent
	//

	AliTriggerAnalysis triggerAnalysis;
	/*
	//printf("AliCDMesonUtils active triggers: %s\n",
	//       ESDEvent->GetHeader()->GetActiveTriggerInputs().Data());
	//printf("AliCDMesonUtils fired triggers: %s\n",
	//       ESDEvent->GetHeader()->GetFiredTriggerInputs().Data());
	//*/
	//http://alisoft.cern.ch/viewvc/trunk/ANALYSIS/AliTriggerAnalysis.cxx?view=markup&root=AliRoot
	//Int_t AliTriggerAnalysis::SPDFiredChips(const AliESDEvent* aEsd, Int_t origin, Bool_t fillHists, Int_t layer)
	// returns the number of fired chips in the SPD
	// origin = 0 --> aEsd->GetMultiplicity()->GetNumberOfFiredChips() (filled from clusters)
	// origin = 1 --> aEsd->GetMultiplicity()->TestFastOrFiredChips() (from hardware bits)


	// SPD FastOR cut
	const Int_t fastORhw = triggerAnalysis.SPDFiredChips(ESDEvent, 1);
	if (hspd) hspd->Fill(fastORhw);
	/*
	if(fastORhw<1)
		return kFALSE;
	*/

	if (hfochans) {
		const AliMultiplicity *mult = ESDEvent->GetMultiplicity();

		for(Int_t iChipKey=0; iChipKey < 1200; iChipKey++){
			if (mult->TestFastOrFiredChips(iChipKey)) {
				hfochans->Fill((Double_t)iChipKey);
			}
		}
	}

	if(kfo){ // spd trigger study
		Int_t nfoctr[10];
		GetNFO(ESDEvent, "[1.0]", nfoctr, 0x0, 0x0);
		nip = nfoctr[kInnerPixel];
		nop = nfoctr[kOuterPixel];

		if(AliCDMesonBase::GetGapBin("V0", GetV0(ESDEvent)) ==
		    AliCDMesonBase::kBinDG) {
			hfo->Fill(nip, nop);
		}

		if(nop<2)
			kfo = 1;
		else
			kfo = nop;

		if(kfo>=10)
			kfo=9;
	}

	// collision vertex cut
	// A cut in XY is implicitly done during the reconstruction by constraining
	// the vertex to the beam diamond.

	// Primary vertex
	Bool_t kpr0 = kTRUE;
	const AliESDVertex *vertex = ESDEvent->GetPrimaryVertexTracks();
	if(vertex->GetNContributors()<1) {
		// SPD vertex
		vertex = ESDEvent->GetPrimaryVertexSPD();
		if(vertex->GetNContributors()<1) {
			// NO VERTEX, SKIP EVENT
			kpr0 = kFALSE;
		}
	}
	const Bool_t kpriv = kpr0 && (fabs(vertex->GetZ()) < 10.);
	// 10 is the common value, unit: cm
	if (hpriv) hpriv->Fill(kpriv);
	if (hpriVtxDist) hpriVtxDist->Fill(vertex->GetZ());
	if (hpriVtxPos && kpr0) hpriVtxPos->Fill(!kpriv);
	if(!kpriv)
		return kFALSE;

	if(hpriVtxX) hpriVtxX->Fill(vertex->GetX());
	if(hpriVtxY) hpriVtxY->Fill(vertex->GetY());
	if(hpriVtxZ) hpriVtxZ->Fill(vertex->GetZ());
	return kTRUE;
}

//------------------------------------------------------------------------------
Bool_t AliCDMesonUtils::CutEvent(const AliAODEvent *AODEvent, TH1 *hpriv,
                                 TH1 *hpriVtxX, TH1 *hpriVtxY, TH1 *hpriVtxZ,
                                 TH1 *hpriVtxPos, TH1 *hpriVtxDist)
{
	//
	// Cut Event for AOD Events, to be combined with the ESD Track Cut
	//

	// TODO: no idea about fast or yet, to be thought of

	// Primary vertex
	Bool_t kpr0 = kTRUE;
	const AliAODVertex *vertex = AODEvent->GetPrimaryVertex();
	if(vertex->GetNContributors()<1) {
		// SPD vertex
		vertex = AODEvent->GetPrimaryVertexSPD();
		if(vertex->GetNContributors()<1) {
			// NO GOOD VERTEX, SKIP EVENT
			kpr0 = kFALSE;
		}
	}
	const Bool_t kpriv = kpr0 && (fabs(vertex->GetZ())<10.);
	// 10 is the common value, unit: cm
	hpriv->Fill(kpriv);
	if (hpriVtxDist) hpriVtxDist->Fill(vertex->GetZ());
	if (hpriVtxPos && kpr0) hpriVtxPos->Fill(!kpriv);
	if(!kpriv)
		return kFALSE;

	if(hpriVtxX) hpriVtxX->Fill(vertex->GetX());
	if(hpriVtxY) hpriVtxY->Fill(vertex->GetY());
	if(hpriVtxZ) hpriVtxZ->Fill(vertex->GetZ());
	return kTRUE;
}


//------------------------------------------------------------------------------
void AliCDMesonUtils::DoVZEROStudy(const AliESDEvent *ESDEvent,
                                   TObjArray* hists, Int_t run)
{
	//
	//
	// IMPORTANT: the order of the histograms here and in
	// AliCDMesonBase::GetHistVZEROStudies(..) has to match

	const AliESDVZERO* esdV0 = ESDEvent->GetVZEROData();
	if (!esdV0) {
		Printf("ERROR: esd V0  not available");
		return;
	}

	// determine trigger decision
	AliTriggerAnalysis triggerAnalysis;
	//const Bool_t khw = kFALSE;

	//Float_t v0a = (triggerAnalysis.V0Trigger(ESDEvent, AliTriggerAnalysis::kASide, khw) ==
	//             AliTriggerAnalysis::kV0BB) ? 1. : 0.;
	//Float_t v0c = (triggerAnalysis.V0Trigger(ESDEvent, AliTriggerAnalysis::kCSide, khw) ==
	//             AliTriggerAnalysis::kV0BB) ? 1. : 0.;

	// obtain OCDB objects
	AliCDBManager *man = AliCDBManager::Instance();
	TString cdbpath;
	if (man->IsDefaultStorageSet()) {
		const AliCDBStorage *dsto = man->GetDefaultStorage();
		cdbpath = TString(dsto->GetBaseFolder());
	}
	else { //should not be used!
		man->SetDefaultStorage(gSystem->Getenv("TRAIN_CDB_PATH"));
		cdbpath = TString(gSystem->Getenv("TRAIN_CDB_PATH"));
	}
	man->SetSpecificStorage("VZERO/Trigger/Data",cdbpath);
	man->SetSpecificStorage("VZERO/Calib/Data",cdbpath);
	man->SetRun(run);

	AliCDBEntry *ent1 = man->Get("VZERO/Trigger/Data");
	if (!ent1) {
		printf("AliCDMesonUtils failed loading VZERO trigger entry from OCDB\n");
		return;
	}
	AliVZEROTriggerData *trigData = (AliVZEROTriggerData*)ent1->GetObject();
	if (!trigData) {
		printf("AliCDMesonUtils failed loading VZERO trigger data from OCDB\n");
		return;
	}

	AliCDBEntry *ent2 = man->Get("VZERO/Calib/Data");
	if (!ent2) {
		printf("AliCDMesonUtils failed loading VZERO calib entry from OCDB\n");
		return;
	}
	AliVZEROCalibData *calData = (AliVZEROCalibData*)ent2->GetObject();
	if (!calData) {
		printf("AliCDMesonUtils failed loading VZERO calibration data from OCDB\n");
		return;
	}

	// fill histograms
	Int_t pmtHist = 0;
	Int_t iPMT = 0;
	for (iPMT = 0; iPMT < 64; ++iPMT) {
		Int_t board   = AliVZEROCalibData::GetBoardNumber(iPMT);
		Int_t channel = AliVZEROCalibData::GetFEEChannelNumber(iPMT);
		((TH2*)hists->At(iPMT+pmtHist))->Fill(esdV0->GetAdc(iPMT),
		                                      trigData->GetPedestalCut(0, board, channel));
	//                                      calData->GetDiscriThr(iPMT));
	}
	pmtHist = iPMT;
	for (iPMT = 0; iPMT < 64; ++iPMT) {
		((TH2*)hists->At(iPMT+pmtHist))->Fill(esdV0->GetAdc(iPMT),
		                                      esdV0->GetMultiplicity(iPMT));
	}
	/*
	// not used in 2010 for pp
	((TH2*)hists->At(pmtHist++))->Fill((Float_t)esdV0->GetTriggerChargeA(), v0a);
	((TH2*)hists->At(pmtHist++))->Fill((Float_t)esdV0->GetTriggerChargeC(), v0c);
	*/
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetGapConfig(const AliESDEvent *ESDEvent,
                                    TH2 *hitMapSPDinner, TH2 *hitMapSPDouter,
                                    TH2 *hitMapSPDtrklt, TH2 *hitMapFMDa,
                                    TH2 *hitMapFMDc, TH1 **fmdSums,
                                    TH2 *TPCGapDCAaSide, TH2 *TPCGapDCAcSide)
{
	//
	// GetGapConfigAndTracks
	//
	// retrieves the gap configuration of a track and returns it as
	// an bit vector
	// kBaseLine ensures, that this event is valid
	// + is equivalent to | in this case
	Int_t gapConfig = AliCDMesonBase::kBitBaseLine + GetV0(ESDEvent)
		+ GetFMD(ESDEvent, hitMapFMDa, hitMapFMDc, fmdSums)
		+ GetSPD(ESDEvent, hitMapSPDinner, hitMapSPDouter, hitMapSPDtrklt);
	if (gapConfig == AliCDMesonBase::kBitBaseLine) {
		gapConfig += GetTPC(ESDEvent, TPCGapDCAaSide, TPCGapDCAcSide);
	}
	else {
		gapConfig += GetTPC(ESDEvent, 0x0, 0x0);
	}
	if (GetFastORmultiplicity(ESDEvent) > 0) {
		gapConfig += AliCDMesonBase::kBitCentAct;
	}
	return gapConfig; // + GetZDC(ESDEvent);
}


//------------------------------------------------------------------------------
void AliCDMesonUtils::FillEtaPhiMap(const AliVEvent *event,
                                    const AliCDMesonTracks* tracks, TH2 *map,
                                    TH2 *map_c)
{
	//
	// Fills the eta phi information about all tracks and about the tracks surving
	// the track cuts (CutTrack) into two separate histograms
	//

	// all tracks
	for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); ++itrk) {
		if (AliVParticle *trk = event->GetTrack(itrk)) {
			if (map) {
				map->Fill(trk->Eta(), trk->Phi());
			}
		}
	}

	// tracks that survived the cuts
	for (Int_t itrk = 0; itrk < tracks->GetCombinedTracks(); ++itrk) {
		if (map_c) {
			map_c->Fill(tracks->GetTrack(itrk)->Eta(), tracks->GetTrack(itrk)->Phi());
		}
	}
}


//------------------------------------------------------------------------------
void AliCDMesonUtils::GetMultFMD(const AliESDEvent *ESDEvent, Int_t& fmdA,
                                 Int_t& fmdC, Float_t  *fmdSums)
{
	//
	// Multiplicity seen by FMD
	//
	// WARNING: this function is only working with a modified AliRoot so far

#ifdef STD_ALIROOT
	fmdA = FMDHitCombinations(ESDEvent, 0);
	fmdC = FMDHitCombinations(ESDEvent, 1);
#else
	AliTriggerAnalysis triggerAnalysis;
	triggerAnalysis.SetFMDThreshold(0.3, 0.5); // parameters got from FMD
	triggerAnalysis.FMDTrigger(ESDEvent, AliTriggerAnalysis::kASide, &fmdA);
	triggerAnalysis.FMDTrigger(ESDEvent, AliTriggerAnalysis::kCSide, &fmdC);
#endif

	if (fmdSums) {
		const AliESDFMD* fmdData =
			(const_cast<AliESDEvent*>(ESDEvent))->GetFMDData();
		for (UShort_t det=1; det<=3; det++) {
			Int_t nRings = (det == 1 ? 1 : 2);
			for (UShort_t ir = 0; ir < nRings; ir++) {
				Char_t   ring = (ir == 0 ? 'I' : 'O');
				UShort_t nsec = (ir == 0 ? 20  : 40);
				UShort_t nstr = (ir == 0 ? 512 : 256);
				for (UShort_t sec =0; sec < nsec;  sec++) {
					for (UShort_t strip = 0; strip < nstr; strip++) {
						Float_t mult = fmdData->Multiplicity(det,ring,sec,strip);
						if (mult == AliESDFMD::kInvalidMult) continue;

						if (det == 1 && ring == 'I') fmdSums[0] += mult;
						else if (det == 2 && ring == 'I') fmdSums[1] += mult;
						else if (det == 2 && ring == 'O') fmdSums[2] += mult;
						else if (det == 3 && ring == 'I') fmdSums[3] += mult;
						else if (det == 3 && ring == 'O') fmdSums[4] += mult;
					}
				}
			}
		}
	}
}


//------------------------------------------------------------------------------
void AliCDMesonUtils::GetMultSPD(const AliESDEvent * ESDEvent, Int_t& spdIA,
                                 Int_t& spdIC, Int_t& spdOA, Int_t& spdOC)
{
	//
	// Retrieves the multiplicity seen by the SPD FastOR
	//

	Int_t nfoctr[10];
	GetNFO(ESDEvent, "]0.9[", nfoctr, 0x0, 0x0);

	spdIA = nfoctr[kIPA];
	spdIC = nfoctr[kIPC];
	spdOA = nfoctr[kOPA];
	spdOC = nfoctr[kOPC];
}


//==============================================================================
//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetV0(const AliESDEvent * ESDEvent)
{
	//
	//GetV0
	//

	AliTriggerAnalysis triggerAnalysis;
	const Bool_t khw = kFALSE;
	const Bool_t v0A =
		(triggerAnalysis.V0Trigger(ESDEvent, AliTriggerAnalysis::kASide, khw) ==
		 AliTriggerAnalysis::kV0BB);
	const Bool_t v0C =
		(triggerAnalysis.V0Trigger(ESDEvent, AliTriggerAnalysis::kCSide, khw) ==
		 AliTriggerAnalysis::kV0BB);

	return v0A * AliCDMesonBase::kBitV0A + v0C * AliCDMesonBase::kBitV0C;
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetFMD(const AliESDEvent *ESDEvent, TH2 *hitMapFMDa,
                              TH2 *hitMapFMDc, TH1 **fmdSums)
{
	//
	// GetFMD
	//

	AliTriggerAnalysis triggerAnalysis;
	triggerAnalysis.SetFMDThreshold(0.3, 0.5); // parameters got from FMD
	const Bool_t fmdA =
		triggerAnalysis.FMDTrigger(ESDEvent, AliTriggerAnalysis::kASide);
	const Bool_t fmdC =
		triggerAnalysis.FMDTrigger(ESDEvent, AliTriggerAnalysis::kCSide);

	//printf("FR - GetFMD\n");

	// prepartions for a charge summation algorithm
	Bool_t hitMaps = (Bool_t)(hitMapFMDa && hitMapFMDc);
	Bool_t calcSum = fmdSums ?
		(fmdSums[0] && fmdSums[1] && fmdSums[2] && fmdSums[3] && fmdSums[4]) :
		kFALSE; // are the histograms defined?
	Float_t sum[] = { 0., 0., 0., 0., 0. };
	// summed multiplicity in the FMD detectors

	// hit map generation
	if (hitMaps || calcSum) {
		const AliESDFMD* fmdData =
			(const_cast<AliESDEvent*>(ESDEvent))->GetFMDData();

		for (UShort_t det=1; det<=3;det++) {
			Int_t nRings = (det == 1 ? 1 : 2);
			for (UShort_t ir = 0; ir < nRings; ir++) {
				Char_t   ring = (ir == 0 ? 'I' : 'O');
				UShort_t nsec = (ir == 0 ? 20  : 40);
				UShort_t nstr = (ir == 0 ? 512 : 256);
				for (UShort_t sec =0; sec < nsec;  sec++) {
					for (UShort_t strip = 0; strip < nstr; strip++) {
						Float_t mult = fmdData->Multiplicity(det,ring,sec,strip);
						if (mult == AliESDFMD::kInvalidMult) continue;

						if (calcSum) {
							if (det == 1 && ring == 'I') sum[0] += mult;
							else if (det == 2 && ring == 'I') sum[1] += mult;
							else if (det == 2 && ring == 'O') sum[2] += mult;
							else if (det == 3 && ring == 'I') sum[3] += mult;
							else if (det == 3 && ring == 'O') sum[4] += mult;
						}

						if (hitMaps) { // care about hit map specific information
							const Float_t eta = fmdData->Eta(det,ring,sec,strip);
							const Float_t phi =
								fmdData->Phi(det,ring,sec,strip) / 180. * TMath::Pi();
							//printf("FR - GetFMD: %f %f %f\n", eta, phi, mult);
							if (eta != AliESDFMD::kInvalidEta) {
								if ((-3.5 < eta) && (eta < -1.5)) {
									hitMapFMDc->Fill(eta, phi, mult); // use mult as weight
								}
								else if ((1.5 < eta) && (eta < 5.5)) {
									hitMapFMDa->Fill(eta, phi, mult); // use mult as weight
								}
							}
						}
					}
				}
			}
		}
	}

	if (calcSum) {
		//printf("DEBUG -- SUM(%f,%f,%f,%f,%f)\n", sum[0], sum[1], sum[2], sum[3],
		//       sum[4]);
		for (UInt_t i = 0; i < 5; i++) { // 
			fmdSums[i]->Fill(sum[i]);
		}
	}

	return fmdA * AliCDMesonBase::kBitFMDA + fmdC * AliCDMesonBase::kBitFMDC;
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetSPD(const AliESDEvent *ESDEvent, TH2 *hitMapSPDinner,
                              TH2 *hitMapSPDouter, TH2 *hitMapSPDtrklt)
{
	//
	// GetSPD
	//

	Int_t nfoctr[10];
	GetNFO(ESDEvent, "]0.9[", nfoctr, hitMapSPDinner, hitMapSPDouter);
	// get multiplicity from fastOR and fill corresponding hit maps

	if (hitMapSPDtrklt) FillSPDtrkltMap(ESDEvent, hitMapSPDtrklt);
	// fill tracklet hit map

	const Int_t ipA = nfoctr[kIPA]; // inner layer A side
	const Int_t ipC = nfoctr[kIPC]; // inner layer C side
	const Int_t opA = nfoctr[kOPA]; // outer layer A side
	const Int_t opC = nfoctr[kOPC]; // outer layer C side

	const Bool_t spdA = ipA + opA; // A side hit?
	const Bool_t spdC = ipC + opC; // C side hit?

	return spdA * AliCDMesonBase::kBitSPDA + spdC * AliCDMesonBase::kBitSPDC;
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetTPC(const AliESDEvent * ESDEvent, TH2 *TPCGapDCAaSide,
                              TH2 *TPCGapDCAcSide)
{
	//
	//GetTPC
	//

	const Double_t etacut = 0.9;
	Int_t nA = 0;
	Int_t nC = 0;

	AliESDtrackCuts cuts;
	cuts.SetMaxDCAToVertexXY(0.1);
	cuts.SetMaxDCAToVertexZ(2.);

	for(Int_t itrack = 0; itrack < ESDEvent->GetNumberOfTracks(); itrack++){
		const AliESDtrack* esdtrack = ESDEvent->GetTrack(itrack);
		Float_t b[2];
		Float_t bCov[3];
		esdtrack->GetImpactParameters(b,bCov);

		if (bCov[0]<=0 || bCov[2]<=0) {
			printf("AliCDMesonUtils - Estimated b resolution lower or equal zero!\n");
			bCov[0]=0;
			bCov[2]=0;
		}

		Float_t dcaToVertexXY = b[0];
		Float_t dcaToVertexZ = b[1];
		if (esdtrack->Eta() > etacut) {
			if (cuts.AcceptTrack(esdtrack)) nA++;
			if (TPCGapDCAaSide) {
				TPCGapDCAaSide->Fill(dcaToVertexXY, dcaToVertexZ);
			}
		}
		else if (esdtrack->Eta() < -etacut) {
			if (cuts.AcceptTrack(esdtrack)) nC++;
			if (TPCGapDCAcSide) {
				TPCGapDCAcSide->Fill(dcaToVertexXY, dcaToVertexZ);
			}
		}
	}

	const Bool_t tpcA = nA;
	const Bool_t tpcC = nC;

	return tpcA * AliCDMesonBase::kBitTPCA + tpcC * AliCDMesonBase::kBitTPCC;
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetZDC(const AliESDEvent * ESDEvent)
{
	//
	//GetZDC
	//

	const Int_t qa = ESDEvent->GetESDZDC()->GetESDQuality();
	Bool_t zdcA = kFALSE, zdcC = kFALSE;
	for(Int_t ii=0; ii<6; ii++){
		if(qa & (1<<ii)){
			if(ii<4) zdcA = kTRUE;
			else zdcC = kTRUE;
		}
	}

	return zdcA * AliCDMesonBase::kBitZDCA + zdcC * AliCDMesonBase::kBitZDCC;
}


//==============================================================================
//------------------------------------------------------------------------------
#ifdef STD_ALIROOT
Int_t AliCDMesonUtils::FMDHitCombinations(const AliESDEvent* ESDEvent,
                                          Int_t side)
{
	//
	// copy of the FMDHitCombinations function originating from AliTriggerAnalysis
	//
	// side == 0 -> A side, side > 0 -> C side

	// workaround for AliESDEvent::GetFMDData is not const!
	const AliESDFMD* fmdData =
		(const_cast<AliESDEvent*>(ESDEvent))->GetFMDData();
	if (!fmdData)
		{
			puts("AliESDFMD not available");
			return -1;
		}

	Int_t detFrom = (side == 0) ? 1 : 3;
	Int_t detTo   = (side == 0) ? 2 : 3;

	Int_t triggers = 0;
	Float_t totalMult = 0;
	for (UShort_t det=detFrom;det<=detTo;det++) {
		Int_t nRings = (det == 1 ? 1 : 2);
		for (UShort_t ir = 0; ir < nRings; ir++) {
			Char_t   ring = (ir == 0 ? 'I' : 'O');
			UShort_t nsec = (ir == 0 ? 20  : 40);
			UShort_t nstr = (ir == 0 ? 512 : 256);
			for (UShort_t sec =0; sec < nsec;  sec++) {
				for (UShort_t strip = 0; strip < nstr; strip++) {
					Float_t mult = fmdData->Multiplicity(det,ring,sec,strip);
					if (mult == AliESDFMD::kInvalidMult) continue;

					if (mult > 0.3) // fFMDLowCut
						totalMult = totalMult + mult;
					else {
						if (totalMult > 0.5) // fFMDHitCut
							triggers++;
					}
				}
			}
		}
	}
	return triggers;
}
#endif


//==============================================================================
//------------------------------------------------------------------------------
void AliCDMesonUtils::SPDLoadGeom(Int_t run)
{
	// method to get the gGeomanager
	// it is called at the CreatedOutputObject stage
	// to comply with the CAF environment

	AliCDBManager *man = AliCDBManager::Instance();

	TString cdbpath;
	if (man->IsDefaultStorageSet()) {
		const AliCDBStorage *dsto = man->GetDefaultStorage();
		cdbpath = TString(dsto->GetBaseFolder());
		//printf("default was set to: %s\n", cdbpath.Data());
	}
	else { //should not be used!
		// man->SetDefaultStorage("alien://folder=/alice/data/2010/OCDB");
		// would be needed on grid
		man->SetDefaultStorage(gSystem->Getenv("TRAIN_CDB_PATH"));
		cdbpath = TString(gSystem->Getenv("TRAIN_CDB_PATH"));
	}

	man->SetSpecificStorage("ITS/Align/Data",cdbpath);
	man->SetSpecificStorage("GRP/Geometry/Data",cdbpath);
	man->SetRun(run);

	AliCDBEntry* obj = man->Get(AliCDBPath("GRP", "Geometry", "Data"));
	if (!obj) {
		printf("AliCDMesonUtils failed loading geometry object\n");
		return;
	}
	AliGeomManager::SetGeometry((TGeoManager*)obj->GetObject());
	AliGeomManager::ApplyAlignObjsFromCDB("ITS");
}

//------------------------------------------------------------------------------
Bool_t AliCDMesonUtils::SPDLoc2Glo(Int_t id, const Double_t *loc,
                                   Double_t *glo)
{
	//
	//SPDLoc2Glo, do not touch
	//

	static TGeoHMatrix mat;
	Int_t vid = AliITSAlignMille2Module::GetVolumeIDFromIndex(id);
	if (vid<0) {
		printf("AliCDMesonUtils Did not find module with such ID %d\n",id);
		return kFALSE;
	}
	AliITSAlignMille2Module::SensVolMatrix(vid,&mat);
	mat.LocalToMaster(loc,glo);
	return kTRUE;
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::CheckChipEta(Int_t chipKey, TString scut,
                                    const Double_t vtxPos[],
                                    TH2 *hitMapSPDinner, TH2 *hitMapSPDouter)
{
	//
	//CheckChipEta
	//

	// retrieves the position in eta for a given chip and applies the cut
	// results:
	// 0 <= out of range
	// -1 <= negative pseudo-rapidity position, in range (C-Side)
	// 1 <= positive pseudo-rapidity position, in range (A-Side)
	//
	// scut: "[0.9" or "]0.9", only 3 digits for the value!!


	const Bool_t kincl = (scut[0] == '[');
	const TString cutval = scut(1,3);
	const Double_t etacut = fabs(cutval.Atof());

	//no eta cut, save time
	if(kincl && etacut>=2)
		return kTRUE;

	Int_t etaside = 1;
	//------------------------------- NOT TO TOUCH ------------------------>>
	UInt_t module=999, offchip=999;
	AliSPDUtils::GetOfflineFromOfflineChipKey(chipKey,module,offchip);
	UInt_t hs = AliSPDUtils::GetOnlineHSFromOffline(module);
	if(hs<2) offchip = 4 - offchip; // inversion  in the inner layer...

	const Int_t col[]={
		hs<2? 0 : 31, 
		hs<2? 31 : 0, 
		hs<2? 31 : 0, 
		hs<2? 0 : 31};
	const Int_t aa[]={0, 0, 255, 255};
	const AliITSsegmentationSPD seg;

	for(Int_t ic=0; ic<4; ic++){
		Float_t localchip[3]={0.,0.,0.};
		seg.DetToLocal(aa[ic],col[ic]+32*offchip,localchip[0],localchip[2]);
		// local coordinate of the chip center
		//printf("local coordinates %d %d: %f %f \n",chipKey, ic, localchip[0],localchip[2]);
		const Double_t local[3] = {localchip[0],localchip[1],localchip[2]};
		Double_t glochip[3]={0.,0.,0.};
		if(!SPDLoc2Glo(module,local,glochip)){
			return kFALSE;
		}

		//-------------------------------------------------------------------<<

		const TVector3 pos(glochip[0]-vtxPos[0], glochip[1]-vtxPos[1],
		                   glochip[2]-vtxPos[2]);
		//pos.Print();

		if (chipKey < 400) { // inner SPD layer
			if (hitMapSPDinner) {
				Double_t phi = pos.Phi(); // output in the range -Pi +Pi
				if (phi < 0.) phi += TMath::TwoPi(); // remap to the interval [0, TwoPi)
				const Double_t eta = pos.Eta();
				hitMapSPDinner->Fill(eta, phi);
			}
		}
		else {
			if (hitMapSPDouter) { // outer SPD layer
				Double_t phi = pos.Phi(); // output in the range -Pi +Pi
				if (phi < 0.) phi += TMath::TwoPi(); // remap to the interval [0, TwoPi)
				const Double_t eta = pos.Eta();
				hitMapSPDouter->Fill(eta, phi);
			}
		}

		if( kincl && fabs(pos.Eta()) > etacut)
			return kFALSE;

		if(!kincl){
			if(fabs(pos.Eta()) < etacut)
				return kFALSE;
			else if(pos.Eta()<0)
				etaside = -1;
			else
				etaside = 1;
		}
	}

	return etaside;
}


//------------------------------------------------------------------------------
void AliCDMesonUtils::GetNFO(const AliESDEvent *ESDEvent, TString etacut,
                             Int_t ctr[], TH2 *hitMapSPDinner,
                             TH2 *hitMapSPDouter)
{
	//
	// GetNFO
	//
	// analyzes the SPD fastOR for a given eta range and returns
	// an array with the number of hits in:

	Int_t ninner=0; // inner layer
	Int_t nouter=0; // outer layer
	Int_t ipA = 0; // inner layer A side
	Int_t ipC = 0; // inner layer C side
	Int_t opA = 0; // outer layer A side
	Int_t opC = 0; // outer layer C side

	const AliMultiplicity *mult = ESDEvent->GetMultiplicity();

	// position of the primary vertex
	Double_t tmp[3] = { 0., 0., 0. };
	ESDEvent->GetPrimaryVertex()->GetXYZ(tmp);
	Double_t vtxPos[3] = { tmp[0], tmp[1], tmp[2] };


	for(Int_t iChipKey=0; iChipKey < 1200; iChipKey++){
		if(mult->TestFastOrFiredChips(iChipKey)){
			// here you check if the FastOr bit is 1 or 0
			const Int_t iseta = CheckChipEta(iChipKey, etacut, vtxPos, hitMapSPDinner,
			                                 hitMapSPDouter);
			if(iseta==0)
				continue;

			if(iChipKey<400) {
				ninner++;  // here you count the FastOr bits in the inner layer
				if(iseta>0)
					ipA ++;
				else
					ipC ++;
			}
			else {
				nouter++;  // here you count the FastOr bits in the outer layer
				if(iseta>0)
					opA ++;
				else
					opC ++;
			}
		}
	}

	ctr[kInnerPixel]= ninner;
	ctr[kOuterPixel]= nouter;
	ctr[kIPA]= ipA;
	ctr[kIPC]= ipC;
	ctr[kOPA]= opA;
	ctr[kOPC]= opC;

	return;
}


//--------------------------------------------------------------------------
Int_t AliCDMesonUtils::GetFastORmultiplicity(const AliESDEvent* ESDEvent)
{
	// determine the number of fired fastOR chips in both layers within
	// -0.9 < eta < 0.9
	//

	const AliMultiplicity *mult = ESDEvent->GetMultiplicity();

	// position of the primary vertex
	Double_t tmp[3] = { 0., 0., 0. };
	ESDEvent->GetPrimaryVertex()->GetXYZ(tmp);
	Double_t vtxPos[3] = { tmp[0], tmp[1], tmp[2] };

	Int_t multiplicity = 0;

	for (Int_t iChipKey=0; iChipKey < 1200; iChipKey++) {
		if(mult->TestFastOrFiredChips(iChipKey)){
			// here you check if the FastOr bit is 1 or 0
			const Int_t iseta = CheckChipEta(iChipKey, "[0.9]", vtxPos, 0x0, 0x0);
			if(iseta==0)
				continue;
			else
				++multiplicity;
		}
	}

	return multiplicity;
}


//--------------------------------------------------------------------------
void AliCDMesonUtils::FillSPDtrkltMap(const AliVEvent* event,
                                      TH2 *hitMapSPDtrklt)
{
	//
	// fill eta phi map of SPD tracklets
	//

	if (hitMapSPDtrklt) {
		if (TString(event->ClassName()) == "AliESDEvent") {
			const AliMultiplicity *mult = ((AliESDEvent*)event)->GetMultiplicity();
			for (Int_t iTracklet = 0; iTracklet < mult->GetNumberOfTracklets();
			     iTracklet++) {
				Double_t eta = mult->GetEta(iTracklet);
				Double_t phi = mult->GetPhi(iTracklet);
				hitMapSPDtrklt->Fill(eta, phi);
			}
		}
		else if (TString(event->ClassName()) == "AliAODEvent") {
			const AliAODTracklets* mult = ((AliAODEvent*)event)->GetTracklets();
			for (Int_t iTracklet = 0; iTracklet < mult->GetNumberOfTracklets();
			     iTracklet++) {
				Double_t eta = -TMath::Log(TMath::Tan(mult->GetTheta(iTracklet)/2.));
				Double_t phi = mult->GetPhi(iTracklet);
				hitMapSPDtrklt->Fill(eta, phi);
			}
		}
	}
}


//==========================================================================
Int_t AliCDMesonUtils::GetPID(AliPIDResponse *pid, const AliVTrack *trk,
                              Int_t mode /* = 0 */)
{
	// determines PID for ESDs and AODs
	// 
	//

	if (!pid) return AliCDMesonBase::kBinPIDUnknown; // no pid available

	Double_t tpcpion = -999., tpckaon = -999., tpcproton = -999.,
		tpcelectron = -999.;
	Double_t tofpion = -999., tofkaon = -999., tofproton = -999.,
		tofelectron = -999.;
	Double_t itspion = -999., itskaon = -999., itsproton = -999.,
		itselectron = -999.;


	// check whether the track was pure ITS standalone track (has not left TPC)
	const Bool_t kits = !(trk->GetStatus() & AliESDtrack::kTPCout);

	if (kits) { // do ITS pid
		const Double_t nin = 3.;

		itspion = pid->NumberOfSigmasITS( trk, AliPID::kPion );
		itskaon = pid->NumberOfSigmasITS( trk, AliPID::kKaon );
		itsproton = pid->NumberOfSigmasITS( trk, AliPID::kProton );
		itselectron = pid->NumberOfSigmasITS( trk, AliPID::kElectron );

		if(fabs(itspion) < nin) // inclusion only
			return AliCDMesonBase::kBinPion;
		else if(fabs(itskaon) < nin)
			return AliCDMesonBase::kBinKaon;
		else if(fabs(itsproton) < nin)
			return AliCDMesonBase::kBinProton;
		else if(fabs(itselectron) < nin)
			return AliCDMesonBase::kBinElectron;
		else{
			return AliCDMesonBase::kBinPIDUnknown;
		}
	}

	tpcpion     = pid->NumberOfSigmasTPC( trk, AliPID::kPion );
	tpckaon     = pid->NumberOfSigmasTPC( trk, AliPID::kKaon );
	tpcproton   = pid->NumberOfSigmasTPC( trk, AliPID::kProton );
	tpcelectron = pid->NumberOfSigmasTPC( trk, AliPID::kElectron );

	// derive information, whether tof pid is available
	const Bool_t ka = !(trk->GetStatus() & AliESDtrack::kTOFmismatch); 
	const Bool_t kb =  (trk->GetStatus() & AliESDtrack::kTOFpid);
	const Bool_t ktof = ka && kb;

	// retrieve TOF information if available
	if(ktof){
		tofpion = pid->NumberOfSigmasTOF(trk, AliPID::kPion);
		tofkaon = pid->NumberOfSigmasTOF(trk, AliPID::kKaon);
		tofproton = pid->NumberOfSigmasTOF(trk, AliPID::kProton);
		tofelectron = pid->NumberOfSigmasTOF(trk, AliPID::kElectron);
	}

	if (mode == 0) {
		// 2010 cuts for PID
		const Double_t nin = 3.;

		// inclusion + exclusion (either TPC or TOF)
		if((fabs(tpcpion) < nin && fabs(tpckaon) > nin && fabs(tpcproton) > nin
		    && fabs(tpcelectron) > nin) ||
		   (fabs(tofpion) < nin && fabs(tofkaon) > nin && fabs(tofproton) > nin
		    && fabs(tofelectron) > nin))
			return AliCDMesonBase::kBinPionE;
		else if((fabs(tpcpion) > nin && fabs(tpckaon) < nin && fabs(tpcproton) > nin
		         && fabs(tpcelectron) > nin) ||
		        (fabs(tofpion) > nin && fabs(tofkaon) < nin && fabs(tofproton) > nin
		         && fabs(tofelectron) > nin))
			return AliCDMesonBase::kBinKaonE;
		else if((fabs(tpcpion) > nin && fabs(tpckaon) > nin && fabs(tpcproton) < nin
		         && fabs(tpcelectron) > nin) ||
		        (fabs(tofpion) > nin && fabs(tofkaon) > nin && fabs(tofproton) < nin
		         && fabs(tofelectron) > nin))
			return AliCDMesonBase::kBinProtonE;
		else if((fabs(tpcpion) > nin && fabs(tpckaon) > nin && fabs(tpcproton) > nin
		         && fabs(tpcelectron) < nin) ||
		        (fabs(tofpion) > nin && fabs(tofkaon) > nin && fabs(tofproton) > nin
		         && fabs(tofelectron) < nin))
			return AliCDMesonBase::kBinElectronE;
		else if(fabs(tpcpion) < nin && fabs(tofpion) < nin) // inclusion (TPC + TOF)
			return AliCDMesonBase::kBinPion;
		else if(fabs(tpckaon) < nin && fabs(tofkaon) < nin)
			return AliCDMesonBase::kBinKaon;
		else if(fabs(tpcproton) < nin && fabs(tofproton) < nin)
			return AliCDMesonBase::kBinProton;
		else if(fabs(tpcelectron) < nin && fabs(tofelectron) < nin)
			return AliCDMesonBase::kBinElectron;
		else{
			return AliCDMesonBase::kBinPIDUnknown;
		}
	}
	else if (mode == 1) {
		// 2011 cuts for PID in LHC11f
		// TPC: [-3,5] sigma (pion)
		// TOF: 3 sigma for all,
		// only Pion is tuned!
		// ONLY INCLUSION CUTS NO EXCLUSION
		const Double_t nin = 3.;

		if(tpcpion < 4. && tpcpion > -2. && fabs(tofpion) < -3. )
			return AliCDMesonBase::kBinPion;
		else if(fabs(tpckaon) < nin && fabs(tofkaon) < nin)
			return AliCDMesonBase::kBinKaon;
		else if(fabs(tpcproton) < nin &&  fabs(tofproton) < nin)
			return AliCDMesonBase::kBinProton;
		else if(fabs(tpcelectron) < nin &&  fabs(tofelectron) < nin)
			return AliCDMesonBase::kBinElectron;
		else{
			return AliCDMesonBase::kBinPIDUnknown;
		}
	}
	return AliCDMesonBase::kBinPIDUnknown;
}


//==========================================================================
Int_t AliCDMesonUtils::GetPID(Int_t pdgCode)
{
	//
	// determine particle type based on PDG code
	//

	if (TMath::Abs(pdgCode) == 211) return AliCDMesonBase::kBinPionE;
	else if (TMath::Abs(pdgCode) == 321) return AliCDMesonBase::kBinKaonE;
	else if (TMath::Abs(pdgCode) == 2212) return AliCDMesonBase::kBinProtonE;
	else if (TMath::Abs(pdgCode) == 11) return AliCDMesonBase::kBinElectronE;
	else return AliCDMesonBase::kBinPIDUnknown;
}


//------------------------------------------------------------------------------
Int_t AliCDMesonUtils::CombinePID(const Int_t pid[])
{
	//
	// combine the PID result
	//

	// determine return value
	if (pid[0] == pid[1]) { // same result for both tracks
		return pid[0];
	}
	// one track identified with exclusion the other only without
	else if ((pid[0] == AliCDMesonBase::kBinPionE &&
	          pid[1] == AliCDMesonBase::kBinPion) ||
	         (pid[1] == AliCDMesonBase::kBinPionE &&
	          pid[0] == AliCDMesonBase::kBinPion)) {
		return AliCDMesonBase::kBinPion;
	}
	else if ((pid[0] == AliCDMesonBase::kBinKaonE &&
	          pid[1] == AliCDMesonBase::kBinKaon) ||
	         (pid[1] == AliCDMesonBase::kBinKaonE &&
	          pid[0] == AliCDMesonBase::kBinKaon)) {
		return AliCDMesonBase::kBinKaon;
	}
	else if ((pid[0] == AliCDMesonBase::kBinProtonE &&
	          pid[1] == AliCDMesonBase::kBinProton) ||
	         (pid[1] == AliCDMesonBase::kBinProtonE &&
	          pid[0] == AliCDMesonBase::kBinProton)) {
		return AliCDMesonBase::kBinProton;
	}
	else if ((pid[0] == AliCDMesonBase::kBinElectronE &&
	          pid[1] == AliCDMesonBase::kBinElectron) ||
	         (pid[1] == AliCDMesonBase::kBinElectronE &&
	          pid[0] == AliCDMesonBase::kBinElectron)) {
		return AliCDMesonBase::kBinElectron;
	}
	// one track identified and one not
	else if (((pid[0] == AliCDMesonBase::kBinPionE ||
	           pid[0] == AliCDMesonBase::kBinPion) &&
	          pid[1] == AliCDMesonBase::kBinPIDUnknown) ||
	         (pid[1] == AliCDMesonBase::kBinPion &&
	          pid[0] == AliCDMesonBase::kBinPIDUnknown)) {
		return AliCDMesonBase::kBinSinglePion;
	}
	else if (((pid[0] == AliCDMesonBase::kBinKaonE ||
	           pid[0] == AliCDMesonBase::kBinKaon)&&
	          pid[1] == AliCDMesonBase::kBinPIDUnknown) ||
	         (pid[1] == AliCDMesonBase::kBinKaon &&
	          pid[0] == AliCDMesonBase::kBinPIDUnknown)) {
		return AliCDMesonBase::kBinSingleKaon;
	}
	else if (((pid[0] == AliCDMesonBase::kBinProtonE ||
	           pid[0] == AliCDMesonBase::kBinProton) &&
	          pid[1] == AliCDMesonBase::kBinPIDUnknown) ||
	         (pid[1] == AliCDMesonBase::kBinProton &&
	          pid[0] == AliCDMesonBase::kBinPIDUnknown)) {
		return AliCDMesonBase::kBinSingleProton;
	}
	else if (((pid[0] == AliCDMesonBase::kBinElectronE ||
	           pid[0] == AliCDMesonBase::kBinElectron) &&
	          pid[1] == AliCDMesonBase::kBinPIDUnknown) ||
	         (pid[1] == AliCDMesonBase::kBinElectron &&
	          pid[0] == AliCDMesonBase::kBinPIDUnknown)) {
		return AliCDMesonBase::kBinSingleElectron;
	}
	else
		return AliCDMesonBase::kBinPIDUnknown;
}


//------------------------------------------------------------------------------
TLorentzVector AliCDMesonUtils::GetKinematics(const Double_t *pa,
                                              const Double_t *pb,
                                              Double_t ma,
                                              Double_t mb, Double_t& cts)
{
	//
	//get kinematics, cts = cos(theta_{#star})
	//

	TLorentzVector va, vb;
	va.SetXYZM(pa[0], pa[1], pa[2], ma);
	vb.SetXYZM(pb[0], pb[1], pb[2], mb);
	const TLorentzVector sumv = va+vb;

	const TVector3 bv = -sumv.BoostVector();

	va.Boost(bv);
	vb.Boost(bv);

	// 3-vectors in the restframe of the mother particle
	const TVector3 pra = va.Vect();
	const TVector3 prb = vb.Vect();
	const TVector3 diff = pra - prb; // their difference

	cts = (diff.Mag2()-pra.Mag2()-prb.Mag2()) / (-2.*pra.Mag()*prb.Mag());
	// cosine theta star, calculated according to the law-of-cosines

	return sumv;
}


//------------------------------------------------------------------------------
Double_t AliCDMesonUtils::GetOA(const Double_t *pa, const Double_t *pb)
{
	//
	//cosOpeningAngle
	//

	TVector3 va, vb;
	va.SetXYZ(pa[0], pa[1], pa[2]);
	vb.SetXYZ(pb[0], pb[1], pb[2]);

	const TVector3 ua = va.Unit();
	const TVector3 ub = vb.Unit();

	return ua.Dot(ub);
}
 AliCDMesonUtils.cxx:1
 AliCDMesonUtils.cxx:2
 AliCDMesonUtils.cxx:3
 AliCDMesonUtils.cxx:4
 AliCDMesonUtils.cxx:5
 AliCDMesonUtils.cxx:6
 AliCDMesonUtils.cxx:7
 AliCDMesonUtils.cxx:8
 AliCDMesonUtils.cxx:9
 AliCDMesonUtils.cxx:10
 AliCDMesonUtils.cxx:11
 AliCDMesonUtils.cxx:12
 AliCDMesonUtils.cxx:13
 AliCDMesonUtils.cxx:14
 AliCDMesonUtils.cxx:15
 AliCDMesonUtils.cxx:16
 AliCDMesonUtils.cxx:17
 AliCDMesonUtils.cxx:18
 AliCDMesonUtils.cxx:19
 AliCDMesonUtils.cxx:20
 AliCDMesonUtils.cxx:21
 AliCDMesonUtils.cxx:22
 AliCDMesonUtils.cxx:23
 AliCDMesonUtils.cxx:24
 AliCDMesonUtils.cxx:25
 AliCDMesonUtils.cxx:26
 AliCDMesonUtils.cxx:27
 AliCDMesonUtils.cxx:28
 AliCDMesonUtils.cxx:29
 AliCDMesonUtils.cxx:30
 AliCDMesonUtils.cxx:31
 AliCDMesonUtils.cxx:32
 AliCDMesonUtils.cxx:33
 AliCDMesonUtils.cxx:34
 AliCDMesonUtils.cxx:35
 AliCDMesonUtils.cxx:36
 AliCDMesonUtils.cxx:37
 AliCDMesonUtils.cxx:38
 AliCDMesonUtils.cxx:39
 AliCDMesonUtils.cxx:40
 AliCDMesonUtils.cxx:41
 AliCDMesonUtils.cxx:42
 AliCDMesonUtils.cxx:43
 AliCDMesonUtils.cxx:44
 AliCDMesonUtils.cxx:45
 AliCDMesonUtils.cxx:46
 AliCDMesonUtils.cxx:47
 AliCDMesonUtils.cxx:48
 AliCDMesonUtils.cxx:49
 AliCDMesonUtils.cxx:50
 AliCDMesonUtils.cxx:51
 AliCDMesonUtils.cxx:52
 AliCDMesonUtils.cxx:53
 AliCDMesonUtils.cxx:54
 AliCDMesonUtils.cxx:55
 AliCDMesonUtils.cxx:56
 AliCDMesonUtils.cxx:57
 AliCDMesonUtils.cxx:58
 AliCDMesonUtils.cxx:59
 AliCDMesonUtils.cxx:60
 AliCDMesonUtils.cxx:61
 AliCDMesonUtils.cxx:62
 AliCDMesonUtils.cxx:63
 AliCDMesonUtils.cxx:64
 AliCDMesonUtils.cxx:65
 AliCDMesonUtils.cxx:66
 AliCDMesonUtils.cxx:67
 AliCDMesonUtils.cxx:68
 AliCDMesonUtils.cxx:69
 AliCDMesonUtils.cxx:70
 AliCDMesonUtils.cxx:71
 AliCDMesonUtils.cxx:72
 AliCDMesonUtils.cxx:73
 AliCDMesonUtils.cxx:74
 AliCDMesonUtils.cxx:75
 AliCDMesonUtils.cxx:76
 AliCDMesonUtils.cxx:77
 AliCDMesonUtils.cxx:78
 AliCDMesonUtils.cxx:79
 AliCDMesonUtils.cxx:80
 AliCDMesonUtils.cxx:81
 AliCDMesonUtils.cxx:82
 AliCDMesonUtils.cxx:83
 AliCDMesonUtils.cxx:84
 AliCDMesonUtils.cxx:85
 AliCDMesonUtils.cxx:86
 AliCDMesonUtils.cxx:87
 AliCDMesonUtils.cxx:88
 AliCDMesonUtils.cxx:89
 AliCDMesonUtils.cxx:90
 AliCDMesonUtils.cxx:91
 AliCDMesonUtils.cxx:92
 AliCDMesonUtils.cxx:93
 AliCDMesonUtils.cxx:94
 AliCDMesonUtils.cxx:95
 AliCDMesonUtils.cxx:96
 AliCDMesonUtils.cxx:97
 AliCDMesonUtils.cxx:98
 AliCDMesonUtils.cxx:99
 AliCDMesonUtils.cxx:100
 AliCDMesonUtils.cxx:101
 AliCDMesonUtils.cxx:102
 AliCDMesonUtils.cxx:103
 AliCDMesonUtils.cxx:104
 AliCDMesonUtils.cxx:105
 AliCDMesonUtils.cxx:106
 AliCDMesonUtils.cxx:107
 AliCDMesonUtils.cxx:108
 AliCDMesonUtils.cxx:109
 AliCDMesonUtils.cxx:110
 AliCDMesonUtils.cxx:111
 AliCDMesonUtils.cxx:112
 AliCDMesonUtils.cxx:113
 AliCDMesonUtils.cxx:114
 AliCDMesonUtils.cxx:115
 AliCDMesonUtils.cxx:116
 AliCDMesonUtils.cxx:117
 AliCDMesonUtils.cxx:118
 AliCDMesonUtils.cxx:119
 AliCDMesonUtils.cxx:120
 AliCDMesonUtils.cxx:121
 AliCDMesonUtils.cxx:122
 AliCDMesonUtils.cxx:123
 AliCDMesonUtils.cxx:124
 AliCDMesonUtils.cxx:125
 AliCDMesonUtils.cxx:126
 AliCDMesonUtils.cxx:127
 AliCDMesonUtils.cxx:128
 AliCDMesonUtils.cxx:129
 AliCDMesonUtils.cxx:130
 AliCDMesonUtils.cxx:131
 AliCDMesonUtils.cxx:132
 AliCDMesonUtils.cxx:133
 AliCDMesonUtils.cxx:134
 AliCDMesonUtils.cxx:135
 AliCDMesonUtils.cxx:136
 AliCDMesonUtils.cxx:137
 AliCDMesonUtils.cxx:138
 AliCDMesonUtils.cxx:139
 AliCDMesonUtils.cxx:140
 AliCDMesonUtils.cxx:141
 AliCDMesonUtils.cxx:142
 AliCDMesonUtils.cxx:143
 AliCDMesonUtils.cxx:144
 AliCDMesonUtils.cxx:145
 AliCDMesonUtils.cxx:146
 AliCDMesonUtils.cxx:147
 AliCDMesonUtils.cxx:148
 AliCDMesonUtils.cxx:149
 AliCDMesonUtils.cxx:150
 AliCDMesonUtils.cxx:151
 AliCDMesonUtils.cxx:152
 AliCDMesonUtils.cxx:153
 AliCDMesonUtils.cxx:154
 AliCDMesonUtils.cxx:155
 AliCDMesonUtils.cxx:156
 AliCDMesonUtils.cxx:157
 AliCDMesonUtils.cxx:158
 AliCDMesonUtils.cxx:159
 AliCDMesonUtils.cxx:160
 AliCDMesonUtils.cxx:161
 AliCDMesonUtils.cxx:162
 AliCDMesonUtils.cxx:163
 AliCDMesonUtils.cxx:164
 AliCDMesonUtils.cxx:165
 AliCDMesonUtils.cxx:166
 AliCDMesonUtils.cxx:167
 AliCDMesonUtils.cxx:168
 AliCDMesonUtils.cxx:169
 AliCDMesonUtils.cxx:170
 AliCDMesonUtils.cxx:171
 AliCDMesonUtils.cxx:172
 AliCDMesonUtils.cxx:173
 AliCDMesonUtils.cxx:174
 AliCDMesonUtils.cxx:175
 AliCDMesonUtils.cxx:176
 AliCDMesonUtils.cxx:177
 AliCDMesonUtils.cxx:178
 AliCDMesonUtils.cxx:179
 AliCDMesonUtils.cxx:180
 AliCDMesonUtils.cxx:181
 AliCDMesonUtils.cxx:182
 AliCDMesonUtils.cxx:183
 AliCDMesonUtils.cxx:184
 AliCDMesonUtils.cxx:185
 AliCDMesonUtils.cxx:186
 AliCDMesonUtils.cxx:187
 AliCDMesonUtils.cxx:188
 AliCDMesonUtils.cxx:189
 AliCDMesonUtils.cxx:190
 AliCDMesonUtils.cxx:191
 AliCDMesonUtils.cxx:192
 AliCDMesonUtils.cxx:193
 AliCDMesonUtils.cxx:194
 AliCDMesonUtils.cxx:195
 AliCDMesonUtils.cxx:196
 AliCDMesonUtils.cxx:197
 AliCDMesonUtils.cxx:198
 AliCDMesonUtils.cxx:199
 AliCDMesonUtils.cxx:200
 AliCDMesonUtils.cxx:201
 AliCDMesonUtils.cxx:202
 AliCDMesonUtils.cxx:203
 AliCDMesonUtils.cxx:204
 AliCDMesonUtils.cxx:205
 AliCDMesonUtils.cxx:206
 AliCDMesonUtils.cxx:207
 AliCDMesonUtils.cxx:208
 AliCDMesonUtils.cxx:209
 AliCDMesonUtils.cxx:210
 AliCDMesonUtils.cxx:211
 AliCDMesonUtils.cxx:212
 AliCDMesonUtils.cxx:213
 AliCDMesonUtils.cxx:214
 AliCDMesonUtils.cxx:215
 AliCDMesonUtils.cxx:216
 AliCDMesonUtils.cxx:217
 AliCDMesonUtils.cxx:218
 AliCDMesonUtils.cxx:219
 AliCDMesonUtils.cxx:220
 AliCDMesonUtils.cxx:221
 AliCDMesonUtils.cxx:222
 AliCDMesonUtils.cxx:223
 AliCDMesonUtils.cxx:224
 AliCDMesonUtils.cxx:225
 AliCDMesonUtils.cxx:226
 AliCDMesonUtils.cxx:227
 AliCDMesonUtils.cxx:228
 AliCDMesonUtils.cxx:229
 AliCDMesonUtils.cxx:230
 AliCDMesonUtils.cxx:231
 AliCDMesonUtils.cxx:232
 AliCDMesonUtils.cxx:233
 AliCDMesonUtils.cxx:234
 AliCDMesonUtils.cxx:235
 AliCDMesonUtils.cxx:236
 AliCDMesonUtils.cxx:237
 AliCDMesonUtils.cxx:238
 AliCDMesonUtils.cxx:239
 AliCDMesonUtils.cxx:240
 AliCDMesonUtils.cxx:241
 AliCDMesonUtils.cxx:242
 AliCDMesonUtils.cxx:243
 AliCDMesonUtils.cxx:244
 AliCDMesonUtils.cxx:245
 AliCDMesonUtils.cxx:246
 AliCDMesonUtils.cxx:247
 AliCDMesonUtils.cxx:248
 AliCDMesonUtils.cxx:249
 AliCDMesonUtils.cxx:250
 AliCDMesonUtils.cxx:251
 AliCDMesonUtils.cxx:252
 AliCDMesonUtils.cxx:253
 AliCDMesonUtils.cxx:254
 AliCDMesonUtils.cxx:255
 AliCDMesonUtils.cxx:256
 AliCDMesonUtils.cxx:257
 AliCDMesonUtils.cxx:258
 AliCDMesonUtils.cxx:259
 AliCDMesonUtils.cxx:260
 AliCDMesonUtils.cxx:261
 AliCDMesonUtils.cxx:262
 AliCDMesonUtils.cxx:263
 AliCDMesonUtils.cxx:264
 AliCDMesonUtils.cxx:265
 AliCDMesonUtils.cxx:266
 AliCDMesonUtils.cxx:267
 AliCDMesonUtils.cxx:268
 AliCDMesonUtils.cxx:269
 AliCDMesonUtils.cxx:270
 AliCDMesonUtils.cxx:271
 AliCDMesonUtils.cxx:272
 AliCDMesonUtils.cxx:273
 AliCDMesonUtils.cxx:274
 AliCDMesonUtils.cxx:275
 AliCDMesonUtils.cxx:276
 AliCDMesonUtils.cxx:277
 AliCDMesonUtils.cxx:278
 AliCDMesonUtils.cxx:279
 AliCDMesonUtils.cxx:280
 AliCDMesonUtils.cxx:281
 AliCDMesonUtils.cxx:282
 AliCDMesonUtils.cxx:283
 AliCDMesonUtils.cxx:284
 AliCDMesonUtils.cxx:285
 AliCDMesonUtils.cxx:286
 AliCDMesonUtils.cxx:287
 AliCDMesonUtils.cxx:288
 AliCDMesonUtils.cxx:289
 AliCDMesonUtils.cxx:290
 AliCDMesonUtils.cxx:291
 AliCDMesonUtils.cxx:292
 AliCDMesonUtils.cxx:293
 AliCDMesonUtils.cxx:294
 AliCDMesonUtils.cxx:295
 AliCDMesonUtils.cxx:296
 AliCDMesonUtils.cxx:297
 AliCDMesonUtils.cxx:298
 AliCDMesonUtils.cxx:299
 AliCDMesonUtils.cxx:300
 AliCDMesonUtils.cxx:301
 AliCDMesonUtils.cxx:302
 AliCDMesonUtils.cxx:303
 AliCDMesonUtils.cxx:304
 AliCDMesonUtils.cxx:305
 AliCDMesonUtils.cxx:306
 AliCDMesonUtils.cxx:307
 AliCDMesonUtils.cxx:308
 AliCDMesonUtils.cxx:309
 AliCDMesonUtils.cxx:310
 AliCDMesonUtils.cxx:311
 AliCDMesonUtils.cxx:312
 AliCDMesonUtils.cxx:313
 AliCDMesonUtils.cxx:314
 AliCDMesonUtils.cxx:315
 AliCDMesonUtils.cxx:316
 AliCDMesonUtils.cxx:317
 AliCDMesonUtils.cxx:318
 AliCDMesonUtils.cxx:319
 AliCDMesonUtils.cxx:320
 AliCDMesonUtils.cxx:321
 AliCDMesonUtils.cxx:322
 AliCDMesonUtils.cxx:323
 AliCDMesonUtils.cxx:324
 AliCDMesonUtils.cxx:325
 AliCDMesonUtils.cxx:326
 AliCDMesonUtils.cxx:327
 AliCDMesonUtils.cxx:328
 AliCDMesonUtils.cxx:329
 AliCDMesonUtils.cxx:330
 AliCDMesonUtils.cxx:331
 AliCDMesonUtils.cxx:332
 AliCDMesonUtils.cxx:333
 AliCDMesonUtils.cxx:334
 AliCDMesonUtils.cxx:335
 AliCDMesonUtils.cxx:336
 AliCDMesonUtils.cxx:337
 AliCDMesonUtils.cxx:338
 AliCDMesonUtils.cxx:339
 AliCDMesonUtils.cxx:340
 AliCDMesonUtils.cxx:341
 AliCDMesonUtils.cxx:342
 AliCDMesonUtils.cxx:343
 AliCDMesonUtils.cxx:344
 AliCDMesonUtils.cxx:345
 AliCDMesonUtils.cxx:346
 AliCDMesonUtils.cxx:347
 AliCDMesonUtils.cxx:348
 AliCDMesonUtils.cxx:349
 AliCDMesonUtils.cxx:350
 AliCDMesonUtils.cxx:351
 AliCDMesonUtils.cxx:352
 AliCDMesonUtils.cxx:353
 AliCDMesonUtils.cxx:354
 AliCDMesonUtils.cxx:355
 AliCDMesonUtils.cxx:356
 AliCDMesonUtils.cxx:357
 AliCDMesonUtils.cxx:358
 AliCDMesonUtils.cxx:359
 AliCDMesonUtils.cxx:360
 AliCDMesonUtils.cxx:361
 AliCDMesonUtils.cxx:362
 AliCDMesonUtils.cxx:363
 AliCDMesonUtils.cxx:364
 AliCDMesonUtils.cxx:365
 AliCDMesonUtils.cxx:366
 AliCDMesonUtils.cxx:367
 AliCDMesonUtils.cxx:368
 AliCDMesonUtils.cxx:369
 AliCDMesonUtils.cxx:370
 AliCDMesonUtils.cxx:371
 AliCDMesonUtils.cxx:372
 AliCDMesonUtils.cxx:373
 AliCDMesonUtils.cxx:374
 AliCDMesonUtils.cxx:375
 AliCDMesonUtils.cxx:376
 AliCDMesonUtils.cxx:377
 AliCDMesonUtils.cxx:378
 AliCDMesonUtils.cxx:379
 AliCDMesonUtils.cxx:380
 AliCDMesonUtils.cxx:381
 AliCDMesonUtils.cxx:382
 AliCDMesonUtils.cxx:383
 AliCDMesonUtils.cxx:384
 AliCDMesonUtils.cxx:385
 AliCDMesonUtils.cxx:386
 AliCDMesonUtils.cxx:387
 AliCDMesonUtils.cxx:388
 AliCDMesonUtils.cxx:389
 AliCDMesonUtils.cxx:390
 AliCDMesonUtils.cxx:391
 AliCDMesonUtils.cxx:392
 AliCDMesonUtils.cxx:393
 AliCDMesonUtils.cxx:394
 AliCDMesonUtils.cxx:395
 AliCDMesonUtils.cxx:396
 AliCDMesonUtils.cxx:397
 AliCDMesonUtils.cxx:398
 AliCDMesonUtils.cxx:399
 AliCDMesonUtils.cxx:400
 AliCDMesonUtils.cxx:401
 AliCDMesonUtils.cxx:402
 AliCDMesonUtils.cxx:403
 AliCDMesonUtils.cxx:404
 AliCDMesonUtils.cxx:405
 AliCDMesonUtils.cxx:406
 AliCDMesonUtils.cxx:407
 AliCDMesonUtils.cxx:408
 AliCDMesonUtils.cxx:409
 AliCDMesonUtils.cxx:410
 AliCDMesonUtils.cxx:411
 AliCDMesonUtils.cxx:412
 AliCDMesonUtils.cxx:413
 AliCDMesonUtils.cxx:414
 AliCDMesonUtils.cxx:415
 AliCDMesonUtils.cxx:416
 AliCDMesonUtils.cxx:417
 AliCDMesonUtils.cxx:418
 AliCDMesonUtils.cxx:419
 AliCDMesonUtils.cxx:420
 AliCDMesonUtils.cxx:421
 AliCDMesonUtils.cxx:422
 AliCDMesonUtils.cxx:423
 AliCDMesonUtils.cxx:424
 AliCDMesonUtils.cxx:425
 AliCDMesonUtils.cxx:426
 AliCDMesonUtils.cxx:427
 AliCDMesonUtils.cxx:428
 AliCDMesonUtils.cxx:429
 AliCDMesonUtils.cxx:430
 AliCDMesonUtils.cxx:431
 AliCDMesonUtils.cxx:432
 AliCDMesonUtils.cxx:433
 AliCDMesonUtils.cxx:434
 AliCDMesonUtils.cxx:435
 AliCDMesonUtils.cxx:436
 AliCDMesonUtils.cxx:437
 AliCDMesonUtils.cxx:438
 AliCDMesonUtils.cxx:439
 AliCDMesonUtils.cxx:440
 AliCDMesonUtils.cxx:441
 AliCDMesonUtils.cxx:442
 AliCDMesonUtils.cxx:443
 AliCDMesonUtils.cxx:444
 AliCDMesonUtils.cxx:445
 AliCDMesonUtils.cxx:446
 AliCDMesonUtils.cxx:447
 AliCDMesonUtils.cxx:448
 AliCDMesonUtils.cxx:449
 AliCDMesonUtils.cxx:450
 AliCDMesonUtils.cxx:451
 AliCDMesonUtils.cxx:452
 AliCDMesonUtils.cxx:453
 AliCDMesonUtils.cxx:454
 AliCDMesonUtils.cxx:455
 AliCDMesonUtils.cxx:456
 AliCDMesonUtils.cxx:457
 AliCDMesonUtils.cxx:458
 AliCDMesonUtils.cxx:459
 AliCDMesonUtils.cxx:460
 AliCDMesonUtils.cxx:461
 AliCDMesonUtils.cxx:462
 AliCDMesonUtils.cxx:463
 AliCDMesonUtils.cxx:464
 AliCDMesonUtils.cxx:465
 AliCDMesonUtils.cxx:466
 AliCDMesonUtils.cxx:467
 AliCDMesonUtils.cxx:468
 AliCDMesonUtils.cxx:469
 AliCDMesonUtils.cxx:470
 AliCDMesonUtils.cxx:471
 AliCDMesonUtils.cxx:472
 AliCDMesonUtils.cxx:473
 AliCDMesonUtils.cxx:474
 AliCDMesonUtils.cxx:475
 AliCDMesonUtils.cxx:476
 AliCDMesonUtils.cxx:477
 AliCDMesonUtils.cxx:478
 AliCDMesonUtils.cxx:479
 AliCDMesonUtils.cxx:480
 AliCDMesonUtils.cxx:481
 AliCDMesonUtils.cxx:482
 AliCDMesonUtils.cxx:483
 AliCDMesonUtils.cxx:484
 AliCDMesonUtils.cxx:485
 AliCDMesonUtils.cxx:486
 AliCDMesonUtils.cxx:487
 AliCDMesonUtils.cxx:488
 AliCDMesonUtils.cxx:489
 AliCDMesonUtils.cxx:490
 AliCDMesonUtils.cxx:491
 AliCDMesonUtils.cxx:492
 AliCDMesonUtils.cxx:493
 AliCDMesonUtils.cxx:494
 AliCDMesonUtils.cxx:495
 AliCDMesonUtils.cxx:496
 AliCDMesonUtils.cxx:497
 AliCDMesonUtils.cxx:498
 AliCDMesonUtils.cxx:499
 AliCDMesonUtils.cxx:500
 AliCDMesonUtils.cxx:501
 AliCDMesonUtils.cxx:502
 AliCDMesonUtils.cxx:503
 AliCDMesonUtils.cxx:504
 AliCDMesonUtils.cxx:505
 AliCDMesonUtils.cxx:506
 AliCDMesonUtils.cxx:507
 AliCDMesonUtils.cxx:508
 AliCDMesonUtils.cxx:509
 AliCDMesonUtils.cxx:510
 AliCDMesonUtils.cxx:511
 AliCDMesonUtils.cxx:512
 AliCDMesonUtils.cxx:513
 AliCDMesonUtils.cxx:514
 AliCDMesonUtils.cxx:515
 AliCDMesonUtils.cxx:516
 AliCDMesonUtils.cxx:517
 AliCDMesonUtils.cxx:518
 AliCDMesonUtils.cxx:519
 AliCDMesonUtils.cxx:520
 AliCDMesonUtils.cxx:521
 AliCDMesonUtils.cxx:522
 AliCDMesonUtils.cxx:523
 AliCDMesonUtils.cxx:524
 AliCDMesonUtils.cxx:525
 AliCDMesonUtils.cxx:526
 AliCDMesonUtils.cxx:527
 AliCDMesonUtils.cxx:528
 AliCDMesonUtils.cxx:529
 AliCDMesonUtils.cxx:530
 AliCDMesonUtils.cxx:531
 AliCDMesonUtils.cxx:532
 AliCDMesonUtils.cxx:533
 AliCDMesonUtils.cxx:534
 AliCDMesonUtils.cxx:535
 AliCDMesonUtils.cxx:536
 AliCDMesonUtils.cxx:537
 AliCDMesonUtils.cxx:538
 AliCDMesonUtils.cxx:539
 AliCDMesonUtils.cxx:540
 AliCDMesonUtils.cxx:541
 AliCDMesonUtils.cxx:542
 AliCDMesonUtils.cxx:543
 AliCDMesonUtils.cxx:544
 AliCDMesonUtils.cxx:545
 AliCDMesonUtils.cxx:546
 AliCDMesonUtils.cxx:547
 AliCDMesonUtils.cxx:548
 AliCDMesonUtils.cxx:549
 AliCDMesonUtils.cxx:550
 AliCDMesonUtils.cxx:551
 AliCDMesonUtils.cxx:552
 AliCDMesonUtils.cxx:553
 AliCDMesonUtils.cxx:554
 AliCDMesonUtils.cxx:555
 AliCDMesonUtils.cxx:556
 AliCDMesonUtils.cxx:557
 AliCDMesonUtils.cxx:558
 AliCDMesonUtils.cxx:559
 AliCDMesonUtils.cxx:560
 AliCDMesonUtils.cxx:561
 AliCDMesonUtils.cxx:562
 AliCDMesonUtils.cxx:563
 AliCDMesonUtils.cxx:564
 AliCDMesonUtils.cxx:565
 AliCDMesonUtils.cxx:566
 AliCDMesonUtils.cxx:567
 AliCDMesonUtils.cxx:568
 AliCDMesonUtils.cxx:569
 AliCDMesonUtils.cxx:570
 AliCDMesonUtils.cxx:571
 AliCDMesonUtils.cxx:572
 AliCDMesonUtils.cxx:573
 AliCDMesonUtils.cxx:574
 AliCDMesonUtils.cxx:575
 AliCDMesonUtils.cxx:576
 AliCDMesonUtils.cxx:577
 AliCDMesonUtils.cxx:578
 AliCDMesonUtils.cxx:579
 AliCDMesonUtils.cxx:580
 AliCDMesonUtils.cxx:581
 AliCDMesonUtils.cxx:582
 AliCDMesonUtils.cxx:583
 AliCDMesonUtils.cxx:584
 AliCDMesonUtils.cxx:585
 AliCDMesonUtils.cxx:586
 AliCDMesonUtils.cxx:587
 AliCDMesonUtils.cxx:588
 AliCDMesonUtils.cxx:589
 AliCDMesonUtils.cxx:590
 AliCDMesonUtils.cxx:591
 AliCDMesonUtils.cxx:592
 AliCDMesonUtils.cxx:593
 AliCDMesonUtils.cxx:594
 AliCDMesonUtils.cxx:595
 AliCDMesonUtils.cxx:596
 AliCDMesonUtils.cxx:597
 AliCDMesonUtils.cxx:598
 AliCDMesonUtils.cxx:599
 AliCDMesonUtils.cxx:600
 AliCDMesonUtils.cxx:601
 AliCDMesonUtils.cxx:602
 AliCDMesonUtils.cxx:603
 AliCDMesonUtils.cxx:604
 AliCDMesonUtils.cxx:605
 AliCDMesonUtils.cxx:606
 AliCDMesonUtils.cxx:607
 AliCDMesonUtils.cxx:608
 AliCDMesonUtils.cxx:609
 AliCDMesonUtils.cxx:610
 AliCDMesonUtils.cxx:611
 AliCDMesonUtils.cxx:612
 AliCDMesonUtils.cxx:613
 AliCDMesonUtils.cxx:614
 AliCDMesonUtils.cxx:615
 AliCDMesonUtils.cxx:616
 AliCDMesonUtils.cxx:617
 AliCDMesonUtils.cxx:618
 AliCDMesonUtils.cxx:619
 AliCDMesonUtils.cxx:620
 AliCDMesonUtils.cxx:621
 AliCDMesonUtils.cxx:622
 AliCDMesonUtils.cxx:623
 AliCDMesonUtils.cxx:624
 AliCDMesonUtils.cxx:625
 AliCDMesonUtils.cxx:626
 AliCDMesonUtils.cxx:627
 AliCDMesonUtils.cxx:628
 AliCDMesonUtils.cxx:629
 AliCDMesonUtils.cxx:630
 AliCDMesonUtils.cxx:631
 AliCDMesonUtils.cxx:632
 AliCDMesonUtils.cxx:633
 AliCDMesonUtils.cxx:634
 AliCDMesonUtils.cxx:635
 AliCDMesonUtils.cxx:636
 AliCDMesonUtils.cxx:637
 AliCDMesonUtils.cxx:638
 AliCDMesonUtils.cxx:639
 AliCDMesonUtils.cxx:640
 AliCDMesonUtils.cxx:641
 AliCDMesonUtils.cxx:642
 AliCDMesonUtils.cxx:643
 AliCDMesonUtils.cxx:644
 AliCDMesonUtils.cxx:645
 AliCDMesonUtils.cxx:646
 AliCDMesonUtils.cxx:647
 AliCDMesonUtils.cxx:648
 AliCDMesonUtils.cxx:649
 AliCDMesonUtils.cxx:650
 AliCDMesonUtils.cxx:651
 AliCDMesonUtils.cxx:652
 AliCDMesonUtils.cxx:653
 AliCDMesonUtils.cxx:654
 AliCDMesonUtils.cxx:655
 AliCDMesonUtils.cxx:656
 AliCDMesonUtils.cxx:657
 AliCDMesonUtils.cxx:658
 AliCDMesonUtils.cxx:659
 AliCDMesonUtils.cxx:660
 AliCDMesonUtils.cxx:661
 AliCDMesonUtils.cxx:662
 AliCDMesonUtils.cxx:663
 AliCDMesonUtils.cxx:664
 AliCDMesonUtils.cxx:665
 AliCDMesonUtils.cxx:666
 AliCDMesonUtils.cxx:667
 AliCDMesonUtils.cxx:668
 AliCDMesonUtils.cxx:669
 AliCDMesonUtils.cxx:670
 AliCDMesonUtils.cxx:671
 AliCDMesonUtils.cxx:672
 AliCDMesonUtils.cxx:673
 AliCDMesonUtils.cxx:674
 AliCDMesonUtils.cxx:675
 AliCDMesonUtils.cxx:676
 AliCDMesonUtils.cxx:677
 AliCDMesonUtils.cxx:678
 AliCDMesonUtils.cxx:679
 AliCDMesonUtils.cxx:680
 AliCDMesonUtils.cxx:681
 AliCDMesonUtils.cxx:682
 AliCDMesonUtils.cxx:683
 AliCDMesonUtils.cxx:684
 AliCDMesonUtils.cxx:685
 AliCDMesonUtils.cxx:686
 AliCDMesonUtils.cxx:687
 AliCDMesonUtils.cxx:688
 AliCDMesonUtils.cxx:689
 AliCDMesonUtils.cxx:690
 AliCDMesonUtils.cxx:691
 AliCDMesonUtils.cxx:692
 AliCDMesonUtils.cxx:693
 AliCDMesonUtils.cxx:694
 AliCDMesonUtils.cxx:695
 AliCDMesonUtils.cxx:696
 AliCDMesonUtils.cxx:697
 AliCDMesonUtils.cxx:698
 AliCDMesonUtils.cxx:699
 AliCDMesonUtils.cxx:700
 AliCDMesonUtils.cxx:701
 AliCDMesonUtils.cxx:702
 AliCDMesonUtils.cxx:703
 AliCDMesonUtils.cxx:704
 AliCDMesonUtils.cxx:705
 AliCDMesonUtils.cxx:706
 AliCDMesonUtils.cxx:707
 AliCDMesonUtils.cxx:708
 AliCDMesonUtils.cxx:709
 AliCDMesonUtils.cxx:710
 AliCDMesonUtils.cxx:711
 AliCDMesonUtils.cxx:712
 AliCDMesonUtils.cxx:713
 AliCDMesonUtils.cxx:714
 AliCDMesonUtils.cxx:715
 AliCDMesonUtils.cxx:716
 AliCDMesonUtils.cxx:717
 AliCDMesonUtils.cxx:718
 AliCDMesonUtils.cxx:719
 AliCDMesonUtils.cxx:720
 AliCDMesonUtils.cxx:721
 AliCDMesonUtils.cxx:722
 AliCDMesonUtils.cxx:723
 AliCDMesonUtils.cxx:724
 AliCDMesonUtils.cxx:725
 AliCDMesonUtils.cxx:726
 AliCDMesonUtils.cxx:727
 AliCDMesonUtils.cxx:728
 AliCDMesonUtils.cxx:729
 AliCDMesonUtils.cxx:730
 AliCDMesonUtils.cxx:731
 AliCDMesonUtils.cxx:732
 AliCDMesonUtils.cxx:733
 AliCDMesonUtils.cxx:734
 AliCDMesonUtils.cxx:735
 AliCDMesonUtils.cxx:736
 AliCDMesonUtils.cxx:737
 AliCDMesonUtils.cxx:738
 AliCDMesonUtils.cxx:739
 AliCDMesonUtils.cxx:740
 AliCDMesonUtils.cxx:741
 AliCDMesonUtils.cxx:742
 AliCDMesonUtils.cxx:743
 AliCDMesonUtils.cxx:744
 AliCDMesonUtils.cxx:745
 AliCDMesonUtils.cxx:746
 AliCDMesonUtils.cxx:747
 AliCDMesonUtils.cxx:748
 AliCDMesonUtils.cxx:749
 AliCDMesonUtils.cxx:750
 AliCDMesonUtils.cxx:751
 AliCDMesonUtils.cxx:752
 AliCDMesonUtils.cxx:753
 AliCDMesonUtils.cxx:754
 AliCDMesonUtils.cxx:755
 AliCDMesonUtils.cxx:756
 AliCDMesonUtils.cxx:757
 AliCDMesonUtils.cxx:758
 AliCDMesonUtils.cxx:759
 AliCDMesonUtils.cxx:760
 AliCDMesonUtils.cxx:761
 AliCDMesonUtils.cxx:762
 AliCDMesonUtils.cxx:763
 AliCDMesonUtils.cxx:764
 AliCDMesonUtils.cxx:765
 AliCDMesonUtils.cxx:766
 AliCDMesonUtils.cxx:767
 AliCDMesonUtils.cxx:768
 AliCDMesonUtils.cxx:769
 AliCDMesonUtils.cxx:770
 AliCDMesonUtils.cxx:771
 AliCDMesonUtils.cxx:772
 AliCDMesonUtils.cxx:773
 AliCDMesonUtils.cxx:774
 AliCDMesonUtils.cxx:775
 AliCDMesonUtils.cxx:776
 AliCDMesonUtils.cxx:777
 AliCDMesonUtils.cxx:778
 AliCDMesonUtils.cxx:779
 AliCDMesonUtils.cxx:780
 AliCDMesonUtils.cxx:781
 AliCDMesonUtils.cxx:782
 AliCDMesonUtils.cxx:783
 AliCDMesonUtils.cxx:784
 AliCDMesonUtils.cxx:785
 AliCDMesonUtils.cxx:786
 AliCDMesonUtils.cxx:787
 AliCDMesonUtils.cxx:788
 AliCDMesonUtils.cxx:789
 AliCDMesonUtils.cxx:790
 AliCDMesonUtils.cxx:791
 AliCDMesonUtils.cxx:792
 AliCDMesonUtils.cxx:793
 AliCDMesonUtils.cxx:794
 AliCDMesonUtils.cxx:795
 AliCDMesonUtils.cxx:796
 AliCDMesonUtils.cxx:797
 AliCDMesonUtils.cxx:798
 AliCDMesonUtils.cxx:799
 AliCDMesonUtils.cxx:800
 AliCDMesonUtils.cxx:801
 AliCDMesonUtils.cxx:802
 AliCDMesonUtils.cxx:803
 AliCDMesonUtils.cxx:804
 AliCDMesonUtils.cxx:805
 AliCDMesonUtils.cxx:806
 AliCDMesonUtils.cxx:807
 AliCDMesonUtils.cxx:808
 AliCDMesonUtils.cxx:809
 AliCDMesonUtils.cxx:810
 AliCDMesonUtils.cxx:811
 AliCDMesonUtils.cxx:812
 AliCDMesonUtils.cxx:813
 AliCDMesonUtils.cxx:814
 AliCDMesonUtils.cxx:815
 AliCDMesonUtils.cxx:816
 AliCDMesonUtils.cxx:817
 AliCDMesonUtils.cxx:818
 AliCDMesonUtils.cxx:819
 AliCDMesonUtils.cxx:820
 AliCDMesonUtils.cxx:821
 AliCDMesonUtils.cxx:822
 AliCDMesonUtils.cxx:823
 AliCDMesonUtils.cxx:824
 AliCDMesonUtils.cxx:825
 AliCDMesonUtils.cxx:826
 AliCDMesonUtils.cxx:827
 AliCDMesonUtils.cxx:828
 AliCDMesonUtils.cxx:829
 AliCDMesonUtils.cxx:830
 AliCDMesonUtils.cxx:831
 AliCDMesonUtils.cxx:832
 AliCDMesonUtils.cxx:833
 AliCDMesonUtils.cxx:834
 AliCDMesonUtils.cxx:835
 AliCDMesonUtils.cxx:836
 AliCDMesonUtils.cxx:837
 AliCDMesonUtils.cxx:838
 AliCDMesonUtils.cxx:839
 AliCDMesonUtils.cxx:840
 AliCDMesonUtils.cxx:841
 AliCDMesonUtils.cxx:842
 AliCDMesonUtils.cxx:843
 AliCDMesonUtils.cxx:844
 AliCDMesonUtils.cxx:845
 AliCDMesonUtils.cxx:846
 AliCDMesonUtils.cxx:847
 AliCDMesonUtils.cxx:848
 AliCDMesonUtils.cxx:849
 AliCDMesonUtils.cxx:850
 AliCDMesonUtils.cxx:851
 AliCDMesonUtils.cxx:852
 AliCDMesonUtils.cxx:853
 AliCDMesonUtils.cxx:854
 AliCDMesonUtils.cxx:855
 AliCDMesonUtils.cxx:856
 AliCDMesonUtils.cxx:857
 AliCDMesonUtils.cxx:858
 AliCDMesonUtils.cxx:859
 AliCDMesonUtils.cxx:860
 AliCDMesonUtils.cxx:861
 AliCDMesonUtils.cxx:862
 AliCDMesonUtils.cxx:863
 AliCDMesonUtils.cxx:864
 AliCDMesonUtils.cxx:865
 AliCDMesonUtils.cxx:866
 AliCDMesonUtils.cxx:867
 AliCDMesonUtils.cxx:868
 AliCDMesonUtils.cxx:869
 AliCDMesonUtils.cxx:870
 AliCDMesonUtils.cxx:871
 AliCDMesonUtils.cxx:872
 AliCDMesonUtils.cxx:873
 AliCDMesonUtils.cxx:874
 AliCDMesonUtils.cxx:875
 AliCDMesonUtils.cxx:876
 AliCDMesonUtils.cxx:877
 AliCDMesonUtils.cxx:878
 AliCDMesonUtils.cxx:879
 AliCDMesonUtils.cxx:880
 AliCDMesonUtils.cxx:881
 AliCDMesonUtils.cxx:882
 AliCDMesonUtils.cxx:883
 AliCDMesonUtils.cxx:884
 AliCDMesonUtils.cxx:885
 AliCDMesonUtils.cxx:886
 AliCDMesonUtils.cxx:887
 AliCDMesonUtils.cxx:888
 AliCDMesonUtils.cxx:889
 AliCDMesonUtils.cxx:890
 AliCDMesonUtils.cxx:891
 AliCDMesonUtils.cxx:892
 AliCDMesonUtils.cxx:893
 AliCDMesonUtils.cxx:894
 AliCDMesonUtils.cxx:895
 AliCDMesonUtils.cxx:896
 AliCDMesonUtils.cxx:897
 AliCDMesonUtils.cxx:898
 AliCDMesonUtils.cxx:899
 AliCDMesonUtils.cxx:900
 AliCDMesonUtils.cxx:901
 AliCDMesonUtils.cxx:902
 AliCDMesonUtils.cxx:903
 AliCDMesonUtils.cxx:904
 AliCDMesonUtils.cxx:905
 AliCDMesonUtils.cxx:906
 AliCDMesonUtils.cxx:907
 AliCDMesonUtils.cxx:908
 AliCDMesonUtils.cxx:909
 AliCDMesonUtils.cxx:910
 AliCDMesonUtils.cxx:911
 AliCDMesonUtils.cxx:912
 AliCDMesonUtils.cxx:913
 AliCDMesonUtils.cxx:914
 AliCDMesonUtils.cxx:915
 AliCDMesonUtils.cxx:916
 AliCDMesonUtils.cxx:917
 AliCDMesonUtils.cxx:918
 AliCDMesonUtils.cxx:919
 AliCDMesonUtils.cxx:920
 AliCDMesonUtils.cxx:921
 AliCDMesonUtils.cxx:922
 AliCDMesonUtils.cxx:923
 AliCDMesonUtils.cxx:924
 AliCDMesonUtils.cxx:925
 AliCDMesonUtils.cxx:926
 AliCDMesonUtils.cxx:927
 AliCDMesonUtils.cxx:928
 AliCDMesonUtils.cxx:929
 AliCDMesonUtils.cxx:930
 AliCDMesonUtils.cxx:931
 AliCDMesonUtils.cxx:932
 AliCDMesonUtils.cxx:933
 AliCDMesonUtils.cxx:934
 AliCDMesonUtils.cxx:935
 AliCDMesonUtils.cxx:936
 AliCDMesonUtils.cxx:937
 AliCDMesonUtils.cxx:938
 AliCDMesonUtils.cxx:939
 AliCDMesonUtils.cxx:940
 AliCDMesonUtils.cxx:941
 AliCDMesonUtils.cxx:942
 AliCDMesonUtils.cxx:943
 AliCDMesonUtils.cxx:944
 AliCDMesonUtils.cxx:945
 AliCDMesonUtils.cxx:946
 AliCDMesonUtils.cxx:947
 AliCDMesonUtils.cxx:948
 AliCDMesonUtils.cxx:949
 AliCDMesonUtils.cxx:950
 AliCDMesonUtils.cxx:951
 AliCDMesonUtils.cxx:952
 AliCDMesonUtils.cxx:953
 AliCDMesonUtils.cxx:954
 AliCDMesonUtils.cxx:955
 AliCDMesonUtils.cxx:956
 AliCDMesonUtils.cxx:957
 AliCDMesonUtils.cxx:958
 AliCDMesonUtils.cxx:959
 AliCDMesonUtils.cxx:960
 AliCDMesonUtils.cxx:961
 AliCDMesonUtils.cxx:962
 AliCDMesonUtils.cxx:963
 AliCDMesonUtils.cxx:964
 AliCDMesonUtils.cxx:965
 AliCDMesonUtils.cxx:966
 AliCDMesonUtils.cxx:967
 AliCDMesonUtils.cxx:968
 AliCDMesonUtils.cxx:969
 AliCDMesonUtils.cxx:970
 AliCDMesonUtils.cxx:971
 AliCDMesonUtils.cxx:972
 AliCDMesonUtils.cxx:973
 AliCDMesonUtils.cxx:974
 AliCDMesonUtils.cxx:975
 AliCDMesonUtils.cxx:976
 AliCDMesonUtils.cxx:977
 AliCDMesonUtils.cxx:978
 AliCDMesonUtils.cxx:979
 AliCDMesonUtils.cxx:980
 AliCDMesonUtils.cxx:981
 AliCDMesonUtils.cxx:982
 AliCDMesonUtils.cxx:983
 AliCDMesonUtils.cxx:984
 AliCDMesonUtils.cxx:985
 AliCDMesonUtils.cxx:986
 AliCDMesonUtils.cxx:987
 AliCDMesonUtils.cxx:988
 AliCDMesonUtils.cxx:989
 AliCDMesonUtils.cxx:990
 AliCDMesonUtils.cxx:991
 AliCDMesonUtils.cxx:992
 AliCDMesonUtils.cxx:993
 AliCDMesonUtils.cxx:994
 AliCDMesonUtils.cxx:995
 AliCDMesonUtils.cxx:996
 AliCDMesonUtils.cxx:997
 AliCDMesonUtils.cxx:998
 AliCDMesonUtils.cxx:999
 AliCDMesonUtils.cxx:1000
 AliCDMesonUtils.cxx:1001
 AliCDMesonUtils.cxx:1002
 AliCDMesonUtils.cxx:1003
 AliCDMesonUtils.cxx:1004
 AliCDMesonUtils.cxx:1005
 AliCDMesonUtils.cxx:1006
 AliCDMesonUtils.cxx:1007
 AliCDMesonUtils.cxx:1008
 AliCDMesonUtils.cxx:1009
 AliCDMesonUtils.cxx:1010
 AliCDMesonUtils.cxx:1011
 AliCDMesonUtils.cxx:1012
 AliCDMesonUtils.cxx:1013
 AliCDMesonUtils.cxx:1014
 AliCDMesonUtils.cxx:1015
 AliCDMesonUtils.cxx:1016
 AliCDMesonUtils.cxx:1017
 AliCDMesonUtils.cxx:1018
 AliCDMesonUtils.cxx:1019
 AliCDMesonUtils.cxx:1020
 AliCDMesonUtils.cxx:1021
 AliCDMesonUtils.cxx:1022
 AliCDMesonUtils.cxx:1023
 AliCDMesonUtils.cxx:1024
 AliCDMesonUtils.cxx:1025
 AliCDMesonUtils.cxx:1026
 AliCDMesonUtils.cxx:1027
 AliCDMesonUtils.cxx:1028
 AliCDMesonUtils.cxx:1029
 AliCDMesonUtils.cxx:1030
 AliCDMesonUtils.cxx:1031
 AliCDMesonUtils.cxx:1032
 AliCDMesonUtils.cxx:1033
 AliCDMesonUtils.cxx:1034
 AliCDMesonUtils.cxx:1035
 AliCDMesonUtils.cxx:1036
 AliCDMesonUtils.cxx:1037
 AliCDMesonUtils.cxx:1038
 AliCDMesonUtils.cxx:1039
 AliCDMesonUtils.cxx:1040
 AliCDMesonUtils.cxx:1041
 AliCDMesonUtils.cxx:1042
 AliCDMesonUtils.cxx:1043
 AliCDMesonUtils.cxx:1044
 AliCDMesonUtils.cxx:1045
 AliCDMesonUtils.cxx:1046
 AliCDMesonUtils.cxx:1047
 AliCDMesonUtils.cxx:1048
 AliCDMesonUtils.cxx:1049
 AliCDMesonUtils.cxx:1050
 AliCDMesonUtils.cxx:1051
 AliCDMesonUtils.cxx:1052
 AliCDMesonUtils.cxx:1053
 AliCDMesonUtils.cxx:1054
 AliCDMesonUtils.cxx:1055
 AliCDMesonUtils.cxx:1056
 AliCDMesonUtils.cxx:1057
 AliCDMesonUtils.cxx:1058
 AliCDMesonUtils.cxx:1059
 AliCDMesonUtils.cxx:1060
 AliCDMesonUtils.cxx:1061
 AliCDMesonUtils.cxx:1062
 AliCDMesonUtils.cxx:1063
 AliCDMesonUtils.cxx:1064
 AliCDMesonUtils.cxx:1065
 AliCDMesonUtils.cxx:1066
 AliCDMesonUtils.cxx:1067
 AliCDMesonUtils.cxx:1068
 AliCDMesonUtils.cxx:1069
 AliCDMesonUtils.cxx:1070
 AliCDMesonUtils.cxx:1071
 AliCDMesonUtils.cxx:1072
 AliCDMesonUtils.cxx:1073
 AliCDMesonUtils.cxx:1074
 AliCDMesonUtils.cxx:1075
 AliCDMesonUtils.cxx:1076
 AliCDMesonUtils.cxx:1077
 AliCDMesonUtils.cxx:1078
 AliCDMesonUtils.cxx:1079
 AliCDMesonUtils.cxx:1080
 AliCDMesonUtils.cxx:1081
 AliCDMesonUtils.cxx:1082
 AliCDMesonUtils.cxx:1083
 AliCDMesonUtils.cxx:1084
 AliCDMesonUtils.cxx:1085
 AliCDMesonUtils.cxx:1086
 AliCDMesonUtils.cxx:1087
 AliCDMesonUtils.cxx:1088
 AliCDMesonUtils.cxx:1089
 AliCDMesonUtils.cxx:1090
 AliCDMesonUtils.cxx:1091
 AliCDMesonUtils.cxx:1092
 AliCDMesonUtils.cxx:1093
 AliCDMesonUtils.cxx:1094
 AliCDMesonUtils.cxx:1095
 AliCDMesonUtils.cxx:1096
 AliCDMesonUtils.cxx:1097
 AliCDMesonUtils.cxx:1098
 AliCDMesonUtils.cxx:1099
 AliCDMesonUtils.cxx:1100
 AliCDMesonUtils.cxx:1101
 AliCDMesonUtils.cxx:1102
 AliCDMesonUtils.cxx:1103
 AliCDMesonUtils.cxx:1104
 AliCDMesonUtils.cxx:1105
 AliCDMesonUtils.cxx:1106
 AliCDMesonUtils.cxx:1107
 AliCDMesonUtils.cxx:1108
 AliCDMesonUtils.cxx:1109
 AliCDMesonUtils.cxx:1110
 AliCDMesonUtils.cxx:1111
 AliCDMesonUtils.cxx:1112
 AliCDMesonUtils.cxx:1113
 AliCDMesonUtils.cxx:1114
 AliCDMesonUtils.cxx:1115
 AliCDMesonUtils.cxx:1116
 AliCDMesonUtils.cxx:1117
 AliCDMesonUtils.cxx:1118
 AliCDMesonUtils.cxx:1119
 AliCDMesonUtils.cxx:1120
 AliCDMesonUtils.cxx:1121
 AliCDMesonUtils.cxx:1122
 AliCDMesonUtils.cxx:1123
 AliCDMesonUtils.cxx:1124
 AliCDMesonUtils.cxx:1125
 AliCDMesonUtils.cxx:1126
 AliCDMesonUtils.cxx:1127
 AliCDMesonUtils.cxx:1128
 AliCDMesonUtils.cxx:1129
 AliCDMesonUtils.cxx:1130
 AliCDMesonUtils.cxx:1131
 AliCDMesonUtils.cxx:1132
 AliCDMesonUtils.cxx:1133
 AliCDMesonUtils.cxx:1134
 AliCDMesonUtils.cxx:1135
 AliCDMesonUtils.cxx:1136
 AliCDMesonUtils.cxx:1137
 AliCDMesonUtils.cxx:1138
 AliCDMesonUtils.cxx:1139
 AliCDMesonUtils.cxx:1140
 AliCDMesonUtils.cxx:1141
 AliCDMesonUtils.cxx:1142
 AliCDMesonUtils.cxx:1143
 AliCDMesonUtils.cxx:1144
 AliCDMesonUtils.cxx:1145
 AliCDMesonUtils.cxx:1146
 AliCDMesonUtils.cxx:1147
 AliCDMesonUtils.cxx:1148
 AliCDMesonUtils.cxx:1149
 AliCDMesonUtils.cxx:1150
 AliCDMesonUtils.cxx:1151
 AliCDMesonUtils.cxx:1152
 AliCDMesonUtils.cxx:1153
 AliCDMesonUtils.cxx:1154
 AliCDMesonUtils.cxx:1155
 AliCDMesonUtils.cxx:1156
 AliCDMesonUtils.cxx:1157
 AliCDMesonUtils.cxx:1158
 AliCDMesonUtils.cxx:1159
 AliCDMesonUtils.cxx:1160
 AliCDMesonUtils.cxx:1161
 AliCDMesonUtils.cxx:1162
 AliCDMesonUtils.cxx:1163
 AliCDMesonUtils.cxx:1164
 AliCDMesonUtils.cxx:1165
 AliCDMesonUtils.cxx:1166
 AliCDMesonUtils.cxx:1167
 AliCDMesonUtils.cxx:1168
 AliCDMesonUtils.cxx:1169
 AliCDMesonUtils.cxx:1170
 AliCDMesonUtils.cxx:1171
 AliCDMesonUtils.cxx:1172
 AliCDMesonUtils.cxx:1173
 AliCDMesonUtils.cxx:1174
 AliCDMesonUtils.cxx:1175
 AliCDMesonUtils.cxx:1176
 AliCDMesonUtils.cxx:1177
 AliCDMesonUtils.cxx:1178
 AliCDMesonUtils.cxx:1179
 AliCDMesonUtils.cxx:1180
 AliCDMesonUtils.cxx:1181
 AliCDMesonUtils.cxx:1182
 AliCDMesonUtils.cxx:1183
 AliCDMesonUtils.cxx:1184
 AliCDMesonUtils.cxx:1185
 AliCDMesonUtils.cxx:1186
 AliCDMesonUtils.cxx:1187
 AliCDMesonUtils.cxx:1188
 AliCDMesonUtils.cxx:1189
 AliCDMesonUtils.cxx:1190
 AliCDMesonUtils.cxx:1191
 AliCDMesonUtils.cxx:1192
 AliCDMesonUtils.cxx:1193
 AliCDMesonUtils.cxx:1194
 AliCDMesonUtils.cxx:1195
 AliCDMesonUtils.cxx:1196
 AliCDMesonUtils.cxx:1197
 AliCDMesonUtils.cxx:1198
 AliCDMesonUtils.cxx:1199
 AliCDMesonUtils.cxx:1200
 AliCDMesonUtils.cxx:1201
 AliCDMesonUtils.cxx:1202
 AliCDMesonUtils.cxx:1203
 AliCDMesonUtils.cxx:1204
 AliCDMesonUtils.cxx:1205
 AliCDMesonUtils.cxx:1206
 AliCDMesonUtils.cxx:1207
 AliCDMesonUtils.cxx:1208
 AliCDMesonUtils.cxx:1209
 AliCDMesonUtils.cxx:1210
 AliCDMesonUtils.cxx:1211
 AliCDMesonUtils.cxx:1212
 AliCDMesonUtils.cxx:1213
 AliCDMesonUtils.cxx:1214
 AliCDMesonUtils.cxx:1215
 AliCDMesonUtils.cxx:1216
 AliCDMesonUtils.cxx:1217
 AliCDMesonUtils.cxx:1218
 AliCDMesonUtils.cxx:1219
 AliCDMesonUtils.cxx:1220
 AliCDMesonUtils.cxx:1221
 AliCDMesonUtils.cxx:1222
 AliCDMesonUtils.cxx:1223
 AliCDMesonUtils.cxx:1224
 AliCDMesonUtils.cxx:1225
 AliCDMesonUtils.cxx:1226
 AliCDMesonUtils.cxx:1227
 AliCDMesonUtils.cxx:1228
 AliCDMesonUtils.cxx:1229
 AliCDMesonUtils.cxx:1230
 AliCDMesonUtils.cxx:1231
 AliCDMesonUtils.cxx:1232
 AliCDMesonUtils.cxx:1233
 AliCDMesonUtils.cxx:1234
 AliCDMesonUtils.cxx:1235
 AliCDMesonUtils.cxx:1236
 AliCDMesonUtils.cxx:1237
 AliCDMesonUtils.cxx:1238
 AliCDMesonUtils.cxx:1239
 AliCDMesonUtils.cxx:1240
 AliCDMesonUtils.cxx:1241
 AliCDMesonUtils.cxx:1242
 AliCDMesonUtils.cxx:1243
 AliCDMesonUtils.cxx:1244
 AliCDMesonUtils.cxx:1245
 AliCDMesonUtils.cxx:1246
 AliCDMesonUtils.cxx:1247
 AliCDMesonUtils.cxx:1248
 AliCDMesonUtils.cxx:1249
 AliCDMesonUtils.cxx:1250
 AliCDMesonUtils.cxx:1251
 AliCDMesonUtils.cxx:1252
 AliCDMesonUtils.cxx:1253
 AliCDMesonUtils.cxx:1254
 AliCDMesonUtils.cxx:1255
 AliCDMesonUtils.cxx:1256
 AliCDMesonUtils.cxx:1257
 AliCDMesonUtils.cxx:1258
 AliCDMesonUtils.cxx:1259
 AliCDMesonUtils.cxx:1260
 AliCDMesonUtils.cxx:1261
 AliCDMesonUtils.cxx:1262
 AliCDMesonUtils.cxx:1263
 AliCDMesonUtils.cxx:1264
 AliCDMesonUtils.cxx:1265
 AliCDMesonUtils.cxx:1266
 AliCDMesonUtils.cxx:1267
 AliCDMesonUtils.cxx:1268
 AliCDMesonUtils.cxx:1269
 AliCDMesonUtils.cxx:1270
 AliCDMesonUtils.cxx:1271
 AliCDMesonUtils.cxx:1272
 AliCDMesonUtils.cxx:1273
 AliCDMesonUtils.cxx:1274
 AliCDMesonUtils.cxx:1275
 AliCDMesonUtils.cxx:1276
 AliCDMesonUtils.cxx:1277
 AliCDMesonUtils.cxx:1278
 AliCDMesonUtils.cxx:1279
 AliCDMesonUtils.cxx:1280
 AliCDMesonUtils.cxx:1281
 AliCDMesonUtils.cxx:1282
 AliCDMesonUtils.cxx:1283
 AliCDMesonUtils.cxx:1284
 AliCDMesonUtils.cxx:1285
 AliCDMesonUtils.cxx:1286
 AliCDMesonUtils.cxx:1287
 AliCDMesonUtils.cxx:1288
 AliCDMesonUtils.cxx:1289
 AliCDMesonUtils.cxx:1290
 AliCDMesonUtils.cxx:1291
 AliCDMesonUtils.cxx:1292
 AliCDMesonUtils.cxx:1293
 AliCDMesonUtils.cxx:1294
 AliCDMesonUtils.cxx:1295
 AliCDMesonUtils.cxx:1296
 AliCDMesonUtils.cxx:1297
 AliCDMesonUtils.cxx:1298
 AliCDMesonUtils.cxx:1299
 AliCDMesonUtils.cxx:1300
 AliCDMesonUtils.cxx:1301
 AliCDMesonUtils.cxx:1302
 AliCDMesonUtils.cxx:1303
 AliCDMesonUtils.cxx:1304
 AliCDMesonUtils.cxx:1305
 AliCDMesonUtils.cxx:1306
 AliCDMesonUtils.cxx:1307
 AliCDMesonUtils.cxx:1308
 AliCDMesonUtils.cxx:1309
 AliCDMesonUtils.cxx:1310
 AliCDMesonUtils.cxx:1311
 AliCDMesonUtils.cxx:1312
 AliCDMesonUtils.cxx:1313
 AliCDMesonUtils.cxx:1314
 AliCDMesonUtils.cxx:1315
 AliCDMesonUtils.cxx:1316
 AliCDMesonUtils.cxx:1317
 AliCDMesonUtils.cxx:1318
 AliCDMesonUtils.cxx:1319
 AliCDMesonUtils.cxx:1320
 AliCDMesonUtils.cxx:1321
 AliCDMesonUtils.cxx:1322
 AliCDMesonUtils.cxx:1323
 AliCDMesonUtils.cxx:1324
 AliCDMesonUtils.cxx:1325
 AliCDMesonUtils.cxx:1326
 AliCDMesonUtils.cxx:1327
 AliCDMesonUtils.cxx:1328
 AliCDMesonUtils.cxx:1329
 AliCDMesonUtils.cxx:1330
 AliCDMesonUtils.cxx:1331
 AliCDMesonUtils.cxx:1332
 AliCDMesonUtils.cxx:1333
 AliCDMesonUtils.cxx:1334
 AliCDMesonUtils.cxx:1335
 AliCDMesonUtils.cxx:1336
 AliCDMesonUtils.cxx:1337
 AliCDMesonUtils.cxx:1338
 AliCDMesonUtils.cxx:1339
 AliCDMesonUtils.cxx:1340
 AliCDMesonUtils.cxx:1341
 AliCDMesonUtils.cxx:1342
 AliCDMesonUtils.cxx:1343
 AliCDMesonUtils.cxx:1344
 AliCDMesonUtils.cxx:1345
 AliCDMesonUtils.cxx:1346
 AliCDMesonUtils.cxx:1347
 AliCDMesonUtils.cxx:1348
 AliCDMesonUtils.cxx:1349
 AliCDMesonUtils.cxx:1350
 AliCDMesonUtils.cxx:1351
 AliCDMesonUtils.cxx:1352
 AliCDMesonUtils.cxx:1353
 AliCDMesonUtils.cxx:1354
 AliCDMesonUtils.cxx:1355
 AliCDMesonUtils.cxx:1356
 AliCDMesonUtils.cxx:1357
 AliCDMesonUtils.cxx:1358
 AliCDMesonUtils.cxx:1359
 AliCDMesonUtils.cxx:1360
 AliCDMesonUtils.cxx:1361
 AliCDMesonUtils.cxx:1362
 AliCDMesonUtils.cxx:1363
 AliCDMesonUtils.cxx:1364
 AliCDMesonUtils.cxx:1365
 AliCDMesonUtils.cxx:1366
 AliCDMesonUtils.cxx:1367
 AliCDMesonUtils.cxx:1368
 AliCDMesonUtils.cxx:1369
 AliCDMesonUtils.cxx:1370
 AliCDMesonUtils.cxx:1371
 AliCDMesonUtils.cxx:1372
 AliCDMesonUtils.cxx:1373
 AliCDMesonUtils.cxx:1374
 AliCDMesonUtils.cxx:1375
 AliCDMesonUtils.cxx:1376
 AliCDMesonUtils.cxx:1377
 AliCDMesonUtils.cxx:1378
 AliCDMesonUtils.cxx:1379
 AliCDMesonUtils.cxx:1380
 AliCDMesonUtils.cxx:1381
 AliCDMesonUtils.cxx:1382
 AliCDMesonUtils.cxx:1383
 AliCDMesonUtils.cxx:1384
 AliCDMesonUtils.cxx:1385
 AliCDMesonUtils.cxx:1386
 AliCDMesonUtils.cxx:1387
 AliCDMesonUtils.cxx:1388
 AliCDMesonUtils.cxx:1389
 AliCDMesonUtils.cxx:1390
 AliCDMesonUtils.cxx:1391
 AliCDMesonUtils.cxx:1392
 AliCDMesonUtils.cxx:1393
 AliCDMesonUtils.cxx:1394
 AliCDMesonUtils.cxx:1395
 AliCDMesonUtils.cxx:1396
 AliCDMesonUtils.cxx:1397
 AliCDMesonUtils.cxx:1398
 AliCDMesonUtils.cxx:1399
 AliCDMesonUtils.cxx:1400
 AliCDMesonUtils.cxx:1401
 AliCDMesonUtils.cxx:1402
 AliCDMesonUtils.cxx:1403
 AliCDMesonUtils.cxx:1404
 AliCDMesonUtils.cxx:1405
 AliCDMesonUtils.cxx:1406
 AliCDMesonUtils.cxx:1407
 AliCDMesonUtils.cxx:1408
 AliCDMesonUtils.cxx:1409
 AliCDMesonUtils.cxx:1410
 AliCDMesonUtils.cxx:1411
 AliCDMesonUtils.cxx:1412
 AliCDMesonUtils.cxx:1413
 AliCDMesonUtils.cxx:1414
 AliCDMesonUtils.cxx:1415
 AliCDMesonUtils.cxx:1416
 AliCDMesonUtils.cxx:1417
 AliCDMesonUtils.cxx:1418
 AliCDMesonUtils.cxx:1419
 AliCDMesonUtils.cxx:1420
 AliCDMesonUtils.cxx:1421
 AliCDMesonUtils.cxx:1422
 AliCDMesonUtils.cxx:1423
 AliCDMesonUtils.cxx:1424
 AliCDMesonUtils.cxx:1425
 AliCDMesonUtils.cxx:1426
 AliCDMesonUtils.cxx:1427
 AliCDMesonUtils.cxx:1428
 AliCDMesonUtils.cxx:1429
 AliCDMesonUtils.cxx:1430
 AliCDMesonUtils.cxx:1431
 AliCDMesonUtils.cxx:1432
 AliCDMesonUtils.cxx:1433