[u/mrichter/AliRoot.git] / TOF / AliTOFAnalysisTaskCalibTree.cxx

#include "AliTOFAnalysisTaskCalibTree.h"
#include "AliAnalysisManager.h"
#include "AliAODHandler.h"
#include "TTree.h"
#include "AliCDBManager.h"
#include "AliGRPManager.h"
#include "AliGRPObject.h"
#include "AliPhysicsSelection.h"
#include "AliESDtrack.h"
#include "AliESDEvent.h"
#include "AliESDpid.h"
#include "AliESDtrackCuts.h"
#include "AliTOFT0v1.h"
#include "AliTOFT0maker.h"
#include "AliTOFcalib.h"

ClassImp(AliTOFAnalysisTaskCalibTree)
  
//_______________________________________________________
  
AliTOFAnalysisTaskCalibTree::AliTOFAnalysisTaskCalibTree(const Char_t* name) :
AliAnalysisTaskSE(name),
  fInitFlag(kFALSE),                   
  fEventSelectionFlag(kFALSE),        
  fVertexSelectionFlag(kFALSE),       
  fVertexCut(1000.),              
  fDiscardPileupEventFlag(kFALSE),   
  fCalibrateTOFsignal(kFALSE),       
  fComputeT0TOF(kFALSE),             
  fUseT0TOF(kFALSE),                 
  fUseLHCClockPhase(kFALSE),         
  fPrimaryDCASelectionFlag(kFALSE),  
  fRunNumber(0),                   
  fESDEvent(0),             
  fEventCuts(new AliPhysicsSelection()),    
  fTrackCuts(new AliESDtrackCuts()),  
  fESDpid(new AliESDpid()),
  fStartTime(0),
  fEndTime(0),
  fElapsedTime(0),
  fIsCollisionCandidate(kFALSE),
  fHasVertex(kFALSE),
  fVertex(NULL),
  fGRPManager(new AliGRPManager()),         
  fGRPObject(NULL),     
  fSpecificStorageParOffline(), 
  fSpecificStorageRunParams(),  
  fTimeResolution(80.),
  fTOFcalib(new AliTOFcalib()),             
  fTOFT0maker(new AliTOFT0maker(fESDpid, fTOFcalib)),         
  fTOFT0v1(new AliTOFT0v1(fESDpid)),
  fOutputTree(0x0)             

{
  /* 
   * default constructor 
   */

  DefineOutput(1, TTree::Class());  

}

//_______________________________________________________

AliTOFAnalysisTaskCalibTree::~AliTOFAnalysisTaskCalibTree()
{
  /*
   * default destructor
   */
  delete fEventCuts;
  delete fTrackCuts;
  delete fESDpid;
  delete fTOFcalib;
  delete fTOFT0maker;
  delete fTOFT0v1;
  if (fOutputTree) {
    delete fOutputTree;
    fOutputTree = 0x0;
  }

}

//_______________________________________________________

void
AliTOFAnalysisTaskCalibTree::UserCreateOutputObjects()
{
  /*
   * user create output objects
   */

  fOutputTree = new TTree("aodTree", "Tree with TOF calib output"); 

  /* setup output tree */
  fOutputTree->Branch("run", &fRunNumber, "run/I");
  fOutputTree->Branch("timestamp", &ftimestamp, "timestamp/i");
  fOutputTree->Branch("timezero", &ftimezero, "timezero/F");
  fOutputTree->Branch("vertex", &fVertexZ, "vertex/F");
  fOutputTree->Branch("nhits", &fnhits, "nhits/I");
  fOutputTree->Branch("momentum", &fmomentum, "momentum[nhits]/F");
  fOutputTree->Branch("length", &flength, "length[nhits]/F");
  fOutputTree->Branch("index", &findex, "index[nhits]/I");
  fOutputTree->Branch("time", &ftime, "time[nhits]/F");
  fOutputTree->Branch("tot", &ftot, "tot[nhits]/F");
  fOutputTree->Branch("texp", &ftexp, "texp[nhits]/F");

  PostData(1, fOutputTree);

}

//_______________________________________________________

