[u/mrichter/AliRoot.git] / ANALYSIS / TenderSupplies / AliTOFTenderSupply.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.                  *
 **************************************************************************/


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// TOF tender: - load updated calibrations (for TOF and T0)
//             - set tofHeader if missing in ESDs (2010 data)
//             - re-apply PID 
//             
// Contacts: Pietro.Antonioli@bo.infn.it                                     //
//           Francesco.Noferini@bo.infn.it                                   //
///////////////////////////////////////////////////////////////////////////////
#include <TMath.h>
#include <TRandom.h>
#include <AliLog.h>
#include <AliESDEvent.h>
#include <AliESDtrack.h>
#include <AliESDInputHandler.h>
#include <AliAnalysisManager.h>
#include <AliESDpid.h>
#include <AliTender.h>

#include <AliTOFcalib.h>
#include <AliTOFT0maker.h>

#include <AliCDBManager.h>
#include <AliCDBEntry.h>
#include <AliT0CalibSeasonTimeShift.h>

#include "AliTOFTenderSupply.h"

ClassImp(AliTOFTenderSupply)

Float_t AliTOFTenderSupply::fgT0Aresolution = 75.;
Float_t AliTOFTenderSupply::fgT0Cresolution = 65.;

AliTOFTenderSupply::AliTOFTenderSupply() :
  AliTenderSupply(),
  fESDpid(0x0),
  fIsMC(kFALSE),
  fTimeZeroType(AliESDpid::kBest_T0),
  fCorrectExpTimes(kTRUE),
  fLHC10dPatch(kFALSE),
  fDebugLevel(0),
  fAutomaticSettings(kTRUE),
  fTOFCalib(0x0),
  fTOFT0maker(0x0),
  fTOFres(100.),
  fT0IntercalibrationShift(0)


{
  //
  // default ctor
  //
  fT0shift[0] = 0;
  fT0shift[1] = 0;
  fT0shift[2] = 0;
  fT0shift[3] = 0;
}

//_____________________________________________________
AliTOFTenderSupply::AliTOFTenderSupply(const char *name, const AliTender *tender) :
  AliTenderSupply(name,tender),
  fESDpid(0x0),
  fIsMC(kFALSE),
  fTimeZeroType(AliESDpid::kBest_T0),
  fCorrectExpTimes(kTRUE),
  fLHC10dPatch(kFALSE),
  fDebugLevel(0),
  fAutomaticSettings(kTRUE),
  fTOFCalib(0x0),
  fTOFT0maker(0x0),
  fTOFres(100.),
  fT0IntercalibrationShift(0)
 
{
  //
  // named ctor
  //

  fT0shift[0] = 0;
  fT0shift[1] = 0;
  fT0shift[2] = 0;
  fT0shift[3] = 0;
}

