[u/mrichter/AliRoot.git] / STEER / AliESDpid.cxx

/**************************************************************************
 * 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.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------
//           Implementation of the combined PID class
//           For the Event Summary Data Class
//           produced by the reconstruction process
//           and containing information on the particle identification
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-----------------------------------------------------------------

#include "AliLog.h"
#include "AliPID.h"
#include "AliESDpid.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"

ClassImp(AliESDpid)

Int_t AliESDpid::MakePID(AliESDEvent *event, Bool_t TPConly, Float_t TimeZeroTOF) const {
  //
  //  Calculate probabilities for all detectors, except if TPConly==kTRUE
  //  and combine PID
  //  
  //   Option TPConly==kTRUE is used during reconstruction, 
  //  because ITS tracking uses TPC pid
  //  HMPID and TRD pid are done in detector reconstructors
  //

  /*
  Float_t TimeZeroTOF = 0;
  if (subtractT0) 
    TimeZeroTOF = event->GetT0();
  */
  Int_t nTrk=event->GetNumberOfTracks();
  for (Int_t iTrk=0; iTrk<nTrk; iTrk++) {  
    AliESDtrack *track=event->GetTrack(iTrk);
    MakeTPCPID(track);
    if (!TPConly) {
      MakeITSPID(track);
      MakeTOFPID(track, TimeZeroTOF);
      //MakeHMPIDPID(track);
      //MakeTRDPID(track);
    }
    CombinePID(track);
  }
  return 0;
}
//_________________________________________________________________________
void AliESDpid::MakeTPCPID(AliESDtrack *track) const
{
  //
  //  TPC pid using bethe-bloch and gaussian response
  //
  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;
      }

      // Check for particles heavier than (AliPID::kSPECIES - 1)
      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
{
  //
  // ITS PID
  // Two options, depending on fITSPIDmethod:
  //  1) Truncated mean method
  //  2) Likelihood, using charges measured in all 4 layers and 
  //     Landau+gaus response functions
  //

  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 not to be used for combined PID purposes
      track->ResetStatus(AliESDtrack::kITSpid);
      return;
    }

    Double_t p[10];

    Bool_t mismatch=kTRUE, heavy=kTRUE;
    for (Int_t j=0; j<AliPID::kSPECIES; j++) {
      Double_t mass=AliPID::ParticleMass(j);//GeV/c^2
      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;
      }

      // Check for particles heavier than (AliPID::kSPECIES - 1)
      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 {  // Likelihood method
    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 TimeZeroTOF) const
{
  //
  //   TOF PID using gaussian response
  //
  if ((track->GetStatus()&AliESDtrack::kTOFout)==0) return;
  if ((track->GetStatus()&AliESDtrack::kTIME)==0) return;

  Double_t time[AliPID::kSPECIESN];
  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() - TimeZeroTOF;

  Double_t p[AliPID::kSPECIES];
  Bool_t mismatch = kTRUE, heavy = kTRUE;
  for (Int_t j=0; j<AliPID::kSPECIES; j++) {
    Double_t sig = sigma[j];
    if (TMath::Abs(tof-time[j]) > fRange*sig) {
      p[j] = TMath::Exp(-0.5*fRange*fRange)/sig;
    } else
      p[j] = TMath::Exp(-0.5*(tof-time[j])*(tof-time[j])/(sig*sig))/sig;

    // Check the mismatching
    Double_t mass = AliPID::ParticleMass(j);
    Double_t pm = fTOFResponse.GetMismatchProbability(track->GetP(),mass);
    if (p[j]>pm) mismatch = kFALSE;

    // Check for particles heavier than (AliPID::kSPECIES - 1)
    if (tof < (time[j] + fRange*sig)) heavy=kFALSE;

  }

  if (mismatch)
    for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1/AliPID::kSPECIES;

  track->SetTOFpid(p);

  if (heavy) track->ResetStatus(AliESDtrack::kTOFpid);    
}
//_________________________________________________________________________
void AliESDpid::MakeTRDPID(AliESDtrack *track) const
{
  //
  // Method to recalculate the TRD PID probabilities
  //
  if((track->GetStatus()&AliESDtrack::kTRDout)==0) return;
  Double_t prob[AliPID::kSPECIES]; Float_t mom[6];
  Double_t dedx[48];  // Allocate space for the maximum number of TRD slices
  for(Int_t ilayer = 0; ilayer < 6; ilayer++){
    mom[ilayer] = track->GetTRDmomentum(ilayer);
    for(Int_t islice = 0; islice < track->GetNumberOfTRDslices(); islice++){
      dedx[ilayer*track->GetNumberOfTRDslices()+islice] = track->GetTRDslice(ilayer, islice);
    }
  }
  fTRDResponse.GetResponse(track->GetNumberOfTRDslices(), dedx, mom, prob);
  track->SetTRDpid(prob);
}
//_________________________________________________________________________
void AliESDpid::CombinePID(AliESDtrack *track) const
{
  //
  // Combine the information of various detectors
  // to determine the Particle Identification
  //
  Int_t ns=AliPID::kSPECIES;
  Double_t p[10]={1.,1.,1.,1.,1.,1.,1.,1.,1.,1.};

  if (track->IsOn(AliESDtrack::kITSpid)) {
    Double_t d[10];
    track->GetITSpid(d);
    for (Int_t j=0; j<ns; j++) p[j]*=d[j];
  }

  if (track->IsOn(AliESDtrack::kTPCpid)) {
    Double_t d[10];
    track->GetTPCpid(d);
    for (Int_t j=0; j<ns; j++) p[j]*=d[j];
  }

  if (track->IsOn(AliESDtrack::kTRDpid)) {
    Double_t d[10];
    track->GetTRDpid(d);
    for (Int_t j=0; j<ns; j++) p[j]*=d[j];
  }

  if (track->IsOn(AliESDtrack::kTOFpid)) {
    Double_t d[10];
    track->GetTOFpid(d);
    for (Int_t j=0; j<ns; j++) p[j]*=d[j];
  }

  if (track->IsOn(AliESDtrack::kHMPIDpid)) {
    Double_t d[10];
    track->GetHMPIDpid(d);
    for (Int_t j=0; j<ns; j++) p[j]*=d[j];
  }

  track->SetESDpid(p);
}
Commit	Line	Data
8c6a71ab	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
4f679a16	16	/* $Id$ */
4f679a16	17
8c6a71ab	18	//-----------------------------------------------------------------
8c6a71ab	19	// Implementation of the combined PID class
4f679a16	20	// For the Event Summary Data Class
	21	// produced by the reconstruction process
	22	// and containing information on the particle identification