void AliTOFAnalysisTaskCalibTree::UserExec(Option_t *option) {
  //
  // user exec
  //

  // unset fill AOD
  ((AliAODHandler*)(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()))->SetFillAOD(kFALSE);

  //init run
  if (!InitRun()) return;

  //init event 
  if (!InitEvent()) return;

  /*** ACCEPTED EVENT ***/
  
  // set vertex
  fVertexZ = fVertex->GetZ();

  // compute T0-TOF using all availeble tracks 
  fTOFT0v1->DefineT0("all", 0.0, 0.5);
  Float_t timeZeroTOF = -1000. * fTOFT0v1->GetResult(0);
  Float_t timeZeroTOF_sigma = 1000. * fTOFT0v1->GetResult(1);
  Int_t timeZeroTOF_tracks = fTOFT0v1->GetResult(3);

  // check T0-TOF sigma 
  if (timeZeroTOF_sigma >= 250.) ftimezero = 999999.; 
  else ftimezero = timeZeroTOF;

  // reset
  fnhits = 0;
  
  // loop over ESD tracks
  Int_t nTracks = fESDEvent->GetNumberOfTracks();
  AliESDtrack *track;
  Int_t index;
  Double_t momentum, length, time, tot, timei[AliPID::kSPECIES];
  for (Int_t itrk = 0; itrk < nTracks; itrk++) {
    // get track
    track = fESDEvent->GetTrack(itrk);
    if (!track) continue;
    // check accept track
    if (!fTrackCuts->AcceptTrack(track)) continue;
    // check primary DCA
    if (fPrimaryDCASelectionFlag && !HasPrimaryDCA(track)) continue;
    // check TOF measurement
    if (!HasTOFMeasurement(track)) continue;

    /*** ACCEPTED TRACK WITH TOF MEASUREMENT ***/

    // get track info 
    momentum = track->P();
    length = track->GetIntegratedLength();
    index = track->GetTOFCalChannel();
    time = track->GetTOFsignal();
    tot = track->GetTOFsignalToT();
    track->GetIntegratedTimes(timei);

    // add hit to array (if there is room)
    if (fnhits > MAXHITS) continue;
    fmomentum[fnhits] = momentum;
    flength[fnhits] = length;
    findex[fnhits] = index;
    ftime[fnhits] = time;
    ftot[fnhits] = tot;
    ftexp[fnhits] = timei[AliPID::kPion];
    fnhits++;

  } /* end of loop over ESD tracks */

  // check number of hits and set fill output tree
  if (fnhits > 0)
    fOutputTree->Fill();

  PostData(1, fOutputTree);

}

//_______________________________________________________

Bool_t AliTOFAnalysisTaskCalibTree::InitRun() {

  //¯
  // init run
  //
  
  // get ESD event 
  fESDEvent = dynamic_cast<AliESDEvent *>(InputEvent());
  if (!fESDEvent) {
    AliError("cannot get ESD event");
    return kFALSE;
  }

  // get run number 
  Int_t runNb = fESDEvent->GetRunNumber();

  // check run already initialized 
  if (fInitFlag && fRunNumber == runNb) return kTRUE;
  fInitFlag = kFALSE;

  // init cdb 
  AliCDBManager *cdb = AliCDBManager::Instance();
  cdb->SetDefaultStorage("raw://");
  if (!fSpecificStorageParOffline.IsNull())
    cdb->SetSpecificStorage("TOF/Calib/ParOffline", fSpecificStorageParOffline.Data());
  if (!fSpecificStorageRunParams.IsNull())
    cdb->SetSpecificStorage("TOF/Calib/RunParams", fSpecificStorageRunParams.Data());
  cdb->SetRun(runNb);
  
  // init TOF calib
  if (!fTOFcalib->Init()) {
    AliError("cannot init TOF calib");
    return kFALSE;
  }

  // get GRP data
  if (!fGRPManager->ReadGRPEntry()) {
    AliError("error while reading \"GRPEntry\" from OCDB");
    return kFALSE;
  }
  fGRPObject = fGRPManager->GetGRPData();
  if (!fGRPObject) {
    AliError("cannot get \"GRPData\" from GRP manager");
    return kFALSE;
  }
  fStartTime = fGRPObject->GetTimeStart();
  fEndTime = fGRPObject->GetTimeEnd();
  AliInfo(Form("got \"GRPData\": startTime=%d, endTime=%d", fStartTime, fEndTime));
  
  AliInfo(Form("initialized for run %d", runNb));
  fInitFlag = kTRUE;
  fRunNumber = runNb;
  return kTRUE;
}

//_______________________________________________________

