#include "TArrayI.h"
#include "TArrayF.h"
#include "TRandom.h"
#include "AliLog.h"
#include "AliPID.h"
#include "AliTOFHeader.h"
#include "AliESDpid.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliMCEvent.h"
#include "AliTOFPIDParams.h"
#include <AliDetectorPID.h>
ClassImp(AliESDpid)
Int_t AliESDpid::MakePID(AliESDEvent *event, Bool_t TPConly, Float_t ) const {
Int_t nTrk=event->GetNumberOfTracks();
for (Int_t iTrk=0; iTrk<nTrk; iTrk++) {
AliESDtrack *track=event->GetTrack(iTrk);
MakeTPCPID(track);
if (!TPConly) {
MakeITSPID(track);
}
CombinePID(track);
}
return 0;
}
Float_t AliESDpid::GetTPCsignalTunedOnData(const AliVTrack *t) const {
AliESDtrack *track = (AliESDtrack *) t;
Float_t dedx = track->GetTPCsignalTunedOnData();
if(dedx > 0) return dedx;
dedx = t->GetTPCsignal();
track->SetTPCsignalTunedOnData(dedx);
if(dedx < 20) return dedx;
AliPID::EParticleType type = AliPID::kPion;
AliMCEventHandler* eventHandler=dynamic_cast<AliMCEventHandler*>(fEventHandler);
if (eventHandler) {
AliMCEvent* mcEvent = eventHandler->MCEvent();
if(mcEvent){
Bool_t kGood = kTRUE;
AliMCParticle *MCpart = (AliMCParticle *) mcEvent->GetTrack(TMath::Abs(t->GetLabel()));
if (MCpart != NULL) {
TParticle *part = MCpart->Particle();
Int_t iS = TMath::Abs(part->GetPdgCode());
if(iS==AliPID::ParticleCode(AliPID::kElectron)){
type = AliPID::kElectron;
}
else if(iS==AliPID::ParticleCode(AliPID::kMuon)){
type = AliPID::kMuon;
}
else if(iS==AliPID::ParticleCode(AliPID::kPion)){
type = AliPID::kPion;
}
else if(iS==AliPID::ParticleCode(AliPID::kKaon)){
type = AliPID::kKaon;
}
else if(iS==AliPID::ParticleCode(AliPID::kProton)){
type = AliPID::kProton;
}
else if(iS==AliPID::ParticleCode(AliPID::kDeuteron)){
type = AliPID::kDeuteron;
}
else if(iS==AliPID::ParticleCode(AliPID::kTriton)){
type = AliPID::kTriton;
}
else if(iS==AliPID::ParticleCode(AliPID::kHe3)){
type = AliPID::kHe3;
}
else if(iS==AliPID::ParticleCode(AliPID::kAlpha)){
type = AliPID::kAlpha;
}
else
kGood = kFALSE;
} else kGood = kFALSE;
if(kGood){
Double_t bethe = fTPCResponse.GetExpectedSignal(track, type, AliTPCPIDResponse::kdEdxDefault, this->UseTPCEtaCorrection(),
this->UseTPCMultiplicityCorrection());
Double_t sigma = fTPCResponse.GetExpectedSigma(track, type, AliTPCPIDResponse::kdEdxDefault, this->UseTPCEtaCorrection(),
this->UseTPCMultiplicityCorrection());
dedx = gRandom->Gaus(bethe,sigma);
}
}
}
track->SetTPCsignalTunedOnData(dedx);
return dedx;
}
Float_t AliESDpid::GetTOFsignalTunedOnData(const AliVTrack *t) const {
AliESDtrack *track = (AliESDtrack *) t;
Double_t tofSignal = track->GetTOFsignalTunedOnData();
if(tofSignal < 99999) return (Float_t)tofSignal;
Float_t addmism = GetTOFPIDParams()->GetTOFadditionalMismForMC();
if(addmism > 1.){
Float_t centr = GetCurrentCentrality();
if(centr > 50) addmism *= 0.1667;
else if(centr > 20) addmism *= 0.33;
}
tofSignal = t->GetTOFsignal() + fTOFResponse.GetTailRandomValue(t->Pt(),t->Eta(),t->GetTOFsignal(),addmism);
track->SetTOFsignalTunedOnData(tofSignal);
return (Float_t)tofSignal;
}
void AliESDpid::MakeTPCPID(AliESDtrack *track) const
{
if ((track->GetStatus()&AliESDtrack::kTPCin )==0)
if ((track->GetStatus()&AliESDtrack::kTPCout)==0) return;
Double_t mom = track->GetP();
const AliExternalTrackParam *in=track->GetInnerParam();
if (in) mom = in->GetP();
Double_t p[AliPID::kSPECIES];
Double_t dedx=track->GetTPCsignal();
Bool_t mismatch=kTRUE, heavy=kTRUE;
for (Int_t j=0; j<AliPID::kSPECIES; j++) {
AliPID::EParticleType type=AliPID::EParticleType(j);
Double_t bethe=fTPCResponse.GetExpectedSignal(mom,type);
Double_t sigma=fTPCResponse.GetExpectedSigma(mom,track->GetTPCsignalN(),type);
if (TMath::Abs(dedx-bethe) > fRange*sigma) {
p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
} else {
p[j]=TMath::Exp(-0.5*(dedx-bethe)*(dedx-bethe)/(sigma*sigma))/sigma;
mismatch=kFALSE;
}
if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
}
if (mismatch)
for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
track->SetTPCpid(p);
if (heavy) track->ResetStatus(AliESDtrack::kTPCpid);
}
void AliESDpid::MakeITSPID(AliESDtrack *track) const
{
if ((track->GetStatus()&AliESDtrack::kITSin)==0 &&
(track->GetStatus()&AliESDtrack::kITSout)==0) return;
Double_t mom=track->GetP();
if (fITSPIDmethod == kITSTruncMean) {
Double_t dedx=track->GetITSsignal();
Bool_t isSA=kTRUE;
Double_t momITS=mom;
ULong_t trStatus=track->GetStatus();
if(trStatus&AliESDtrack::kTPCin) isSA=kFALSE;
UChar_t clumap=track->GetITSClusterMap();
Int_t nPointsForPid=0;
for(Int_t i=2; i<6; i++){
if(clumap&(1<<i)) ++nPointsForPid;
}
if(nPointsForPid<3) {
track->ResetStatus(AliESDtrack::kITSpid);
return;
}
Double_t p[AliPID::kSPECIES];
Bool_t mismatch=kTRUE, heavy=kTRUE;
for (Int_t j=0; j<AliPID::kSPECIES; j++) {
Double_t mass=AliPID::ParticleMass(j);
Double_t bethe=fITSResponse.Bethe(momITS,mass);
Double_t sigma=fITSResponse.GetResolution(bethe,nPointsForPid,isSA);
if (TMath::Abs(dedx-bethe) > fRange*sigma) {
p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
} else {
p[j]=TMath::Exp(-0.5*(dedx-bethe)*(dedx-bethe)/(sigma*sigma))/sigma;
mismatch=kFALSE;
}
if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
}
if (mismatch)
for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
track->SetITSpid(p);
if (heavy) track->ResetStatus(AliESDtrack::kITSpid);
}
else {
Double_t condprobfun[AliPID::kSPECIES];
Double_t qclu[4];
track->GetITSdEdxSamples(qclu);
fITSResponse.GetITSProbabilities(mom,qclu,condprobfun);
track->SetITSpid(condprobfun);
}
}
void AliESDpid::MakeTOFPID(AliESDtrack *track, Float_t ) const
{
if ((track->GetStatus()&AliESDtrack::kTOFout)==0) return;
if ((track->GetStatus()&AliESDtrack::kTIME)==0) return;
if ((track->GetStatus()&AliESDtrack::kITSin)==0) return;
Int_t ibin = fTOFResponse.GetMomBin(track->GetP());
Float_t timezero = fTOFResponse.GetT0bin(ibin);
Double_t time[AliPID::kSPECIESC];
track->GetIntegratedTimes(time);
Double_t sigma[AliPID::kSPECIES];
for (Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++) {
sigma[iPart] = fTOFResponse.GetExpectedSigma(track->GetP(),time[iPart],AliPID::ParticleMass(iPart));
}
AliDebugGeneral("AliESDpid::MakeTOFPID",2,
Form("Expected TOF signals [ps]: %f %f %f %f %f",
time[AliPID::kElectron],
time[AliPID::kMuon],
time[AliPID::kPion],
time[AliPID::kKaon],
time[AliPID::kProton]));
AliDebugGeneral("AliESDpid::MakeTOFPID",2,
Form("Expected TOF std deviations [ps]: %f %f %f %f %f",
sigma[AliPID::kElectron],
sigma[AliPID::kMuon],
sigma[AliPID::kPion],
sigma[AliPID::kKaon],
sigma[AliPID::kProton]
));
Double_t tof = track->GetTOFsignal() - timezero;
Double_t p[AliPID::kSPECIES];
Bool_t heavy = kTRUE;
for (Int_t j=0; j<AliPID::kSPECIES; j++) {
Double_t sig = sigma[j];
if (TMath::Abs(tof-time[j]) > (fRange+2)*sig) {
p[j] = TMath::Exp(-0.5*(fRange+2)*(fRange+2))/sig;
} else
p[j] = TMath::Exp(-0.5*(tof-time[j])*(tof-time[j])/(sig*sig))/sig;
if (tof < (time[j] + fRange*sig)) heavy=kFALSE;
}
track->SetTOFpid(p);
if (heavy) track->ResetStatus(AliESDtrack::kTOFpid);
}
void AliESDpid::MakeTRDPID(AliESDtrack *track) const
{
Double_t prob[AliPID::kSPECIES];
GetComputeTRDProbability(track, AliPID::kSPECIES, prob);
track->SetTRDpid(prob);
}
void AliESDpid::CombinePID(AliESDtrack *track) const
{
Double_t p[AliPID::kSPECIES]={1.};
if (track->IsOn(AliESDtrack::kITSpid)) {
Double_t d[AliPID::kSPECIES];
track->GetITSpid(d);
for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
}
if (track->IsOn(AliESDtrack::kTPCpid)) {
Double_t d[AliPID::kSPECIES];
track->GetTPCpid(d);
for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
}
if (track->IsOn(AliESDtrack::kTRDpid)) {
Double_t d[AliPID::kSPECIES];
track->GetTRDpid(d);
for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
}
if (track->IsOn(AliESDtrack::kTOFpid)) {
Double_t d[AliPID::kSPECIES];
track->GetTOFpid(d);
for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
}
if (track->IsOn(AliESDtrack::kHMPIDpid)) {
Double_t d[AliPID::kSPECIES];
track->GetHMPIDpid(d);
for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]*=d[j];
}
track->SetESDpid(p);
}
Bool_t AliESDpid::CheckTOFMatching(AliESDtrack *track) const{
Bool_t status = kFALSE;
Double_t exptimes[AliPID::kSPECIESC];
track->GetIntegratedTimes(exptimes);
Float_t p = track->P();
Float_t dedx = track->GetTPCsignal();
Float_t time = track->GetTOFsignal() - fTOFResponse.GetStartTime(p);
Double_t ptpc[3];
track->GetInnerPxPyPz(ptpc);
Float_t momtpc=TMath::Sqrt(ptpc[0]*ptpc[0] + ptpc[1]*ptpc[1] + ptpc[2]*ptpc[2]);
for(Int_t i=0;i < AliPID::kSPECIES;i++){
AliPID::EParticleType type=AliPID::EParticleType(i);
Float_t resolutionTOF = fTOFResponse.GetExpectedSigma(p, exptimes[i], AliPID::ParticleMass(i));
if(TMath::Abs(exptimes[i] - time) < fRange * resolutionTOF){
Float_t dedxExp = fTPCResponse.GetExpectedSignal(momtpc,type);
Float_t resolutionTPC = fTPCResponse.GetExpectedSigma(momtpc,track->GetTPCsignalN(),type);
if(TMath::Abs(dedx - dedxExp) < fRangeTOFMismatch * resolutionTPC){
status = kTRUE;
}
}
}
Float_t resolutionTOFpr = fTOFResponse.GetExpectedSigma(p, exptimes[4], AliPID::ParticleMass(4));
if(!status && (exptimes[4] + fRange*resolutionTOFpr < time)) status = kTRUE;
return status;
}
Float_t AliESDpid::GetSignalDeltaTOFold(const AliVParticle *track, AliPID::EParticleType type, Bool_t ratio) const
{
AliVTrack *vtrack=(AliVTrack*)track;
const Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
Double_t tofTime = 99999;
if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
else tofTime=vtrack->GetTOFsignal();
tofTime = tofTime - fTOFResponse.GetStartTime(vtrack->P());
Double_t delta=-9999.;
if (!ratio) delta=tofTime-expTime;
else if (expTime>1.e-20) delta=tofTime/expTime;
return delta;
}
Float_t AliESDpid::GetNumberOfSigmasTOFold(const AliVParticle *track, AliPID::EParticleType type) const
{
AliVTrack *vtrack=(AliVTrack*)track;
Double_t tofTime = 99999;
if (fTuneMConData && ((fTuneMConDataMask & kDetTOF) == kDetTOF) ) tofTime = (Double_t)this->GetTOFsignalTunedOnData((AliVTrack*)vtrack);
else tofTime=vtrack->GetTOFsignal();
Double_t expTime = fTOFResponse.GetExpectedSignal(vtrack,type);
return (tofTime - fTOFResponse.GetStartTime(vtrack->P()) - expTime)/fTOFResponse.GetExpectedSigma(vtrack->P(),expTime,AliPID::ParticleMassZ(type));
}
void AliESDpid::SetPIDForTracking(AliESDtrack *esdtr) const
{
Double_t prob[AliPID::kSPECIESC]={0.};
EDetPidStatus pidStatus=ComputePIDProbability(kTPC, esdtr, AliPID::kSPECIESC, prob);
if (pidStatus==kDetNoSignal) {
esdtr->SetPIDForTracking(AliPID::kPion);
return;
}
Float_t max=0.,min=1.e9;
Int_t pid=-1;
for (Int_t i=0; i<AliPID::kSPECIESC; ++i) {
if (prob[i]>max) {pid=i; max=prob[i];}
if (prob[i]<min) min=prob[i];
}
if (pid>AliPID::kSPECIESC-1 || (min>=max)) pid = AliPID::kPion;
esdtr->SetPIDForTracking( pid );
}
void AliESDpid::MakePIDForTracking(AliESDEvent *event) const
{
Int_t nTrk=event->GetNumberOfTracks();
for (Int_t iTrk=nTrk; iTrk--;) {
AliESDtrack *track = event->GetTrack(iTrk);
SetPIDForTracking(track);
}
}