8c6a71ab	23	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
	24	//-----------------------------------------------------------------
	25
10d100d4	26	#include "AliLog.h"
10d100d4	27	#include "AliPID.h"
8c6a71ab	28	#include "AliESDpid.h"
af885e0f	29	#include "AliESDEvent.h"
8c6a71ab	30	#include "AliESDtrack.h"
	31
	32	ClassImp(AliESDpid)
	33
10d100d4	34	Int_t AliESDpid::MakePID(AliESDEvent *event, Bool_t TPConly, Float_t TimeZeroTOF) const {
	35	//
	36	// Calculate probabilities for all detectors, except if TPConly==kTRUE
	37	// and combine PID
	38	//
	39	// Option TPConly==kTRUE is used during reconstruction,
	40	// because ITS tracking uses TPC pid
	41	// HMPID and TRD pid are done in detector reconstructors
	42	//
	43
	44	/*
	45	Float_t TimeZeroTOF = 0;
	46	if (subtractT0)
	47	TimeZeroTOF = event->GetT0();
	48	*/
	49	Int_t nTrk=event->GetNumberOfTracks();
	50	for (Int_t iTrk=0; iTrk<nTrk; iTrk++) {
	51	AliESDtrack *track=event->GetTrack(iTrk);
	52	MakeTPCPID(track);
	53	if (!TPConly) {
	54	MakeITSPID(track);
	55	MakeTOFPID(track, TimeZeroTOF);
	56	//MakeHMPIDPID(track);
ce5d6908	57	//MakeTRDPID(track);
10d100d4	58	}
	59	CombinePID(track);
	60	}
	61	return 0;
	62	}
