[u/mrichter/AliRoot.git] / TOF / AliTOFpidESD.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.                  *
 **************************************************************************/

//-----------------------------------------------------------------//
//                                                                 //
//           Implementation of the TOF PID class                   //
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch         //
//                                                                 //
//-----------------------------------------------------------------//

#include "TMath.h"
#include "AliLog.h"

#include "AliESDtrack.h"
#include "AliESDEvent.h"

#include "AliTOFpidESD.h"

ClassImp(AliTOFpidESD)

//_________________________________________________________________________
AliTOFpidESD::AliTOFpidESD(): 
  fSigma(0),
  fRange(0),
  fPmax(0)         // zero at 0.5 GeV/c for pp
{
}
//_________________________________________________________________________
AliTOFpidESD::AliTOFpidESD(Double_t *param):
  fSigma(param[0]),
  fRange(param[1]),
  fPmax(0)          // zero at 0.5 GeV/c for pp
{
  //
  //  The main constructor
  //
  //

  //fPmax=TMath::Exp(-0.5*3*3)/fSigma; // ~3 sigma at 0.5 GeV/c for PbPb 
}

Double_t 
AliTOFpidESD::GetMismatchProbability(Double_t p, Double_t mass) const {
  //
  // Returns the probability of mismatching 
  // assuming 1/(p*beta)^2 scaling
  //
  const Double_t km=0.5;                   // "reference" momentum (GeV/c)

  Double_t ref2=km*km*km*km/(km*km + mass*mass);// "reference" (p*beta)^2
  Double_t p2beta2=p*p*p*p/(p*p + mass*mass);

  return fPmax*ref2/p2beta2;
}

//_________________________________________________________________________
Int_t AliTOFpidESD::MakePID(AliESDEvent *event, Double_t timeZero)
{
  //
  //  This function calculates the "detector response" PID probabilities
  //                Just for a bare hint... 

  AliDebug(1,Form("TOF PID Parameters: Sigma (ps)= %f, Range= %f",fSigma,fRange));
  AliDebug(1,"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ \n");

  Int_t ntrk=event->GetNumberOfTracks();
  AliESDtrack **tracks=new AliESDtrack*[ntrk];

  Int_t i;
  for (i=0; i<ntrk; i++) {
    AliESDtrack *t=event->GetTrack(i);
    tracks[i]=t;
  }

  for (i=0; i<ntrk; i++) {
    AliESDtrack *t=tracks[i];
    if ((t->GetStatus()&AliESDtrack::kTOFout)==0) continue;
    if ((t->GetStatus()&AliESDtrack::kTIME)==0) continue;
    Double_t tof=t->GetTOFsignal()-timeZero;
    Double_t time[10]; t->GetIntegratedTimes(time);
    Double_t p[10];
    Double_t mom=t->GetP();
    Bool_t mismatch=kTRUE, heavy=kTRUE;
    for (Int_t j=0; j<AliPID::kSPECIES; j++) {
      Double_t mass=AliPID::ParticleMass(j);
      Double_t dpp=0.01;      //mean relative pt resolution;
      if (mom>0.5) dpp=0.01*mom;
      Double_t sigma=dpp*time[j]/(1.+ mom*mom/(mass*mass));
      sigma=TMath::Sqrt(sigma*sigma + fSigma*fSigma);
      if (TMath::Abs(tof-time[j]) > fRange*sigma) {
	p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
      } else 
        p[j]=TMath::Exp(-0.5*(tof-time[j])*(tof-time[j])/(sigma*sigma))/sigma;

      // Check the mismatching
      Double_t pm=GetMismatchProbability(mom,mass);
      if (p[j]>pm) mismatch=kFALSE;

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

    }

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

    t->SetTOFpid(p);

    if (heavy) t->ResetStatus(AliESDtrack::kTOFpid);    

  }

  delete[] tracks;
  
  return 0;
}

