[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)),
  ftimestamp(0),
  fVertexZ(99999),
  ftimezero(9999999),
  fnhits(-1),
  fOutputTree(0x0)             

{
  /* 
   * default constructor 
   */

  for (Int_t i = 0; i < MAXHITS; i++){
      fmomentum[i] = 999999;
      flength[i] = 999999;
      findex[i] = -1;
      ftime[i] = 999999;
      ftot[i] = 999999;
      ftexp[i] = 999999;
  }

  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 *) {
  //
  // 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);  // not used for the time being

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