8c6a71ab	63	//_________________________________________________________________________
10d100d4	64	void AliESDpid::MakeTPCPID(AliESDtrack *track) const
8c6a71ab	65	{
4f679a16	66	//
10d100d4	67	// TPC pid using bethe-bloch and gaussian response
4f679a16	68	//
10d100d4	69	if ((track->GetStatus()&AliESDtrack::kTPCin )==0)
10d100d4	70	if ((track->GetStatus()&AliESDtrack::kTPCout)==0) return;
8c6a71ab	71
10d100d4	72	Double_t mom = track->GetP();
	73	const AliExternalTrackParam *in=track->GetInnerParam();
	74	if (in) mom = in->GetP();
8c6a71ab	75
10d100d4	76	Double_t p[AliPID::kSPECIES];
	77	Double_t dedx=track->GetTPCsignal();
	78	Bool_t mismatch=kTRUE, heavy=kTRUE;
8c6a71ab	79
10d100d4	80	for (Int_t j=0; j<AliPID::kSPECIES; j++) {
	81	AliPID::EParticleType type=AliPID::EParticleType(j);
	82	Double_t bethe=fTPCResponse.GetExpectedSignal(mom,type);
	83	Double_t sigma=fTPCResponse.GetExpectedSigma(mom,track->GetTPCsignalN(),type);
	84	if (TMath::Abs(dedx-bethe) > fRange*sigma) {
	85	p[j]=TMath::Exp(-0.5fRangefRange)/sigma;
	86	} else {
	87	p[j]=TMath::Exp(-0.5(dedx-bethe)(dedx-bethe)/(sigma*sigma))/sigma;
	88	mismatch=kFALSE;
	89	}
8c6a71ab	90
10d100d4	91	// Check for particles heavier than (AliPID::kSPECIES - 1)
10d100d4	92	if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
c630aafd	93
4a78b8c5	94	}
4a78b8c5	95
10d100d4	96	if (mismatch)
	97	for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1/AliPID::kSPECIES;
	98
	99	track->SetTPCpid(p);
	100
	101	if (heavy) track->ResetStatus(AliESDtrack::kTPCpid);
	102
	103	}
	104	//_________________________________________________________________________
	105	void AliESDpid::MakeITSPID(AliESDtrack *track) const
	106	{
	107	//
	108	// ITS PID
	109	// Two options, depending on fITSPIDmethod:
	110	// 1) Truncated mean method
	111	// 2) Likelihood, using charges measured in all 4 layers and
	112	// Landau+gaus response functions
	113	//
	114
	115	if ((track->GetStatus()&AliESDtrack::kITSin)==0 &&
	116	(track->GetStatus()&AliESDtrack::kITSout)==0) return;
	117
	118	Double_t mom=track->GetP();
	119	if (fITSPIDmethod == kITSTruncMean) {
	120	Double_t dedx=track->GetITSsignal();
15e979c9	121	Bool_t isSA=kTRUE;
	122	Double_t momITS=mom;
	123	ULong_t trStatus=track->GetStatus();
99daa709	124	if(trStatus&AliESDtrack::kTPCin) isSA=kFALSE;
15e979c9	125	UChar_t clumap=track->GetITSClusterMap();
	126	Int_t nPointsForPid=0;
	127	for(Int_t i=2; i<6; i++){
	128	if(clumap&(1<<i)) ++nPointsForPid;
	129	}
	130
	131	if(nPointsForPid<3) { // track not to be used for combined PID purposes
	132	track->ResetStatus(AliESDtrack::kITSpid);
	133	return;
	134	}
	135
10d100d4	136	Double_t p[10];
15e979c9	137
10d100d4	138	Bool_t mismatch=kTRUE, heavy=kTRUE;
	139	for (Int_t j=0; j<AliPID::kSPECIES; j++) {
	140	Double_t mass=AliPID::ParticleMass(j);//GeV/c^2
15e979c9	141	Double_t bethe=fITSResponse.Bethe(momITS,mass);
15e979c9	142	Double_t sigma=fITSResponse.GetResolution(bethe,nPointsForPid,isSA);
10d100d4	143	if (TMath::Abs(dedx-bethe) > fRange*sigma) {
	144	p[j]=TMath::Exp(-0.5fRangefRange)/sigma;
	145	} else {
	146	p[j]=TMath::Exp(-0.5(dedx-bethe)(dedx-bethe)/(sigma*sigma))/sigma;
	147	mismatch=kFALSE;
	148	}
	149
	150	// Check for particles heavier than (AliPID::kSPECIES - 1)
	151	if (dedx < (bethe + fRange*sigma)) heavy=kFALSE;
	152
4a78b8c5	153	}
c630aafd	154
10d100d4	155	if (mismatch)
	156	for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1./AliPID::kSPECIES;
	157
	158	track->SetITSpid(p);
	159
	160	if (heavy) track->ResetStatus(AliESDtrack::kITSpid);
	161	}
	162	else { // Likelihood method
	163	Double_t condprobfun[AliPID::kSPECIES];
	164	Double_t qclu[4];
	165	track->GetITSdEdxSamples(qclu);
	166	fITSResponse.GetITSProbabilities(mom,qclu,condprobfun);
	167	track->SetITSpid(condprobfun);
8c6a71ab	168	}
7a8614f3	169
10d100d4	170	}
	171	//_________________________________________________________________________
	172	void AliESDpid::MakeTOFPID(AliESDtrack *track, Float_t TimeZeroTOF) const
	173	{
	174	//
	175	// TOF PID using gaussian response
	176	//
	177	if ((track->GetStatus()&AliESDtrack::kTOFout)==0) return;
	178	if ((track->GetStatus()&AliESDtrack::kTIME)==0) return;
	179
	180	Double_t time[AliPID::kSPECIESN];
	181	track->GetIntegratedTimes(time);
	182
	183	Double_t sigma[AliPID::kSPECIES];
	184	for (Int_t iPart = 0; iPart < AliPID::kSPECIES; iPart++) {
	185	sigma[iPart] = fTOFResponse.GetExpectedSigma(track->GetP(),time[iPart],AliPID::ParticleMass(iPart));
	186	}
	187
	188	AliDebugGeneral("AliESDpid::MakeTOFPID",2,
	189	Form("Expected TOF signals [ps]: %f %f %f %f %f",
	190	time[AliPID::kElectron],
	191	time[AliPID::kMuon],
	192	time[AliPID::kPion],
	193	time[AliPID::kKaon],
	194	time[AliPID::kProton]));
	195
	196	AliDebugGeneral("AliESDpid::MakeTOFPID",2,
	197	Form("Expected TOF std deviations [ps]: %f %f %f %f %f",
	198	sigma[AliPID::kElectron],
	199	sigma[AliPID::kMuon],
	200	sigma[AliPID::kPion],
	201	sigma[AliPID::kKaon],
	202	sigma[AliPID::kProton]
	203	));
	204
	205	Double_t tof = track->GetTOFsignal() - TimeZeroTOF;
	206
	207	Double_t p[AliPID::kSPECIES];
	208	Bool_t mismatch = kTRUE, heavy = kTRUE;
	209	for (Int_t j=0; j<AliPID::kSPECIES; j++) {
	210	Double_t sig = sigma[j];
	211	if (TMath::Abs(tof-time[j]) > fRange*sig) {
	212	p[j] = TMath::Exp(-0.5fRangefRange)/sig;
	213	} else
	214	p[j] = TMath::Exp(-0.5(tof-time[j])(tof-time[j])/(sig*sig))/sig;
	215
	216	// Check the mismatching
	217	Double_t mass = AliPID::ParticleMass(j);
	218	Double_t pm = fTOFResponse.GetMismatchProbability(track->GetP(),mass);
	219	if (p[j]>pm) mismatch = kFALSE;
	220
	221	// Check for particles heavier than (AliPID::kSPECIES - 1)
	222	if (tof < (time[j] + fRange*sig)) heavy=kFALSE;
	223
	224	}
	225
	226	if (mismatch)
	227	for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1/AliPID::kSPECIES;
	228
	229	track->SetTOFpid(p);
	230
	231	if (heavy) track->ResetStatus(AliESDtrack::kTOFpid);
	232	}
	233	//_________________________________________________________________________