//_________________________________________________________________________
Int_t AliTOFpidESD::MakePID(AliESDEvent *event)
{
  //
  //  This function calculates the "detector response" PID probabilities
  //                Just for a bare hint... 

  Int_t ntrk=event->GetNumberOfTracks();
  AliESDtrack **tracks=new AliESDtrack*[ntrk];

  Int_t i;
  for (i=0; i<ntrk; i++) {
    AliESDtrack *t=event->GetTrack(i);
    tracks[i]=t;
  }

  for (i=0; i<ntrk; i++) {
    AliESDtrack *t=tracks[i];
    if ((t->GetStatus()&AliESDtrack::kTOFout)==0) continue;
    if ((t->GetStatus()&AliESDtrack::kTIME)==0) continue;
    Double_t tof=t->GetTOFsignal();
    Double_t time[10]; t->GetIntegratedTimes(time);
    Double_t p[10];
    Double_t mom=t->GetP();
    Bool_t mismatch=kTRUE, heavy=kTRUE;
    for (Int_t j=0; j<AliPID::kSPECIES; j++) {
      Double_t mass=AliPID::ParticleMass(j);
      Double_t dpp=0.01;      //mean relative pt resolution;
      if (mom>0.5) dpp=0.01*mom;
      Double_t sigma=dpp*time[j]/(1.+ mom*mom/(mass*mass));
      sigma=TMath::Sqrt(sigma*sigma + fSigma*fSigma);
      if (TMath::Abs(tof-time[j]) > fRange*sigma) {
	p[j]=TMath::Exp(-0.5*fRange*fRange)/sigma;
      } else
        p[j]=TMath::Exp(-0.5*(tof-time[j])*(tof-time[j])/(sigma*sigma))/sigma;

      // Check the mismatching
      Double_t pm=GetMismatchProbability(mom,mass);
      if (p[j]>pm) mismatch=kFALSE;

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

    }

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

    t->SetTOFpid(p);

    if (heavy) t->ResetStatus(AliESDtrack::kTOFpid);    

  }

  delete[] tracks;
  
  return 0;
}
Commit	Line	Data
	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
	16	//-----------------------------------------------------------------//
	17	// //
	18	// Implementation of the TOF PID class //
	19	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch //
	20	// //
	21	//-----------------------------------------------------------------//
	22
	23	#include "TMath.h"
	24	#include "AliLog.h"
	25
	26	#include "AliESDtrack.h"
	27	#include "AliESDEvent.h"
	28
	29	#include "AliTOFpidESD.h"
	30
	31	ClassImp(AliTOFpidESD)
	32
	33	//_________________________________________________________________________
	34	AliTOFpidESD::AliTOFpidESD():
	35	fSigma(0),
	36	fRange(0),
	37	fPmax(0) // zero at 0.5 GeV/c for pp
	38	{
	39	}
	40	//_________________________________________________________________________
	41	AliTOFpidESD::AliTOFpidESD(Double_t *param):
	42	fSigma(param[0]),
	43	fRange(param[1]),
	44	fPmax(0) // zero at 0.5 GeV/c for pp
	45	{
	46	//
	47	// The main constructor
	48	//
	49	//
	50
	51	//fPmax=TMath::Exp(-0.533)/fSigma; // ~3 sigma at 0.5 GeV/c for PbPb
	52	}
	53
	54	Double_t
	55	AliTOFpidESD::GetMismatchProbability(Double_t p, Double_t mass) const {
	56	//
	57	// Returns the probability of mismatching
	58	// assuming 1/(p*beta)^2 scaling
	59	//
	60	const Double_t km=0.5; // "reference" momentum (GeV/c)
	61
	62	Double_t ref2=kmkmkmkm/(kmkm + massmass);// "reference" (pbeta)^2
	63	Double_t p2beta2=pppp/(pp + mass*mass);
	64
	65	return fPmax*ref2/p2beta2;
	66	}
	67
	68	//_________________________________________________________________________
	69	Int_t AliTOFpidESD::MakePID(AliESDEvent *event, Double_t timeZero)
	70	{
	71	//
	72	// This function calculates the "detector response" PID probabilities
	73	// Just for a bare hint...
	74
	75	AliDebug(1,Form("TOF PID Parameters: Sigma (ps)= %f, Range= %f",fSigma,fRange));
	76	AliDebug(1,"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ \n");
	77
	78	Int_t ntrk=event->GetNumberOfTracks();
	79	AliESDtrack *tracks=new AliESDtrack[ntrk];
	80
	81	Int_t i;
	82	for (i=0; i<ntrk; i++) {
	83	AliESDtrack *t=event->GetTrack(i);
	84	tracks[i]=t;
	85	}
	86
	87	for (i=0; i<ntrk; i++) {
	88	AliESDtrack *t=tracks[i];
	89	if ((t->GetStatus()&AliESDtrack::kTOFout)==0) continue;
	90	if ((t->GetStatus()&AliESDtrack::kTIME)==0) continue;
	91	Double_t tof=t->GetTOFsignal()-timeZero;
	92	Double_t time[10]; t->GetIntegratedTimes(time);
	93	Double_t p[10];
	94	Double_t mom=t->GetP();
	95	Bool_t mismatch=kTRUE, heavy=kTRUE;
	96	for (Int_t j=0; j<AliPID::kSPECIES; j++) {
	97	Double_t mass=AliPID::ParticleMass(j);
	98	Double_t dpp=0.01; //mean relative pt resolution;
	99	if (mom>0.5) dpp=0.01*mom;
	100	Double_t sigma=dpptime[j]/(1.+ mommom/(mass*mass));
	101	sigma=TMath::Sqrt(sigmasigma + fSigmafSigma);
	102	if (TMath::Abs(tof-time[j]) > fRange*sigma) {
	103	p[j]=TMath::Exp(-0.5fRangefRange)/sigma;
	104	} else
	105	p[j]=TMath::Exp(-0.5(tof-time[j])(tof-time[j])/(sigma*sigma))/sigma;
	106
	107	// Check the mismatching
	108	Double_t pm=GetMismatchProbability(mom,mass);
	109	if (p[j]>pm) mismatch=kFALSE;
	110
	111	// Check for particles heavier than (AliPID::kSPECIES - 1)
	112	if (tof < (time[j] + fRange*sigma)) heavy=kFALSE;
	113
	114	}
	115
	116	if (mismatch)
	117	for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1/AliPID::kSPECIES;
	118
	119	t->SetTOFpid(p);
	120
	121	if (heavy) t->ResetStatus(AliESDtrack::kTOFpid);
	122
	123	}
	124
	125	delete[] tracks;
	126
	127	return 0;
	128	}
	129
	130	//_________________________________________________________________________
	131	Int_t AliTOFpidESD::MakePID(AliESDEvent *event)
	132	{
	133	//
	134	// This function calculates the "detector response" PID probabilities
	135	// Just for a bare hint...
	136
	137	Int_t ntrk=event->GetNumberOfTracks();
	138	AliESDtrack *tracks=new AliESDtrack[ntrk];
	139
	140	Int_t i;
	141	for (i=0; i<ntrk; i++) {
	142	AliESDtrack *t=event->GetTrack(i);
	143	tracks[i]=t;
	144	}
	145
	146	for (i=0; i<ntrk; i++) {
	147	AliESDtrack *t=tracks[i];
	148	if ((t->GetStatus()&AliESDtrack::kTOFout)==0) continue;
	149	if ((t->GetStatus()&AliESDtrack::kTIME)==0) continue;
	150	Double_t tof=t->GetTOFsignal();
	151	Double_t time[10]; t->GetIntegratedTimes(time);
	152	Double_t p[10];
	153	Double_t mom=t->GetP();
	154	Bool_t mismatch=kTRUE, heavy=kTRUE;
	155	for (Int_t j=0; j<AliPID::kSPECIES; j++) {
	156	Double_t mass=AliPID::ParticleMass(j);
	157	Double_t dpp=0.01; //mean relative pt resolution;
	158	if (mom>0.5) dpp=0.01*mom;
	159	Double_t sigma=dpptime[j]/(1.+ mommom/(mass*mass));
	160	sigma=TMath::Sqrt(sigmasigma + fSigmafSigma);
	161	if (TMath::Abs(tof-time[j]) > fRange*sigma) {
	162	p[j]=TMath::Exp(-0.5fRangefRange)/sigma;
	163	} else
	164	p[j]=TMath::Exp(-0.5(tof-time[j])(tof-time[j])/(sigma*sigma))/sigma;
	165
	166	// Check the mismatching
	167	Double_t pm=GetMismatchProbability(mom,mass);
	168	if (p[j]>pm) mismatch=kFALSE;
	169
	170	// Check for particles heavier than (AliPID::kSPECIES - 1)
	171	if (tof < (time[j] + fRange*sigma)) heavy=kFALSE;
	172
	173	}
	174
	175	if (mismatch)
	176	for (Int_t j=0; j<AliPID::kSPECIES; j++) p[j]=1/AliPID::kSPECIES;
	177
	178	t->SetTOFpid(p);
	179
	180	if (heavy) t->ResetStatus(AliESDtrack::kTOFpid);
	181
	182	}
	183
	184	delete[] tracks;
	185
	186	return 0;
	187	}
	188