//_____________________________________________________
void AliTOFTenderSupply::Init()
{

  
  // Initialise TOF tender (this is called at each detected run change)
  AliLog::SetClassDebugLevel("AliTOFTenderSupply",10); 

  // Setup PID object, check for MC, set AliTOFcalib and TOFT0 maker conf
  Int_t run = fTender->GetRun();
  if (run == 0) return;                // to skip first init, when we don't have yet a run number

  if (fAutomaticSettings) {
    if (run>=114737&&run<=117223) {      //period="LHC10B";
      fCorrectExpTimes=kTRUE;
      fLHC10dPatch=kFALSE;
      fTOFres=100.;
      fTimeZeroType=AliESDpid::kTOF_T0;
      fT0IntercalibrationShift = 0;
    }
    else if (run>=118503&&run<=121040) { //period="LHC10C";
      fCorrectExpTimes=kTRUE;
      fLHC10dPatch=kFALSE;
      fTOFres=100.;
      fTimeZeroType=AliESDpid::kTOF_T0;
      fT0IntercalibrationShift = 0;
    }
    else if (run>=122195&&run<=126437) { //period="LHC10D";
      fCorrectExpTimes=kFALSE;
      fLHC10dPatch=kTRUE;
      fTOFres=100.;
      fTimeZeroType=AliESDpid::kBest_T0;
      fT0IntercalibrationShift = 0;
    }
    else if (run>=127719&&run<=130850) { //period="LHC10E";
      fCorrectExpTimes=kFALSE;
      fLHC10dPatch=kFALSE;
      fTOFres=100.;
      fTimeZeroType=AliESDpid::kBest_T0;
      fT0IntercalibrationShift = 30.;
    }
    else if (run>=133004&&run<=135029) { //period="LHC10F";
      fCorrectExpTimes=kFALSE;
      fLHC10dPatch=kFALSE;
      fTOFres=100.;
      fTimeZeroType=AliESDpid::kBest_T0;
      fT0IntercalibrationShift = 0.;
      AliWarning("TOF tender not supported for LHC10F period!! Settings are just a guess!!");
    }
    else if (run>=135654&&run<=136377) { //period="LHC10G";
      fCorrectExpTimes=kFALSE;
      fLHC10dPatch=kFALSE;
      fTOFres=100.;
      fTimeZeroType=AliESDpid::kBest_T0;
      fT0IntercalibrationShift = 0.;
      AliWarning("TOF tender not supported for LHC10G period!! Settings are just a guess!!");
    }
    else if (run>=136851&&run<=139517) { //period="LHC10H" - pass2;
      fCorrectExpTimes=kFALSE;
      fLHC10dPatch=kFALSE;                
      fTOFres=90.;
      fTimeZeroType=AliESDpid::kTOF_T0;
      fT0IntercalibrationShift = 0.;
    }
    else if (run>=139699) {              //period="LHC11A";
      fCorrectExpTimes=kFALSE;
      fLHC10dPatch=kFALSE;
      fTOFres=100.;
      fTimeZeroType=AliESDpid::kBest_T0;
      fT0IntercalibrationShift = 0.;
      AliWarning("TOF tender not supported for LHC11A period!! Settings are just a guess!!");
    }
  }

  // Check if another detector already created the esd pid object
  // if not we create it and set it to the ESD input handler
  fESDpid=fTender->GetESDhandler()->GetESDpid();
  if (!fESDpid) {
    fESDpid=new AliESDpid;
    fTender->GetESDhandler()->SetESDpid(fESDpid);
  }

  // Even if the user didn't set fIsMC, we force it on if we find the MC handler 
  AliAnalysisManager *mgr=AliAnalysisManager::GetAnalysisManager();
  if (mgr->GetMCtruthEventHandler() && !(fIsMC) ) {
    AliWarning("This ESD is MC, fIsMC found OFF: fIsMC turned ON");
    fIsMC=kTRUE;
  }

  // Configure TOF calibration class
  if (!fTOFCalib)fTOFCalib=new AliTOFcalib();  // create if needed
  fTOFCalib->SetRemoveMeanT0(!(fIsMC));        // must be kFALSE on MC (default is kTRUE)
  fTOFCalib->SetCalibrateTOFsignal(!(fIsMC));  // must be kFALSE on MC (no new calibration) (default is kTRUE)
  fTOFCalib->SetCorrectTExp(fCorrectExpTimes); // apply a fine tuning on the expected times at low momenta
  

  // Configure TOFT0 maker class
  //  if (!fTOFT0maker) fTOFT0maker = new AliTOFT0maker(fESDpid,fTOFCalib); // create if needed
  if (!fTOFT0maker) fTOFT0maker = new AliTOFT0maker(fESDpid); // without passing AliTOFCalib it uses the diamond
  fTOFT0maker->SetTimeResolution(fTOFres);     // set TOF resolution for the PID
  

  AliInfo("|******************************************************|");
  AliInfo(Form("|    Alice TOF Tender Initialisation (Run %d)  |",fTender->GetRun()));
  AliInfo("|    Settings:                                         |");
  AliInfo(Form("|    Correct Exp Times              :  %d               |",fCorrectExpTimes));
  AliInfo(Form("|    LHC10d patch                   :  %d               |",fLHC10dPatch));
  AliInfo(Form("|    TOF resolution for TOFT0 maker :  %5.2f (ps)     |",fTOFres));
  AliInfo(Form("|    timeZero selection             :  %d               |",fTimeZeroType));
  AliInfo(Form("|    MC flag                        :  %d               |",fIsMC));
  AliInfo(Form("|    TOF/T0 intecalibration shift   :  %5.2f (ps)     |",fT0IntercalibrationShift));
  AliInfo("|******************************************************|");


}