Bool_t AliTOFAnalysisTaskCalibTree::InitEvent() {

  //
  // init event
  //

  // get ESD event 
  fESDEvent = dynamic_cast<AliESDEvent *>(InputEvent());
  if (!fESDEvent) return kFALSE;

  // set event time and elapsed time
  ftimestamp = fESDEvent->GetTimeStamp();
  fElapsedTime = fESDEvent->GetTimeStamp() - fStartTime;

  // event selection
  if (fEventSelectionFlag){
    fIsCollisionCandidate = fEventCuts->IsCollisionCandidate(fESDEvent);
    if (!fIsCollisionCandidate) return kFALSE;
  }

  // vertex selection
  fVertex = fESDEvent->GetPrimaryVertexTracks();
  if (fVertex->GetNContributors() < 1) {
    fVertex = fESDEvent->GetPrimaryVertexSPD();
    if (fVertex->GetNContributors() < 1) fHasVertex = kFALSE;
    else fHasVertex = kTRUE;
  }
  else fHasVertex = kTRUE;
  if (fVertexSelectionFlag && (!fHasVertex || TMath::Abs(fVertex->GetZ()) > fVertexCut)) return kFALSE;

  // discard pile-up event is requested
  if (fDiscardPileupEventFlag) {
    if (fESDEvent->IsPileupFromSPD()) {
      printf("PILE-UP event, will be discarded\n");
      return kFALSE;
    }
  }

  // init TOF response 
  fESDpid->GetTOFResponse().SetTimeResolution(fTimeResolution);

  // init TOF-T0 maker 
  fTOFT0maker->SetTimeResolution(fTimeResolution);
  
  // calibrate ESD if requested
  if (fCalibrateTOFsignal)
    fTOFcalib->CalibrateESD(fESDEvent);

  // compute T0-TOF and apply it if requested
  if (fComputeT0TOF) 
    fTOFT0maker->ComputeT0TOF(fESDEvent);
  if (fUseT0TOF) {
    fTOFT0maker->ApplyT0TOF(fESDEvent);
    //fESDpid->MakePID(fESDEvent, kFALSE, 0.);
  }

  // init T0-TOF
  fTOFT0v1->Init(fESDEvent);

  return kTRUE;

}

//_______________________________________________________

Bool_t AliTOFAnalysisTaskCalibTree::HasTOFMeasurement(AliESDtrack *track) {

  //
  // has TOF measurement
  //

  //check TOF status flags 
  if (!(track->GetStatus() & AliESDtrack::kTOFout) ||
      !(track->GetStatus() & AliESDtrack::kTIME)) return kFALSE;

  // check integrated length
  if (track->GetIntegratedLength() < 350.) return kFALSE;

  // TOF measurement ok
  return kTRUE;
}

//_______________________________________________________

Bool_t AliTOFAnalysisTaskCalibTree::HasPrimaryDCA(AliESDtrack *track) {

  //
  // has primary DCA
  //

  // cut on transverse impact parameter
  Float_t d0z0[2],covd0z0[3];
  track->GetImpactParameters(d0z0, covd0z0);
  Float_t sigma= 0.0050 + 0.0060 / TMath::Power(track->Pt(), 0.9);
  Float_t d0max = 7. * sigma;
  //
  Float_t sigmaZ = 0.0146 + 0.0070 / TMath::Power(track->Pt(), 1.114758);
  if (track->Pt() > 1.) sigmaZ = 0.0216;
  Float_t d0maxZ = 5. * sigmaZ;
  //
  if(TMath::Abs(d0z0[0]) > d0max || TMath::Abs(d0z0[1]) > d0maxZ) 
    return kFALSE;
  
  /* primary DCA ok */
  return kTRUE;
}
Commit	Line	Data
7cfa8ae2	1	#include "AliTOFAnalysisTaskCalibTree.h"
	2	#include "AliAnalysisManager.h"
	3	#include "AliAODHandler.h"
	4	#include "TTree.h"
	5	#include "AliCDBManager.h"
	6	#include "AliGRPManager.h"
	7	#include "AliGRPObject.h"
	8	#include "AliPhysicsSelection.h"
	9	#include "AliESDtrack.h"
	10	#include "AliESDEvent.h"
	11	#include "AliESDpid.h"
	12	#include "AliESDtrackCuts.h"
	13	#include "AliTOFT0v1.h"
	14	#include "AliTOFT0maker.h"
	15	#include "AliTOFcalib.h"
	16
	17	ClassImp(AliTOFAnalysisTaskCalibTree)
	18
	19	//_______________________________________________________
	20
	21	AliTOFAnalysisTaskCalibTree::AliTOFAnalysisTaskCalibTree(const Char_t* name) :
	22	AliAnalysisTaskSE(name),
	23	fInitFlag(kFALSE),
	24	fEventSelectionFlag(kFALSE),
	25	fVertexSelectionFlag(kFALSE),
	26	fVertexCut(1000.),
	27	fDiscardPileupEventFlag(kFALSE),
	28	fCalibrateTOFsignal(kFALSE),
	29	fComputeT0TOF(kFALSE),
	30	fUseT0TOF(kFALSE),
	31	fUseLHCClockPhase(kFALSE),
	32	fPrimaryDCASelectionFlag(kFALSE),
	33	fRunNumber(0),
	34	fESDEvent(0),
	35	fEventCuts(new AliPhysicsSelection()),
	36	fTrackCuts(new AliESDtrackCuts()),
	37	fESDpid(new AliESDpid()),
	38	fStartTime(0),
	39	fEndTime(0),
	40	fElapsedTime(0),
	41	fIsCollisionCandidate(kFALSE),
	42	fHasVertex(kFALSE),
	43	fVertex(NULL),
	44	fGRPManager(new AliGRPManager()),
	45	fGRPObject(NULL),
	46	fSpecificStorageParOffline(),
	47	fSpecificStorageRunParams(),
	48	fTimeResolution(80.),
	49	fTOFcalib(new AliTOFcalib()),
	50	fTOFT0maker(new AliTOFT0maker(fESDpid, fTOFcalib)),