b439f460	234	void AliESDpid::MakeTRDPID(AliESDtrack *track) const
	235	{
	236	//
	237	// Method to recalculate the TRD PID probabilities
	238	//
	239	if((track->GetStatus()&AliESDtrack::kTRDout)==0) return;
	240	Double_t prob[AliPID::kSPECIES]; Float_t mom[6];
	241	Double_t dedx[48]; // Allocate space for the maximum number of TRD slices
	242	for(Int_t ilayer = 0; ilayer < 6; ilayer++){
	243	mom[ilayer] = track->GetTRDmomentum(ilayer);
	244	for(Int_t islice = 0; islice < track->GetNumberOfTRDslices(); islice++){
	245	dedx[ilayer*track->GetNumberOfTRDslices()+islice] = track->GetTRDslice(ilayer, islice);
	246	}
	247	}
	248	fTRDResponse.GetResponse(track->GetNumberOfTRDslices(), dedx, mom, prob);
	249	track->SetTRDpid(prob);
	250	}
	251	//_________________________________________________________________________
10d100d4	252	void AliESDpid::CombinePID(AliESDtrack *track) const
	253	{
	254	//
	255	// Combine the information of various detectors
	256	// to determine the Particle Identification
	257	//
	258	Int_t ns=AliPID::kSPECIES;
	259	Double_t p[10]={1.,1.,1.,1.,1.,1.,1.,1.,1.,1.};
	260
	261	if (track->IsOn(AliESDtrack::kITSpid)) {
	262	Double_t d[10];
	263	track->GetITSpid(d);
	264	for (Int_t j=0; j<ns; j++) p[j]*=d[j];
	265	}
	266
	267	if (track->IsOn(AliESDtrack::kTPCpid)) {
	268	Double_t d[10];
	269	track->GetTPCpid(d);
	270	for (Int_t j=0; j<ns; j++) p[j]*=d[j];
	271	}
	272
	273	if (track->IsOn(AliESDtrack::kTRDpid)) {
	274	Double_t d[10];
	275	track->GetTRDpid(d);
	276	for (Int_t j=0; j<ns; j++) p[j]*=d[j];
	277	}
	278
	279	if (track->IsOn(AliESDtrack::kTOFpid)) {
	280	Double_t d[10];
	281	track->GetTOFpid(d);
	282	for (Int_t j=0; j<ns; j++) p[j]*=d[j];
	283	}
	284
	285	if (track->IsOn(AliESDtrack::kHMPIDpid)) {
	286	Double_t d[10];
	287	track->GetHMPIDpid(d);
	288	for (Int_t j=0; j<ns; j++) p[j]*=d[j];
	289	}
	290
	291	track->SetESDpid(p);
8c6a71ab	292	}