//_____________________________________________________
void AliTOFTenderSupply::ProcessEvent()
{
  //
  // Use updated calibrations for TOF and T0, reapply PID information
  // For MC: timeZero sampling and additional smearing for T0

  if (fDebugLevel > 1) AliInfo("process event");

  AliESDEvent *event=fTender->GetEvent();
  if (!event) return;
  if (fDebugLevel > 1) AliInfo("event read");


  if (fTender->RunChanged()){ 

    Init();            

    fTOFCalib->Init(fTender->GetRun());
    
    if(event->GetT0TOF()){ // read T0 detector correction from OCDB
      // OCDB instance
      AliCDBManager* ocdbMan = AliCDBManager::Instance();
      ocdbMan->SetRun(fTender->GetRun());    
      AliCDBEntry *entry = ocdbMan->Get("T0/Calib/TimeAdjust/");
      if(entry) {
	AliT0CalibSeasonTimeShift *clb = (AliT0CalibSeasonTimeShift*) entry->GetObject();
	Float_t *t0means= clb->GetT0Means();
	//      Float_t *t0sigmas = clb->GetT0Sigmas();
	fT0shift[0] = t0means[0] + fT0IntercalibrationShift;
	fT0shift[1] = t0means[1] + fT0IntercalibrationShift;
	fT0shift[2] = t0means[2] + fT0IntercalibrationShift;
	fT0shift[3] = t0means[3] + fT0IntercalibrationShift;
      } else {
	for (Int_t i=0;i<4;i++) fT0shift[i]=0;
	AliWarning("TofTender no T0 entry found T0shift set to 0");
      }
    }
  }


  fTOFCalib->CalibrateESD(event);   //recalculate TOF signal (no harm for MC, see settings inside init)
  if (fLHC10dPatch && !(fIsMC)) RecomputeTExp(event);

  Double_t startTime = 0.;
  if(fIsMC) startTime = fTOFCalib->TuneForMC(event,fTOFres);

  if (fDebugLevel > 1) Printf(" TofTender: startTime %f",startTime);
  if (fDebugLevel > 1) Printf(" TofTender: T0 time (orig) %f %f %f",event->GetT0TOF(0),event->GetT0TOF(1),event->GetT0TOF(2));
  // event by event TO detector treatment  
  if(event->GetT0TOF()){   // protection: we adjust T0 only if it is there....

    if (event->GetT0TOF(0) == 0) event->SetT0TOF(0, 9999999.); // in case no information we set to unknown
    if (event->GetT0TOF(1) == 0) event->SetT0TOF(1, 99999.);
    if (event->GetT0TOF(2) == 0) event->SetT0TOF(2, 99999.);

    if(!fIsMC){   // data: apply shifts to align around Zero
      event->SetT0TOF(0,event->GetT0TOF(0) - fT0shift[0]);
      event->SetT0TOF(1,event->GetT0TOF(1) - fT0shift[1]);
      event->SetT0TOF(2,event->GetT0TOF(2) - fT0shift[2]);
    } else {
      // MC: add smearing for realistic T0A and T0C resolution
      Double_t defResolutionT0A = 33.;   // in future we will get this from ESDrun data structure or via OCDB
      Double_t defResolutionT0C = 30.;   // for the moment we don't trust them
      if ( (fgT0Aresolution > defResolutionT0A) && (event->GetT0TOF(1)<90000.) ) { // add smearing only if signal is there
	Double_t addedSmearingT0A = TMath::Sqrt(fgT0Aresolution*fgT0Aresolution - defResolutionT0A*defResolutionT0A);
        Double_t smearingT0A = gRandom->Gaus(0.,addedSmearingT0A);
	event->SetT0TOF(1,event->GetT0TOF(1) + smearingT0A);
      }
      if ( (fgT0Cresolution > defResolutionT0C) && (event->GetT0TOF(2)<90000.) ) { // add smearing only if signal is there
	Double_t addedSmearingT0C = TMath::Sqrt(fgT0Cresolution*fgT0Cresolution - defResolutionT0C*defResolutionT0C);
	Double_t smearingT0C = gRandom->Gaus(0.,addedSmearingT0C);
        event->SetT0TOF(2,event->GetT0TOF(2) + smearingT0C);
      }
      if (event->GetT0TOF(0)<90000.) { // we recompute the AND only if it is already there...
	Double_t smearedT0AC = (event->GetT0TOF(1)+event->GetT0TOF(2))/2.;
	event->SetT0TOF(0,smearedT0AC); 
      }
      if (fDebugLevel > 1) Printf(" TofTender: T0 time (postSmear) %f %f %f",event->GetT0TOF(0),event->GetT0TOF(1),event->GetT0TOF(2));
      // add finally the timeZero offset also to the T0 detector information
      event->SetT0TOF(0,event->GetT0TOF(0) + startTime);
      event->SetT0TOF(1,event->GetT0TOF(1) + startTime);
      event->SetT0TOF(2,event->GetT0TOF(2) + startTime);  
      if (fDebugLevel > 1) Printf(" TofTender: T0 time (postStart) %f %f %f",event->GetT0TOF(0),event->GetT0TOF(1),event->GetT0TOF(2));
    }
    // after shifts adjust (data) or smearing+offset (MC) we 'clean' to default if signals not there 
    if(event->GetT0TOF(0) > 900000) event->SetT0TOF(0, 999999.);
    if(event->GetT0TOF(1) > 90000)  event->SetT0TOF(1, 99999.);
    if(event->GetT0TOF(2) > 90000)  event->SetT0TOF(2, 99999.);
  }
  if (fDebugLevel > 1) Printf(" TofTender: T0 time (FINAL) %f %f %f",event->GetT0TOF(0),event->GetT0TOF(1),event->GetT0TOF(2));
  
  //compute timeZero of the event via TOF-TO
  fTOFT0maker->ComputeT0TOF(event);
  fTOFT0maker->WriteInESD(event);

  // recalculate PID probabilities
  fESDpid->SetTOFResponse(event, (AliESDpid::EStartTimeType_t)fTimeZeroType);

  // this is for safety, especially if the user doesn't attach a PID tender after TOF tender  
  Int_t ntracks=event->GetNumberOfTracks();
  for(Int_t itrack = 0; itrack < ntracks; itrack++){
    fESDpid->MakeTOFPID(event->GetTrack(itrack),0);   
  }
  
  
}