228b3dce	51	fTOFT0v1(new AliTOFT0v1(fESDpid)),
228b3dce	52	fOutputTree(0x0)
7cfa8ae2	53
	54	{
	55	/*
	56	* default constructor
	57	*/
	58
228b3dce	59	DefineOutput(1, TTree::Class());
228b3dce	60
7cfa8ae2	61	}
	62
	63	//_______________________________________________________
	64
	65	AliTOFAnalysisTaskCalibTree::~AliTOFAnalysisTaskCalibTree()
	66	{
	67	/*
	68	* default destructor
	69	*/
	70	delete fEventCuts;
	71	delete fTrackCuts;
	72	delete fESDpid;
	73	delete fTOFcalib;
	74	delete fTOFT0maker;
	75	delete fTOFT0v1;
228b3dce	76	if (fOutputTree) {
	77	delete fOutputTree;
	78	fOutputTree = 0x0;
	79	}
7cfa8ae2	80
	81	}
	82
	83	//_______________________________________________________
	84
	85	void
	86	AliTOFAnalysisTaskCalibTree::UserCreateOutputObjects()
	87	{
	88	/*
	89	* user create output objects
	90	*/
	91
228b3dce	92	fOutputTree = new TTree("aodTree", "Tree with TOF calib output");
228b3dce	93
7cfa8ae2	94	/* setup output tree */
228b3dce	95	fOutputTree->Branch("run", &fRunNumber, "run/I");
	96	fOutputTree->Branch("timestamp", &ftimestamp, "timestamp/i");
	97	fOutputTree->Branch("timezero", &ftimezero, "timezero/F");
	98	fOutputTree->Branch("vertex", &fVertexZ, "vertex/F");
	99	fOutputTree->Branch("nhits", &fnhits, "nhits/I");
	100	fOutputTree->Branch("momentum", &fmomentum, "momentum[nhits]/F");
	101	fOutputTree->Branch("length", &flength, "length[nhits]/F");
	102	fOutputTree->Branch("index", &findex, "index[nhits]/I");
	103	fOutputTree->Branch("time", &ftime, "time[nhits]/F");
	104	fOutputTree->Branch("tot", &ftot, "tot[nhits]/F");
	105	fOutputTree->Branch("texp", &ftexp, "texp[nhits]/F");
	106
	107	PostData(1, fOutputTree);
7cfa8ae2	108
	109	}
	110
	111	//_______________________________________________________
	112
	113	void AliTOFAnalysisTaskCalibTree::UserExec(Option_t *option) {
	114	//
	115	// user exec
	116	//
	117
	118	// unset fill AOD
	119	((AliAODHandler*)(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()))->SetFillAOD(kFALSE);
	120
	121	//init run
	122	if (!InitRun()) return;
	123
	124	//init event
	125	if (!InitEvent()) return;
	126
	127	/* ACCEPTED EVENT */
	128
	129	// set vertex
	130	fVertexZ = fVertex->GetZ();
	131
	132	// compute T0-TOF using all availeble tracks
	133	fTOFT0v1->DefineT0("all", 0.0, 0.5);
	134	Float_t timeZeroTOF = -1000. * fTOFT0v1->GetResult(0);
	135	Float_t timeZeroTOF_sigma = 1000. * fTOFT0v1->GetResult(1);
	136	Int_t timeZeroTOF_tracks = fTOFT0v1->GetResult(3);
	137
	138	// check T0-TOF sigma
	139	if (timeZeroTOF_sigma >= 250.) ftimezero = 999999.;
	140	else ftimezero = timeZeroTOF;
	141
	142	// reset
	143	fnhits = 0;
	144
	145	// loop over ESD tracks
	146	Int_t nTracks = fESDEvent->GetNumberOfTracks();
	147	AliESDtrack *track;
	148	Int_t index;
	149	Double_t momentum, length, time, tot, timei[AliPID::kSPECIES];
	150	for (Int_t itrk = 0; itrk < nTracks; itrk++) {
	151	// get track
	152	track = fESDEvent->GetTrack(itrk);
	153	if (!track) continue;
	154	// check accept track
	155	if (!fTrackCuts->AcceptTrack(track)) continue;
	156	// check primary DCA
	157	if (fPrimaryDCASelectionFlag && !HasPrimaryDCA(track)) continue;
	158	// check TOF measurement
	159	if (!HasTOFMeasurement(track)) continue;
	160
	161	/* ACCEPTED TRACK WITH TOF MEASUREMENT */
	162
	163	// get track info
	164	momentum = track->P();
	165	length = track->GetIntegratedLength();
	166	index = track->GetTOFCalChannel();
	167	time = track->GetTOFsignal();
	168	tot = track->GetTOFsignalToT();
	169	track->GetIntegratedTimes(timei);
	170
	171	// add hit to array (if there is room)
172	if (fnhits > MAXHITS) continue;
173	fmomentum[fnhits] = momentum;
174	flength[fnhits] = length;
175	findex[fnhits] = index;
176	ftime[fnhits] = time;
177	ftot[fnhits] = tot;
178	ftexp[fnhits] = timei[AliPID::kPion];
179	fnhits++;
180
181	} /* end of loop over ESD tracks */
182
183	// check number of hits and set fill output tree
184	if (fnhits > 0)
228b3dce	185	fOutputTree->Fill();
	186
	187	PostData(1, fOutputTree);
7cfa8ae2	188
	189	}
	190
	191	//_______________________________________________________
	192
	193	Bool_t AliTOFAnalysisTaskCalibTree::InitRun() {
	194
228b3dce	195	//¯
7cfa8ae2	196	// init run
	197	//
	198
	199	// get ESD event
	200	fESDEvent = dynamic_cast<AliESDEvent *>(InputEvent());
	201	if (!fESDEvent) {
	202	AliError("cannot get ESD event");
	203	return kFALSE;
	204	}
	205
	206	// get run number
	207	Int_t runNb = fESDEvent->GetRunNumber();
	208
	209	// check run already initialized
	210	if (fInitFlag && fRunNumber == runNb) return kTRUE;
	211	fInitFlag = kFALSE;
	212
	213	// init cdb
	214	AliCDBManager *cdb = AliCDBManager::Instance();
	215	cdb->SetDefaultStorage("raw://");
	216	if (!fSpecificStorageParOffline.IsNull())
	217	cdb->SetSpecificStorage("TOF/Calib/ParOffline", fSpecificStorageParOffline.Data());
	218	if (!fSpecificStorageRunParams.IsNull())
	219	cdb->SetSpecificStorage("TOF/Calib/RunParams", fSpecificStorageRunParams.Data());
	220	cdb->SetRun(runNb);
	221
	222	// init TOF calib
	223	if (!fTOFcalib->Init()) {
	224	AliError("cannot init TOF calib");
	225	return kFALSE;
	226	}
	227
	228	// get GRP data
	229	if (!fGRPManager->ReadGRPEntry()) {
	230	AliError("error while reading \"GRPEntry\" from OCDB");
	231	return kFALSE;
	232	}
	233	fGRPObject = fGRPManager->GetGRPData();
	234	if (!fGRPObject) {
	235	AliError("cannot get \"GRPData\" from GRP manager");
	236	return kFALSE;
	237	}
	238	fStartTime = fGRPObject->GetTimeStart();
	239	fEndTime = fGRPObject->GetTimeEnd();
	240	AliInfo(Form("got \"GRPData\": startTime=%d, endTime=%d", fStartTime, fEndTime));
	241
	242	AliInfo(Form("initialized for run %d", runNb));
	243	fInitFlag = kTRUE;
	244	fRunNumber = runNb;
	245	return kTRUE;
	246	}
	247
	248	//_______________________________________________________
	249
	250	Bool_t AliTOFAnalysisTaskCalibTree::InitEvent() {
	251
	252	//
	253	// init event
	254	//
	255
	256	// get ESD event
	257	fESDEvent = dynamic_cast<AliESDEvent *>(InputEvent());
	258	if (!fESDEvent) return kFALSE;
	259
260	// set event time and elapsed time
261	ftimestamp = fESDEvent->GetTimeStamp();
262	fElapsedTime = fESDEvent->GetTimeStamp() - fStartTime;
263
264	// event selection
228b3dce	265	if (fEventSelectionFlag){
	266	fIsCollisionCandidate = fEventCuts->IsCollisionCandidate(fESDEvent);
	267	if (!fIsCollisionCandidate) return kFALSE;
	268	}
7cfa8ae2	269
	270	// vertex selection
	271	fVertex = fESDEvent->GetPrimaryVertexTracks();
	272	if (fVertex->GetNContributors() < 1) {
	273	fVertex = fESDEvent->GetPrimaryVertexSPD();
	274	if (fVertex->GetNContributors() < 1) fHasVertex = kFALSE;
	275	else fHasVertex = kTRUE;
	276	}
	277	else fHasVertex = kTRUE;
	278	if (fVertexSelectionFlag && (!fHasVertex \|\| TMath::Abs(fVertex->GetZ()) > fVertexCut)) return kFALSE;
	279
	280	// discard pile-up event is requested
	281	if (fDiscardPileupEventFlag) {
	282	if (fESDEvent->IsPileupFromSPD()) {
	283	printf("PILE-UP event, will be discarded\n");
	284	return kFALSE;
	285	}
	286	}
	287
	288	// init TOF response
	289	fESDpid->GetTOFResponse().SetTimeResolution(fTimeResolution);
	290
	291	// init TOF-T0 maker
	292	fTOFT0maker->SetTimeResolution(fTimeResolution);
	293
	294	// calibrate ESD if requested
	295	if (fCalibrateTOFsignal)
	296	fTOFcalib->CalibrateESD(fESDEvent);
	297
	298	// compute T0-TOF and apply it if requested
	299	if (fComputeT0TOF)
	300	fTOFT0maker->ComputeT0TOF(fESDEvent);
	301	if (fUseT0TOF) {
	302	fTOFT0maker->ApplyT0TOF(fESDEvent);
	303	//fESDpid->MakePID(fESDEvent, kFALSE, 0.);
	304	}
	305
	306	// init T0-TOF
	307	fTOFT0v1->Init(fESDEvent);
	308
	309	return kTRUE;
	310
	311	}
	312
	313	//_______________________________________________________
	314
	315	Bool_t AliTOFAnalysisTaskCalibTree::HasTOFMeasurement(AliESDtrack *track) {
	316
	317	//
	318	// has TOF measurement
	319	//
	320
	321	//check TOF status flags
	322	if (!(track->GetStatus() & AliESDtrack::kTOFout) \|\|
	323	!(track->GetStatus() & AliESDtrack::kTIME)) return kFALSE;
	324
	325	// check integrated length
	326	if (track->GetIntegratedLength() < 350.) return kFALSE;
	327
	328	// TOF measurement ok
	329	return kTRUE;
	330	}
	331
	332	//_______________________________________________________
333
334	Bool_t AliTOFAnalysisTaskCalibTree::HasPrimaryDCA(AliESDtrack *track) {
335
336	//
337	// has primary DCA
338	//
339
340	// cut on transverse impact parameter
341	Float_t d0z0[2],covd0z0[3];
342	track->GetImpactParameters(d0z0, covd0z0);
343	Float_t sigma= 0.0050 + 0.0060 / TMath::Power(track->Pt(), 0.9);
344	Float_t d0max = 7. * sigma;
345	//
346	Float_t sigmaZ = 0.0146 + 0.0070 / TMath::Power(track->Pt(), 1.114758);
347	if (track->Pt() > 1.) sigmaZ = 0.0216;
348	Float_t d0maxZ = 5. * sigmaZ;
349	//
350	if(TMath::Abs(d0z0[0]) > d0max \|\| TMath::Abs(d0z0[1]) > d0maxZ)
351	return kFALSE;
352
353	/* primary DCA ok */
354	return kTRUE;
355	}