#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)
{
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[])
{
Double_t tmpp1[3], tmpp2[3];
trks[0]->GetPxPyPz(tmpp1);
trks[1]->GetPxPyPz(tmpp2);
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;
va.SetXYZM(tmpp1[0], tmpp1[1], tmpp1[2], masstrk);
vb.SetXYZM(tmpp2[0], tmpp2[1], tmpp2[2], masstrk);
TLorentzVector sumv = va+vb;
TVector3 sumXZ(sumv.X(), 0, sumv.Z());
mass = sumv.M();
momentum[0] = sumv.X();
momentum[1] = sumv.Y();
momentum[2] = sumv.Z();
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);
theta = va.Theta();
phi = va.Phi();
}
Int_t AliCDMesonUtils::GetEventType(const AliESDEvent *ESDEvent)
{
TString firedTriggerClasses = ESDEvent->GetFiredTriggerClasses();
if (firedTriggerClasses.Contains("CINT1A-ABCE-NOPF-ALL")) {
return AliCDMesonBase::kBinEventA;
}
if (firedTriggerClasses.Contains("CINT1C-ABCE-NOPF-ALL")) {
return AliCDMesonBase::kBinEventC;
}
if (firedTriggerClasses.Contains("CINT1B-ABCE-NOPF-ALL")) {
return AliCDMesonBase::kBinEventI;
}
if (firedTriggerClasses.Contains("CINT1-E-NOPF-ALL")) {
return AliCDMesonBase::kBinEventE;
}
if (firedTriggerClasses.Contains("CDG5-E")) {
return AliCDMesonBase::kBinEventE;
}
if (firedTriggerClasses.Contains("CDG5-I")) {
return AliCDMesonBase::kBinEventI;
}
if (firedTriggerClasses.Contains("CDG5-AC")) {
return AliCDMesonBase::kBinEventAC;
}
return AliCDMesonBase::kBinEventUnknown;
}
void AliCDMesonUtils::SwapTrack(const AliVTrack* trks[])
{
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[])
{
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 )
{
if (!pid){
return AliCDMesonBase::kBinPIDUnknown;
}
Int_t kpid[2];
for(Int_t ii=0; ii<2; ii++){
kpid[ii] = GetPID(pid, trks[ii], mode);
}
if (comb2trkPID) {
comb2trkPID->Fill(kpid[0], kpid[1]);
}
return CombinePID(kpid);
}
Int_t AliCDMesonUtils::GetCombPID(const TParticle* particles[],
TH2 *comb2trkPID )
{
Int_t kpid[2];
for(Int_t ii=0; ii<2; ii++){
kpid[ii] = GetPID(particles[ii]->GetPdgCode());
}
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)
{
sum = forwardA = forwardC = central = 0;
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)
{
AliTriggerAnalysis triggerAnalysis;
const Int_t fastORhw = triggerAnalysis.SPDFiredChips(ESDEvent, 1);
if (hspd) hspd->Fill(fastORhw);
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){
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;
}
Bool_t kpr0 = kTRUE;
const AliESDVertex *vertex = ESDEvent->GetPrimaryVertexTracks();
if(vertex->GetNContributors()<1) {
vertex = ESDEvent->GetPrimaryVertexSPD();
if(vertex->GetNContributors()<1) {
kpr0 = kFALSE;
}
}
const Bool_t kpriv = kpr0 && (fabs(vertex->GetZ()) < 10.);
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)
{
Bool_t kpr0 = kTRUE;
const AliAODVertex *vertex = AODEvent->GetPrimaryVertex();
if(vertex->GetNContributors()<1) {
vertex = AODEvent->GetPrimaryVertexSPD();
if(vertex->GetNContributors()<1) {
kpr0 = kFALSE;
}
}
const Bool_t kpriv = kpr0 && (fabs(vertex->GetZ())<10.);
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)
{
const AliESDVZERO* esdV0 = ESDEvent->GetVZEROData();
if (!esdV0) {
Printf("ERROR: esd V0 not available");
return;
}
AliTriggerAnalysis triggerAnalysis;
AliCDBManager *man = AliCDBManager::Instance();
TString cdbpath;
if (man->IsDefaultStorageSet()) {
const AliCDBStorage *dsto = man->GetDefaultStorage();
cdbpath = TString(dsto->GetBaseFolder());
}
else {
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;
}
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));
}
pmtHist = iPMT;
for (iPMT = 0; iPMT < 64; ++iPMT) {
((TH2*)hists->At(iPMT+pmtHist))->Fill(esdV0->GetAdc(iPMT),
esdV0->GetMultiplicity(iPMT));
}
}
Int_t AliCDMesonUtils::GetGapConfig(const AliESDEvent *ESDEvent,
TH2 *hitMapSPDinner, TH2 *hitMapSPDouter,
TH2 *hitMapSPDtrklt, TH2 *hitMapFMDa,
TH2 *hitMapFMDc, TH1 **fmdSums,
TH2 *TPCGapDCAaSide, TH2 *TPCGapDCAcSide)
{
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;
}
void AliCDMesonUtils::FillEtaPhiMap(const AliVEvent *event,
const AliCDMesonTracks* tracks, TH2 *map,
TH2 *map_c)
{
for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); ++itrk) {
if (AliVParticle *trk = event->GetTrack(itrk)) {
if (map) {
map->Fill(trk->Eta(), trk->Phi());
}
}
}
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)
{
#ifdef STD_ALIROOT
fmdA = FMDHitCombinations(ESDEvent, 0);
fmdC = FMDHitCombinations(ESDEvent, 1);
#else
AliTriggerAnalysis triggerAnalysis;
triggerAnalysis.SetFMDThreshold(0.3, 0.5);
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)
{
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)
{
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)
{
AliTriggerAnalysis triggerAnalysis;
triggerAnalysis.SetFMDThreshold(0.3, 0.5);
const Bool_t fmdA =
triggerAnalysis.FMDTrigger(ESDEvent, AliTriggerAnalysis::kASide);
const Bool_t fmdC =
triggerAnalysis.FMDTrigger(ESDEvent, AliTriggerAnalysis::kCSide);
Bool_t hitMaps = (Bool_t)(hitMapFMDa && hitMapFMDc);
Bool_t calcSum = fmdSums ?
(fmdSums[0] && fmdSums[1] && fmdSums[2] && fmdSums[3] && fmdSums[4]) :
kFALSE;
Float_t sum[] = { 0., 0., 0., 0., 0. };
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) {
const Float_t eta = fmdData->Eta(det,ring,sec,strip);
const Float_t phi =
fmdData->Phi(det,ring,sec,strip) / 180. * TMath::Pi();
if (eta != AliESDFMD::kInvalidEta) {
if ((-3.5 < eta) && (eta < -1.5)) {
hitMapFMDc->Fill(eta, phi, mult);
}
else if ((1.5 < eta) && (eta < 5.5)) {
hitMapFMDa->Fill(eta, phi, mult);
}
}
}
}
}
}
}
}
if (calcSum) {
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)
{
Int_t nfoctr[10];
GetNFO(ESDEvent, "]0.9[", nfoctr, hitMapSPDinner, hitMapSPDouter);
if (hitMapSPDtrklt) FillSPDtrkltMap(ESDEvent, hitMapSPDtrklt);
const Int_t ipA = nfoctr[kIPA];
const Int_t ipC = nfoctr[kIPC];
const Int_t opA = nfoctr[kOPA];
const Int_t opC = nfoctr[kOPC];
const Bool_t spdA = ipA + opA;
const Bool_t spdC = ipC + opC;
return spdA * AliCDMesonBase::kBitSPDA + spdC * AliCDMesonBase::kBitSPDC;
}
Int_t AliCDMesonUtils::GetTPC(const AliESDEvent * ESDEvent, TH2 *TPCGapDCAaSide,
TH2 *TPCGapDCAcSide)
{
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)
{
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)
{
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)
totalMult = totalMult + mult;
else {
if (totalMult > 0.5)
triggers++;
}
}
}
}
}
return triggers;
}
#endif
void AliCDMesonUtils::SPDLoadGeom(Int_t run)
{
AliCDBManager *man = AliCDBManager::Instance();
TString cdbpath;
if (man->IsDefaultStorageSet()) {
const AliCDBStorage *dsto = man->GetDefaultStorage();
cdbpath = TString(dsto->GetBaseFolder());
}
else {
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)
{
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)
{
const Bool_t kincl = (scut[0] == '[');
const TString cutval = scut(1,3);
const Double_t etacut = fabs(cutval.Atof());
if(kincl && etacut>=2)
return kTRUE;
Int_t etaside = 1;
UInt_t module=999, offchip=999;
AliSPDUtils::GetOfflineFromOfflineChipKey(chipKey,module,offchip);
UInt_t hs = AliSPDUtils::GetOnlineHSFromOffline(module);
if(hs<2) offchip = 4 - offchip;
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]);
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]);
if (chipKey < 400) {
if (hitMapSPDinner) {
Double_t phi = pos.Phi();
if (phi < 0.) phi += TMath::TwoPi();
const Double_t eta = pos.Eta();
hitMapSPDinner->Fill(eta, phi);
}
}
else {
if (hitMapSPDouter) {
Double_t phi = pos.Phi();
if (phi < 0.) phi += TMath::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)
{
Int_t ninner=0;
Int_t nouter=0;
Int_t ipA = 0;
Int_t ipC = 0;
Int_t opA = 0;
Int_t opC = 0;
const AliMultiplicity *mult = ESDEvent->GetMultiplicity();
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)){
const Int_t iseta = CheckChipEta(iChipKey, etacut, vtxPos, hitMapSPDinner,
hitMapSPDouter);
if(iseta==0)
continue;
if(iChipKey<400) {
ninner++;
if(iseta>0)
ipA ++;
else
ipC ++;
}
else {
nouter++;
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)
{
const AliMultiplicity *mult = ESDEvent->GetMultiplicity();
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)){
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)
{
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 )
{
if (!pid) return AliCDMesonBase::kBinPIDUnknown;
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.;
const Bool_t kits = !(trk->GetStatus() & AliESDtrack::kTPCout);
if (kits) {
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)
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 );
const Bool_t ka = !(trk->GetStatus() & AliESDtrack::kTOFmismatch);
const Bool_t kb = (trk->GetStatus() & AliESDtrack::kTOFpid);
const Bool_t ktof = ka && kb;
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) {
const Double_t nin = 3.;
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)
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) {
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)
{
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[])
{
if (pid[0] == pid[1]) {
return pid[0];
}
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;
}
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)
{
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);
const TVector3 pra = va.Vect();
const TVector3 prb = vb.Vect();
const TVector3 diff = pra - prb;
cts = (diff.Mag2()-pra.Mag2()-prb.Mag2()) / (-2.*pra.Mag()*prb.Mag());
return sumv;
}
Double_t AliCDMesonUtils::GetOA(const Double_t *pa, const Double_t *pb)
{
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);
}