//_____________________________________________________
void AliTOFTenderSupply::RecomputeTExp(AliESDEvent *event) const
{
  /*
   * calibrate TExp
   */

  
  /* loop over tracks */
  AliESDtrack *track = NULL;
  for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); itrk++) {
    /* get track and calibrate */
    track = event->GetTrack(itrk);
    RecomputeTExp(track);
  }
  
}

//_____________________________________________________
void AliTOFTenderSupply::RecomputeTExp(AliESDtrack *track) const
{
  /*** 
       THIS METHOD IS BASED ON THEORETICAL EXPECTED TIME COMPUTED
       USING AVERAGE MOMENTUM BETWEEN INNER/OUTER TRACK PARAMS 
       IT IS A ROUGH APPROXIMATION APPLIED TO FIX LHC10d-pass2 DATA
       WHERE A WRONG GEOMETRY (FULL TRD) WAS INSERTED
  ***/

  Double_t texp[AliPID::kSPECIES];
  if (!track || !(track->GetStatus() & AliESDtrack::kTOFout)) return;


  /* get track params */
  Float_t l = track->GetIntegratedLength();
  Float_t p = track->P();
  if (track->GetInnerParam() && track->GetOuterParam()) {
    Float_t pin = track->GetInnerParam()->P();
    Float_t pout = track->GetOuterParam()->P();
    p = 0.5 * (pin + pout);
  }
  /* loop over particle types and compute expected time */
  for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++)
    texp[ipart] = GetExpTimeTh(AliPID::ParticleMass(ipart), p, l) - 37.; 
  // 37 is a final semiempirical offset to further adjust (calibrations were
  // done with "standard" integratedTimes)
  /* set integrated times */
  track->SetIntegratedTimes(texp);

}
Commit	Line	Data
ee981ab3	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	// //
dc369c13	19	// TOF tender: - load updated calibrations (for TOF and T0)
	20	// - set tofHeader if missing in ESDs (2010 data)
	21	// - re-apply PID
	22	//
	23	// Contacts: Pietro.Antonioli@bo.infn.it //
	24	// Francesco.Noferini@bo.infn.it //
ee981ab3	25	///////////////////////////////////////////////////////////////////////////////
dc369c13	26	#include <TMath.h>
dc369c13	27	#include <TRandom.h>
ee981ab3	28	#include <AliLog.h>
ee981ab3	29	#include <AliESDEvent.h>
88ccd4cf	30	#include <AliESDtrack.h>
ee981ab3	31	#include <AliESDInputHandler.h>
	32	#include <AliAnalysisManager.h>
	33	#include <AliESDpid.h>
	34	#include <AliTender.h>
	35
	36	#include <AliTOFcalib.h>
	37	#include <AliTOFT0maker.h>
	38
	39	#include <AliCDBManager.h>
	40	#include <AliCDBEntry.h>
	41	#include <AliT0CalibSeasonTimeShift.h>
	42
	43	#include "AliTOFTenderSupply.h"
	44
e26aa0bb	45	ClassImp(AliTOFTenderSupply)
e26aa0bb	46
dc369c13	47	Float_t AliTOFTenderSupply::fgT0Aresolution = 75.;
	48	Float_t AliTOFTenderSupply::fgT0Cresolution = 65.;
	49
ee981ab3	50	AliTOFTenderSupply::AliTOFTenderSupply() :
	51	AliTenderSupply(),
	52	fESDpid(0x0),
	53	fIsMC(kFALSE),
dc369c13	54	fTimeZeroType(AliESDpid::kBest_T0),
ee981ab3	55	fCorrectExpTimes(kTRUE),
88ccd4cf	56	fLHC10dPatch(kFALSE),
dc369c13	57	fDebugLevel(0),
63f693ef	58	fAutomaticSettings(kTRUE),
ee981ab3	59	fTOFCalib(0x0),
ee981ab3	60	fTOFT0maker(0x0),
63f693ef	61	fTOFres(100.),
63f693ef	62	fT0IntercalibrationShift(0)
ee981ab3	63
dc369c13	64
ee981ab3	65	{
	66	//
	67	// default ctor
	68	//
ee981ab3	69	fT0shift[0] = 0;
	70	fT0shift[1] = 0;
	71	fT0shift[2] = 0;
	72	fT0shift[3] = 0;
	73	}
	74
	75	//_____________________________________________________
	76	AliTOFTenderSupply::AliTOFTenderSupply(const char name, const AliTender tender) :
	77	AliTenderSupply(name,tender),
	78	fESDpid(0x0),
	79	fIsMC(kFALSE),
dc369c13	80	fTimeZeroType(AliESDpid::kBest_T0),
ee981ab3	81	fCorrectExpTimes(kTRUE),
88ccd4cf	82	fLHC10dPatch(kFALSE),
dc369c13	83	fDebugLevel(0),
63f693ef	84	fAutomaticSettings(kTRUE),
ee981ab3	85	fTOFCalib(0x0),
ee981ab3	86	fTOFT0maker(0x0),
63f693ef	87	fTOFres(100.),
63f693ef	88	fT0IntercalibrationShift(0)
ee981ab3	89
	90	{
	91	//
	92	// named ctor
	93	//
	94
	95	fT0shift[0] = 0;
	96	fT0shift[1] = 0;
	97	fT0shift[2] = 0;
	98	fT0shift[3] = 0;
	99	}
	100
	101	//_____________________________________________________
	102	void AliTOFTenderSupply::Init()
	103	{
ee981ab3	104
dc369c13	105
dc369c13	106	// Initialise TOF tender (this is called at each detected run change)
b3e3d195	107	AliLog::SetClassDebugLevel("AliTOFTenderSupply",10);
b3e3d195	108
dc369c13	109	// Setup PID object, check for MC, set AliTOFcalib and TOFT0 maker conf
63f693ef	110	Int_t run = fTender->GetRun();
63f693ef	111	if (run == 0) return; // to skip first init, when we don't have yet a run number
ee981ab3	112
63f693ef	113	if (fAutomaticSettings) {
	114	if (run>=114737&&run<=117223) { //period="LHC10B";
	115	fCorrectExpTimes=kTRUE;
	116	fLHC10dPatch=kFALSE;
	117	fTOFres=100.;
	118	fTimeZeroType=AliESDpid::kTOF_T0;
	119	fT0IntercalibrationShift = 0;
	120	}
	121	else if (run>=118503&&run<=121040) { //period="LHC10C";
	122	fCorrectExpTimes=kTRUE;
	123	fLHC10dPatch=kFALSE;
	124	fTOFres=100.;
	125	fTimeZeroType=AliESDpid::kTOF_T0;
	126	fT0IntercalibrationShift = 0;
	127	}
	128	else if (run>=122195&&run<=126437) { //period="LHC10D";
	129	fCorrectExpTimes=kFALSE;
	130	fLHC10dPatch=kTRUE;
	131	fTOFres=100.;
	132	fTimeZeroType=AliESDpid::kBest_T0;
	133	fT0IntercalibrationShift = 0;
	134	}
	135	else if (run>=127719&&run<=130850) { //period="LHC10E";
	136	fCorrectExpTimes=kFALSE;
	137	fLHC10dPatch=kFALSE;
	138	fTOFres=100.;
	139	fTimeZeroType=AliESDpid::kBest_T0;
	140	fT0IntercalibrationShift = 30.;
	141	}
	142	else if (run>=133004&&run<=135029) { //period="LHC10F";
	143	fCorrectExpTimes=kFALSE;
	144	fLHC10dPatch=kFALSE;
	145	fTOFres=100.;
	146	fTimeZeroType=AliESDpid::kBest_T0;
	147	fT0IntercalibrationShift = 0.;
	148	AliWarning("TOF tender not supported for LHC10F period!! Settings are just a guess!!");
	149	}
	150	else if (run>=135654&&run<=136377) { //period="LHC10G";
	151	fCorrectExpTimes=kFALSE;
	152	fLHC10dPatch=kFALSE;
	153	fTOFres=100.;
	154	fTimeZeroType=AliESDpid::kBest_T0;
	155	fT0IntercalibrationShift = 0.;
	156	AliWarning("TOF tender not supported for LHC10G period!! Settings are just a guess!!");
	157	}
0715e776	158	else if (run>=136851&&run<=139517) { //period="LHC10H" - pass2;
63f693ef	159	fCorrectExpTimes=kFALSE;
0715e776	160	fLHC10dPatch=kFALSE;
63f693ef	161	fTOFres=90.;
	162	fTimeZeroType=AliESDpid::kTOF_T0;
	163	fT0IntercalibrationShift = 0.;
63f693ef	164	}
	165	else if (run>=139699) { //period="LHC11A";
	166	fCorrectExpTimes=kFALSE;
	167	fLHC10dPatch=kFALSE;
	168	fTOFres=100.;
	169	fTimeZeroType=AliESDpid::kBest_T0;
	170	fT0IntercalibrationShift = 0.;
	171	AliWarning("TOF tender not supported for LHC11A period!! Settings are just a guess!!");
	172	}
	173	}
ee981ab3	174
	175	// Check if another detector already created the esd pid object
	176	// if not we create it and set it to the ESD input handler
	177	fESDpid=fTender->GetESDhandler()->GetESDpid();
	178	if (!fESDpid) {
	179	fESDpid=new AliESDpid;
	180	fTender->GetESDhandler()->SetESDpid(fESDpid);
	181	}
	182
dc369c13	183	// Even if the user didn't set fIsMC, we force it on if we find the MC handler
ee981ab3	184	AliAnalysisManager *mgr=AliAnalysisManager::GetAnalysisManager();
dc369c13	185	if (mgr->GetMCtruthEventHandler() && !(fIsMC) ) {
	186	AliWarning("This ESD is MC, fIsMC found OFF: fIsMC turned ON");
	187	fIsMC=kTRUE;
	188	}
ee981ab3	189
dc369c13	190	// Configure TOF calibration class
	191	if (!fTOFCalib)fTOFCalib=new AliTOFcalib(); // create if needed
	192	fTOFCalib->SetRemoveMeanT0(!(fIsMC)); // must be kFALSE on MC (default is kTRUE)
	193	fTOFCalib->SetCalibrateTOFsignal(!(fIsMC)); // must be kFALSE on MC (no new calibration) (default is kTRUE)
	194	fTOFCalib->SetCorrectTExp(fCorrectExpTimes); // apply a fine tuning on the expected times at low momenta
	195
	196
	197	// Configure TOFT0 maker class
74830383	198	// if (!fTOFT0maker) fTOFT0maker = new AliTOFT0maker(fESDpid,fTOFCalib); // create if needed
74830383	199	if (!fTOFT0maker) fTOFT0maker = new AliTOFT0maker(fESDpid); // without passing AliTOFCalib it uses the diamond
dc369c13	200	fTOFT0maker->SetTimeResolution(fTOFres); // set TOF resolution for the PID
dc369c13	201
ee981ab3	202
dc369c13	203	AliInfo("\|******************************************************\|");
	204	AliInfo(Form("\| Alice TOF Tender Initialisation (Run %d) \|",fTender->GetRun()));
	205	AliInfo("\| Settings: \|");
	206	AliInfo(Form("\| Correct Exp Times : %d \|",fCorrectExpTimes));
	207	AliInfo(Form("\| LHC10d patch : %d \|",fLHC10dPatch));
	208	AliInfo(Form("\| TOF resolution for TOFT0 maker : %5.2f (ps) \|",fTOFres));
	209	AliInfo(Form("\| timeZero selection : %d \|",fTimeZeroType));
	210	AliInfo(Form("\| MC flag : %d \|",fIsMC));
63f693ef	211	AliInfo(Form("\| TOF/T0 intecalibration shift : %5.2f (ps) \|",fT0IntercalibrationShift));
dc369c13	212	AliInfo("\|******************************************************\|");
e4e3a90d	213
e4e3a90d	214
ee981ab3	215	}
	216
	217	//_____________________________________________________
	218	void AliTOFTenderSupply::ProcessEvent()
	219	{
	220	//
dc369c13	221	// Use updated calibrations for TOF and T0, reapply PID information
dc369c13	222	// For MC: timeZero sampling and additional smearing for T0
ee981ab3	223
dc369c13	224	if (fDebugLevel > 1) AliInfo("process event");
ee981ab3	225
	226	AliESDEvent *event=fTender->GetEvent();
	227	if (!event) return;
dc369c13	228	if (fDebugLevel > 1) AliInfo("event read");
dc369c13	229
e4e3a90d	230
ee981ab3	231
dc369c13	232	if (fTender->RunChanged()){
dc369c13	233
63f693ef	234	Init();
63f693ef	235
ee981ab3	236	fTOFCalib->Init(fTender->GetRun());
	237
	238	if(event->GetT0TOF()){ // read T0 detector correction from OCDB
	239	// OCDB instance
	240	AliCDBManager* ocdbMan = AliCDBManager::Instance();
	241	ocdbMan->SetRun(fTender->GetRun());
	242	AliCDBEntry *entry = ocdbMan->Get("T0/Calib/TimeAdjust/");
	243	if(entry) {
	244	AliT0CalibSeasonTimeShift clb = (AliT0CalibSeasonTimeShift) entry->GetObject();
	245	Float_t *t0means= clb->GetT0Means();
	246	// Float_t *t0sigmas = clb->GetT0Sigmas();
63f693ef	247	fT0shift[0] = t0means[0] + fT0IntercalibrationShift;
	248	fT0shift[1] = t0means[1] + fT0IntercalibrationShift;
	249	fT0shift[2] = t0means[2] + fT0IntercalibrationShift;
	250	fT0shift[3] = t0means[3] + fT0IntercalibrationShift;
dc369c13	251	} else {
63f693ef	252	for (Int_t i=0;i<4;i++) fT0shift[i]=0;
dc369c13	253	AliWarning("TofTender no T0 entry found T0shift set to 0");
dc369c13	254	}
ee981ab3	255	}
ee981ab3	256	}
88ccd4cf	257
88ccd4cf	258
dc369c13	259	fTOFCalib->CalibrateESD(event); //recalculate TOF signal (no harm for MC, see settings inside init)
	260	if (fLHC10dPatch && !(fIsMC)) RecomputeTExp(event);
	261
	262	Double_t startTime = 0.;
	263	if(fIsMC) startTime = fTOFCalib->TuneForMC(event,fTOFres);
	264
	265	if (fDebugLevel > 1) Printf(" TofTender: startTime %f",startTime);
	266	if (fDebugLevel > 1) Printf(" TofTender: T0 time (orig) %f %f %f",event->GetT0TOF(0),event->GetT0TOF(1),event->GetT0TOF(2));
	267	// event by event TO detector treatment
	268	if(event->GetT0TOF()){ // protection: we adjust T0 only if it is there....
	269
	270	if (event->GetT0TOF(0) == 0) event->SetT0TOF(0, 9999999.); // in case no information we set to unknown
	271	if (event->GetT0TOF(1) == 0) event->SetT0TOF(1, 99999.);
	272	if (event->GetT0TOF(2) == 0) event->SetT0TOF(2, 99999.);
ee981ab3	273
dc369c13	274	if(!fIsMC){ // data: apply shifts to align around Zero
220433fd	275	event->SetT0TOF(0,event->GetT0TOF(0) - fT0shift[0]);
	276	event->SetT0TOF(1,event->GetT0TOF(1) - fT0shift[1]);
	277	event->SetT0TOF(2,event->GetT0TOF(2) - fT0shift[2]);
dc369c13	278	} else {
	279	// MC: add smearing for realistic T0A and T0C resolution
	280	Double_t defResolutionT0A = 33.; // in future we will get this from ESDrun data structure or via OCDB
	281	Double_t defResolutionT0C = 30.; // for the moment we don't trust them
	282	if ( (fgT0Aresolution > defResolutionT0A) && (event->GetT0TOF(1)<90000.) ) { // add smearing only if signal is there
	283	Double_t addedSmearingT0A = TMath::Sqrt(fgT0AresolutionfgT0Aresolution - defResolutionT0AdefResolutionT0A);
	284	Double_t smearingT0A = gRandom->Gaus(0.,addedSmearingT0A);
	285	event->SetT0TOF(1,event->GetT0TOF(1) + smearingT0A);
	286	}
	287	if ( (fgT0Cresolution > defResolutionT0C) && (event->GetT0TOF(2)<90000.) ) { // add smearing only if signal is there
	288	Double_t addedSmearingT0C = TMath::Sqrt(fgT0CresolutionfgT0Cresolution - defResolutionT0CdefResolutionT0C);
	289	Double_t smearingT0C = gRandom->Gaus(0.,addedSmearingT0C);
	290	event->SetT0TOF(2,event->GetT0TOF(2) + smearingT0C);
	291	}
	292	if (event->GetT0TOF(0)<90000.) { // we recompute the AND only if it is already there...
	293	Double_t smearedT0AC = (event->GetT0TOF(1)+event->GetT0TOF(2))/2.;
	294	event->SetT0TOF(0,smearedT0AC);
	295	}
	296	if (fDebugLevel > 1) Printf(" TofTender: T0 time (postSmear) %f %f %f",event->GetT0TOF(0),event->GetT0TOF(1),event->GetT0TOF(2));
	297	// add finally the timeZero offset also to the T0 detector information
	298	event->SetT0TOF(0,event->GetT0TOF(0) + startTime);
	299	event->SetT0TOF(1,event->GetT0TOF(1) + startTime);
	300	event->SetT0TOF(2,event->GetT0TOF(2) + startTime);
	301	if (fDebugLevel > 1) Printf(" TofTender: T0 time (postStart) %f %f %f",event->GetT0TOF(0),event->GetT0TOF(1),event->GetT0TOF(2));
220433fd	302	}
dc369c13	303	// after shifts adjust (data) or smearing+offset (MC) we 'clean' to default if signals not there
	304	if(event->GetT0TOF(0) > 900000) event->SetT0TOF(0, 999999.);
	305	if(event->GetT0TOF(1) > 90000) event->SetT0TOF(1, 99999.);
	306	if(event->GetT0TOF(2) > 90000) event->SetT0TOF(2, 99999.);
ee981ab3	307	}
dc369c13	308	if (fDebugLevel > 1) Printf(" TofTender: T0 time (FINAL) %f %f %f",event->GetT0TOF(0),event->GetT0TOF(1),event->GetT0TOF(2));
ee981ab3	309
dc369c13	310	//compute timeZero of the event via TOF-TO
ee981ab3	311	fTOFT0maker->ComputeT0TOF(event);
	312	fTOFT0maker->WriteInESD(event);
	313
ee981ab3	314	// recalculate PID probabilities
ee981ab3	315	fESDpid->SetTOFResponse(event, (AliESDpid::EStartTimeType_t)fTimeZeroType);
dc369c13	316
dc369c13	317	// this is for safety, especially if the user doesn't attach a PID tender after TOF tender
ee981ab3	318	Int_t ntracks=event->GetNumberOfTracks();
ee981ab3	319	for(Int_t itrack = 0; itrack < ntracks; itrack++){
dc369c13	320	fESDpid->MakeTOFPID(event->GetTrack(itrack),0);
ee981ab3	321	}
	322
	323
	324	}
	325
	326
88ccd4cf	327	//_____________________________________________________
	328	void AliTOFTenderSupply::RecomputeTExp(AliESDEvent *event) const
	329	{
	330	/*
	331	* calibrate TExp
	332	*/
	333
	334
	335	/* loop over tracks */
	336	AliESDtrack *track = NULL;
	337	for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); itrk++) {
	338	/* get track and calibrate */
	339	track = event->GetTrack(itrk);
	340	RecomputeTExp(track);
	341	}
	342
	343	}
	344
	345	//_____________________________________________________
	346	void AliTOFTenderSupply::RecomputeTExp(AliESDtrack *track) const
	347	{
	348	/***
	349	THIS METHOD IS BASED ON THEORETICAL EXPECTED TIME COMPUTED
	350	USING AVERAGE MOMENTUM BETWEEN INNER/OUTER TRACK PARAMS
	351	IT IS A ROUGH APPROXIMATION APPLIED TO FIX LHC10d-pass2 DATA
	352	WHERE A WRONG GEOMETRY (FULL TRD) WAS INSERTED
	353	***/
	354
	355	Double_t texp[AliPID::kSPECIES];
	356	if (!track \|\| !(track->GetStatus() & AliESDtrack::kTOFout)) return;
ee981ab3	357
88ccd4cf	358
	359	/* get track params */
	360	Float_t l = track->GetIntegratedLength();
	361	Float_t p = track->P();
	362	if (track->GetInnerParam() && track->GetOuterParam()) {
	363	Float_t pin = track->GetInnerParam()->P();
	364	Float_t pout = track->GetOuterParam()->P();
	365	p = 0.5 * (pin + pout);
	366	}
	367	/* loop over particle types and compute expected time */
	368	for (Int_t ipart = 0; ipart < AliPID::kSPECIES; ipart++)
	369	texp[ipart] = GetExpTimeTh(AliPID::ParticleMass(ipart), p, l) - 37.;
	370	// 37 is a final semiempirical offset to further adjust (calibrations were
	371	// done with "standard" integratedTimes)
	372	/* set integrated times */
	373	track->SetIntegratedTimes(texp);
	374
	375	}
dc369c13	376
dc369c13	377