[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnCutESD2010.cxx

//
// Class AliRsnCutESD2010
//
// General implementation of a single cut strategy, which can be:
// - a value contained in a given interval  [--> IsBetween()   ]
// - a value equal to a given reference     [--> MatchesValue()]
//
// In all cases, the reference value(s) is (are) given as data members
// and each kind of cut requires a given value type (Int, UInt, Double),
// but the cut check procedure is then automatized and chosen thanks to
// an enumeration of the implemented cut types.
// At the end, the user (or any other point which uses this object) has
// to use the method IsSelected() to check if this cut has been passed.
//
// authors: Martin Vala (martin.vala@cern.ch)
//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
//

#include <Riostream.h>

#include "AliESDpid.h"
#include "AliTOFT0maker.h"
#include "AliTOFcalib.h"
#include "AliCDBManager.h"
#include "AliITSPIDResponse.h"

#include "AliRsnEvent.h"
#include "AliRsnDaughter.h"
#include "AliRsnCutESD2010.h"

ClassImp(AliRsnCutESD2010)

//_________________________________________________________________________________________________
AliRsnCutESD2010::AliRsnCutESD2010() :
  AliRsnCut(AliRsnCut::kDaughter),
  fIsMC(kFALSE),
  fCheckITS(kTRUE),
  fCheckTPC(kTRUE),
  fCheckTOF(kTRUE),
  fUseGlobal(kTRUE),
  fUseITSSA(kTRUE),
  fMaxITSband(1E6),
  fTPCpLimit(0.35),
  fMinTPCband(-1E6),
  fMaxTPCband( 1E6),
  fESDtrackCutsTPC(),
  fESDtrackCutsITS(),
  fESDpid(0x0),
  fTOFmaker(0x0),
  fTOFcalib(0x0),
  fTOFcalibrateESD(kFALSE),
  fTOFcorrectTExp(kFALSE),
  fTOFuseT0(kFALSE),
  fTOFtuneMC(kFALSE),
  fTOFresolution(0.0),
  fLastRun(-1)
{
//
// Default constructor.
//
}

//_________________________________________________________________________________________________
AliRsnCutESD2010::AliRsnCutESD2010
(const char *name) :
  AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
  fIsMC(kFALSE),
  fCheckITS(kTRUE),
  fCheckTPC(kTRUE),
  fCheckTOF(kTRUE),
  fUseGlobal(kTRUE),
  fUseITSSA(kTRUE),
  fMaxITSband(1E6),
  fTPCpLimit(0.35),
  fMinTPCband(-1E6),
  fMaxTPCband( 1E6),
  fESDtrackCutsTPC(),
  fESDtrackCutsITS(),
  fESDpid(0x0),
  fTOFmaker(0x0),
  fTOFcalib(0x0),
  fTOFcalibrateESD(kFALSE),
  fTOFcorrectTExp(kFALSE),
  fTOFuseT0(kFALSE),
  fTOFtuneMC(kFALSE),
  fTOFresolution(0.0),
  fLastRun(-1)
{
//
// Main constructor.
//
}

//_________________________________________________________________________________________________
AliRsnCutESD2010::AliRsnCutESD2010
(const AliRsnCutESD2010& copy) :
  AliRsnCut(copy),
  fIsMC(kFALSE),
  fCheckITS(copy.fCheckITS),
  fCheckTPC(copy.fCheckTPC),
  fCheckTOF(copy.fCheckTOF),
  fUseGlobal(copy.fUseGlobal),
  fUseITSSA(copy.fUseITSSA),
  fMaxITSband(copy.fMaxITSband),
  fTPCpLimit(copy.fTPCpLimit),
  fMinTPCband(copy.fMinTPCband),
  fMaxTPCband(copy.fMaxTPCband),
  fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
  fESDtrackCutsITS(copy.fESDtrackCutsITS),
  fESDpid(0x0),
  fTOFmaker(0x0),
  fTOFcalib(0x0),
  fTOFcalibrateESD(copy.fTOFcalibrateESD),
  fTOFcorrectTExp(copy.fTOFcorrectTExp),
  fTOFuseT0(copy.fTOFuseT0),
  fTOFtuneMC(copy.fTOFtuneMC),
  fTOFresolution(copy.fTOFresolution),
  fLastRun(-1)
{
//
// Main constructor.
//
}

//_________________________________________________________________________________________________
void AliRsnCutESD2010::InitializeToDefaults(Bool_t isSim)
{
//
// Main constructor.
//

  // ----> set TPC range for PID and calibration
  SetTPCrange(5.0, 3.0);
  SetTPCpLimit(0.35);
  
  // ----> set ITS range for PID
  SetITSband(4.0);
  
  // ----> set TPC calibration
  if (isSim) SetTPCpar(2.15898 / 50.0, 1.75295E1, 3.40030E-9, 1.96178, 3.91720);
  else       SetTPCpar(1.41543 / 50.0, 2.63394E1, 5.0411E-11, 2.12543, 4.88663);
  
  // ----> set standard quality cuts for TPC global tracks
  fESDtrackCutsTPC.SetRequireTPCStandAlone(kTRUE); // require to have the projection at inner TPC wall
  fESDtrackCutsTPC.SetMinNClustersTPC(70);
  fESDtrackCutsTPC.SetMaxChi2PerClusterTPC(4);
  fESDtrackCutsTPC.SetAcceptKinkDaughters(kFALSE);
  fESDtrackCutsTPC.SetRequireTPCRefit(kTRUE);
  fESDtrackCutsTPC.SetRequireITSRefit(kTRUE);
  fESDtrackCutsTPC.SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
  fESDtrackCutsTPC.SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9"); // DCA pt dependent: 7*(0.0050+0.0060/pt0.9)
  fESDtrackCutsTPC.SetMaxDCAToVertexZ(1e6); // disabled
  fESDtrackCutsTPC.SetDCAToVertex2D(kFALSE); // each DCA is checked separately
  fESDtrackCutsTPC.SetRequireSigmaToVertex(kFALSE);
  
  // ----> set standard quality cuts for ITS standalone tracks
  fESDtrackCutsITS.SetRequireITSStandAlone(kTRUE);
  fESDtrackCutsITS.SetRequireITSRefit(kTRUE);
  fESDtrackCutsITS.SetMinNClustersITS(4);
  fESDtrackCutsITS.SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
  fESDtrackCutsITS.SetMaxChi2PerClusterITS(1.);
  fESDtrackCutsITS.SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55"); // DCA pt dependent
  fESDtrackCutsITS.SetMaxDCAToVertexZ(1e6); // disabled
  fESDtrackCutsITS.SetDCAToVertex2D(kFALSE); // each DCA is checked separately
  
  // ----> set the TOF calibration depending on type of input (sim/data)
  SetTOFcorrectTExp(kTRUE);
  SetTOFuseT0(kTRUE);
  SetTOFresolution(100.0);
  if (isSim)
  {
    SetTOFcalibrateESD(kFALSE);
    SetTOFtuneMC(kTRUE);
  }
  else
  {
    //if (isPass2) SetTOFcalibrateESD(kFALSE); // potrebbe anche essere kFALSE
    SetTOFcalibrateESD(kTRUE);
    SetTOFtuneMC(kFALSE);
  }
}

//_________________________________________________________________________________________________
void AliRsnCutESD2010::SetEvent(AliRsnEvent *event)
{
  // don't do anything if the event is the same as before
  if (fEvent != 0x0 && fEvent == event) return;
  
  // retrieve the ESD event
  AliESDEvent *esd = event->GetRefESD();
  if (!esd)
  {
    fEvent = 0x0;
    return;
  }
  else
  {
    fEvent = event;
  }
  
  // if absent, initialize ESD pid responst
  if (!fESDpid)
  {
    fESDpid = new AliESDpid;
    fESDpid->GetTPCResponse().SetBetheBlochParameters(fTPCpar[0],fTPCpar[1],fTPCpar[2],fTPCpar[3],fTPCpar[4]);
  }
  
  // initialize DB to current run
  Int_t run = esd->GetRunNumber();
  if (run != fLastRun)
  {
    cout << "Run = " << run << " -- LAST = " << fLastRun << endl;
    fLastRun = run;
    
    // setup TOF maker & calibration
    if (!fTOFcalib) fTOFcalib = new AliTOFcalib;
    fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
    if (!fTOFmaker) fTOFmaker = new AliTOFT0maker(fESDpid, fTOFcalib);
    fTOFmaker->SetTimeResolution(fTOFresolution);
      
    AliCDBManager *cdb = AliCDBManager::Instance();
    cdb->ClearCache(); // suggestion by Annalisa
    cdb->Clear();      // suggestion by Annalisa
    cdb->SetDefaultStorage("raw://");
    cdb->SetRun(run);
    
    fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
    fTOFcalib->Init();
  }
  
  // if required, calibrate the TOF t0 maker with current event
  if (fTOFcalibrateESD) fTOFcalib->CalibrateESD(esd);
  if (fTOFtuneMC) fTOFmaker->TuneForMC(esd);
  if (fTOFuseT0) 
  {
    fTOFmaker->ComputeT0TOF(esd);
    fTOFmaker->ApplyT0TOF(esd);
    fESDpid->MakePID(esd, kFALSE, 0.);
  }
}

//_________________________________________________________________________________________________
Bool_t AliRsnCutESD2010::IsSelected(TObject *obj1, TObject* /*obj2*/)
{
//
// Cut checker.
//

  // coherence check: require an ESD track
  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(obj1);
  if (!daughter) return kFALSE;
  AliESDtrack *track = daughter->GetRefESDtrack();
  if (!track) return kFALSE;
  
  // if no reference event, skip
  if (!fEvent) return kFALSE;
  
  // ITS stuff #1 create the response function
  AliITSPIDResponse itsrsp(fIsMC);
  
  // TOF: define fixed function for compatibility range
  Double_t a1 = 0.01, a2 = -0.03;
  Double_t b1 = 0.25, b2 =  0.25;
  Double_t c1 = 0.05, c2 = -0.03;
  Double_t ymax, ymin;
  
  ULong_t  status;
  Int_t    k, nITS;
  Double_t times[10], tpcNSigma, tpcMaxNSigma, itsSignal, itsNSigma, mom, tofTime, tofSigma, tofRef, tofRel;
  Bool_t   okQuality, okTOF, okTPC, okITS, okTrack, isTPC, isITSSA;
  UChar_t  itsCluMap;
  
  // get commonly used variables
  status  = (ULong_t)track->GetStatus();
  mom     = track->P();
  isTPC   = ((status & AliESDtrack::kTPCin)  != 0);
  isITSSA = ((status & AliESDtrack::kTPCin)  == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
  
  // accept only tracks which are TPC+ITS or ITS standalone
  if (!isTPC   && !isITSSA) return kFALSE;
  if ( isTPC   && !fUseGlobal) return kFALSE;
  if ( isITSSA && !fUseITSSA) return kFALSE;
  
  if (isTPC)
  {
    // check standard ESD cuts
    okQuality = fESDtrackCutsTPC.IsSelected(track);
    //cout << "GLOBAL -- quality = " << (okQuality ? "GOOD" : "BAD") << endl;
    if (!okQuality) return kFALSE;
  
    // check TPC dE/dx
    if (fCheckTPC)
    {
      tpcNSigma = TMath::Abs(fESDpid->NumberOfSigmasTPC(track, AliPID::kKaon));
      if (track->GetInnerParam()->P() > fTPCpLimit) tpcMaxNSigma = fMinTPCband; else tpcMaxNSigma = fMaxTPCband;
      okTPC = (tpcNSigma <= tpcMaxNSigma);
      //cout << "RSN -- TPC    -- nsigma = " << tpcNSigma << ", max = " << tpcMaxNSigma << " --> " << (okTPC ? "OK" : "FAILED") << endl;
      //cout << "RSNTPC -- " << fTPCpar[0] << ' ' << fTPCpar[1] << ' ' << fTPCpar[2] << ' ' << fTPCpar[3] << ' ' << fTPCpar[4] << endl;
    }
    else
    {
      okTPC = kTRUE;
    }
    
    // check TOF (only if momentum is large than function asymptote and flags are OK)
    if (fCheckTOF)
    {
      if (((status & AliESDtrack::kTOFout) != 0) && ((status & AliESDtrack::kTIME) != 0) && mom > TMath::Max(b1, b2))
      {
        track->GetIntegratedTimes(times);
        tofTime  = (Double_t)track->GetTOFsignal();
        tofSigma = fTOFmaker->GetExpectedSigma(mom, times[AliPID::kKaon], AliPID::ParticleMass(AliPID::kKaon));
        tofRef   = times[AliPID::kKaon];
        if (tofRef > 0.0)
        {
          tofRel   = (tofTime - tofRef) / tofRef;
          ymax     = a1 / (mom - b1) + c1;
          ymin     = a2 / (mom - b2) + c2;
          okTOF    = (tofRel >= ymin && tofRel <= ymax);
          //cout << "TOF    -- diff = " << tofDiff << ", rel diff = " << tofRel << ", range = " << ymin << " to " << ymax << ", sigma = " << tofSigma << " --> " << (okTOF ? "OK" : "FAILED") << endl;
        }
        else
        {
          okTOF = kTRUE;
          if (!fCheckTPC) okTOF = kFALSE;
          //cout << "TOF    -- not checked due to ZERO reference time" << endl;
        }
      }
      else
      {
        okTOF = kTRUE;
        if (!fCheckTPC) okTOF = kFALSE;
        //cout << "TOF    -- not checked because TOF pid absent" << endl;
      }
    }
    else
    {
      okTOF = kTRUE;
    }
    
    // combine checks
    okTrack = okQuality && okTPC && okTOF;
    //cout << "GLOBAL -- overall = " << (okTrack ? "ACCEPTED" : "REJECTED") << endl;
  }
  else
  {
    // check standard ESD cuts
    okQuality = fESDtrackCutsITS.IsSelected(track);
    //cout << "ITSSA  -- quality = " << (okQuality ? "GOOD" : "BAD") << endl;
    if (!okQuality) return kFALSE;
    
    // check dE/dx
    if (fCheckITS)
    {
      itsSignal = track->GetITSsignal();
      itsCluMap = track->GetITSClusterMap();
      nITS      = 0;
      for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
      if (nITS < 3) 
      {
        okITS = kFALSE;
        //cout << "ITS    -- not checked due to too few PID clusters" << endl;
      }
      else
      {
        itsNSigma = itsrsp.GetNumberOfSigmas(mom, itsSignal, AliPID::kKaon, nITS, kTRUE);
        okITS = (TMath::Abs(itsNSigma) <= fMaxITSband);
        //cout << "ITS    -- nsigma = " << itsNSigma << ", max = " << fMaxITSband << " --> " << (okITS ? "OK" : "FAILED") << endl;
      }
    }
    else
    {
      okITS = kTRUE;
    }
    
    okTrack = okQuality && okITS;
    //cout << "ITSSA  -- overall = " << (okTrack ? "ACCEPTED" : "REJECTED") << endl;
  }
  
  return okTrack;
}
Commit	Line	Data
2dab9030	1	//
	2	// Class AliRsnCutESD2010
	3	//
	4	// General implementation of a single cut strategy, which can be:
	5	// - a value contained in a given interval [--> IsBetween() ]
	6	// - a value equal to a given reference [--> MatchesValue()]
	7	//
	8	// In all cases, the reference value(s) is (are) given as data members
	9	// and each kind of cut requires a given value type (Int, UInt, Double),
	10	// but the cut check procedure is then automatized and chosen thanks to
	11	// an enumeration of the implemented cut types.
	12	// At the end, the user (or any other point which uses this object) has
	13	// to use the method IsSelected() to check if this cut has been passed.
	14	//
	15	// authors: Martin Vala (martin.vala@cern.ch)
	16	// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
	17	//
	18
	19	#include <Riostream.h>
	20
	21	#include "AliESDpid.h"
	22	#include "AliTOFT0maker.h"
	23	#include "AliTOFcalib.h"
	24	#include "AliCDBManager.h"
	25	#include "AliITSPIDResponse.h"
	26
	27	#include "AliRsnEvent.h"
	28	#include "AliRsnDaughter.h"
	29	#include "AliRsnCutESD2010.h"
	30
	31	ClassImp(AliRsnCutESD2010)
	32
	33	//_________________________________________________________________________________________________
	34	AliRsnCutESD2010::AliRsnCutESD2010() :
	35	AliRsnCut(AliRsnCut::kDaughter),
	36	fIsMC(kFALSE),
	37	fCheckITS(kTRUE),
	38	fCheckTPC(kTRUE),
	39	fCheckTOF(kTRUE),
35765294	40	fUseGlobal(kTRUE),
35765294	41	fUseITSSA(kTRUE),
2dab9030	42	fMaxITSband(1E6),
	43	fTPCpLimit(0.35),
	44	fMinTPCband(-1E6),
	45	fMaxTPCband( 1E6),
	46	fESDtrackCutsTPC(),
	47	fESDtrackCutsITS(),
	48	fESDpid(0x0),
	49	fTOFmaker(0x0),
	50	fTOFcalib(0x0),
	51	fTOFcalibrateESD(kFALSE),
	52	fTOFcorrectTExp(kFALSE),
	53	fTOFuseT0(kFALSE),
	54	fTOFtuneMC(kFALSE),
	55	fTOFresolution(0.0),
	56	fLastRun(-1)
	57	{
	58	//
	59	// Default constructor.
	60	//
	61	}
	62
	63	//_________________________________________________________________________________________________
	64	AliRsnCutESD2010::AliRsnCutESD2010
	65	(const char *name) :
	66	AliRsnCut(name, AliRsnCut::kDaughter, 0.0, 0.0),
	67	fIsMC(kFALSE),
	68	fCheckITS(kTRUE),
	69	fCheckTPC(kTRUE),
	70	fCheckTOF(kTRUE),
35765294	71	fUseGlobal(kTRUE),
35765294	72	fUseITSSA(kTRUE),
2dab9030	73	fMaxITSband(1E6),
	74	fTPCpLimit(0.35),
	75	fMinTPCband(-1E6),
	76	fMaxTPCband( 1E6),
	77	fESDtrackCutsTPC(),
	78	fESDtrackCutsITS(),
	79	fESDpid(0x0),
	80	fTOFmaker(0x0),
	81	fTOFcalib(0x0),
	82	fTOFcalibrateESD(kFALSE),
	83	fTOFcorrectTExp(kFALSE),
	84	fTOFuseT0(kFALSE),
	85	fTOFtuneMC(kFALSE),
	86	fTOFresolution(0.0),
	87	fLastRun(-1)
	88	{
	89	//
	90	// Main constructor.
	91	//
	92	}
	93
	94	//_________________________________________________________________________________________________
	95	AliRsnCutESD2010::AliRsnCutESD2010
	96	(const AliRsnCutESD2010& copy) :
	97	AliRsnCut(copy),
	98	fIsMC(kFALSE),
	99	fCheckITS(copy.fCheckITS),
	100	fCheckTPC(copy.fCheckTPC),
	101	fCheckTOF(copy.fCheckTOF),
35765294	102	fUseGlobal(copy.fUseGlobal),
35765294	103	fUseITSSA(copy.fUseITSSA),
2dab9030	104	fMaxITSband(copy.fMaxITSband),
	105	fTPCpLimit(copy.fTPCpLimit),
	106	fMinTPCband(copy.fMinTPCband),
	107	fMaxTPCband(copy.fMaxTPCband),
	108	fESDtrackCutsTPC(copy.fESDtrackCutsTPC),
	109	fESDtrackCutsITS(copy.fESDtrackCutsITS),
	110	fESDpid(0x0),
	111	fTOFmaker(0x0),
	112	fTOFcalib(0x0),
	113	fTOFcalibrateESD(copy.fTOFcalibrateESD),
	114	fTOFcorrectTExp(copy.fTOFcorrectTExp),
	115	fTOFuseT0(copy.fTOFuseT0),
	116	fTOFtuneMC(copy.fTOFtuneMC),
	117	fTOFresolution(copy.fTOFresolution),
	118	fLastRun(-1)
	119	{
	120	//
	121	// Main constructor.
	122	//
2dab9030	123	}
	124
	125	//_________________________________________________________________________________________________
c79c04e1	126	void AliRsnCutESD2010::InitializeToDefaults(Bool_t isSim)
2dab9030	127	{
	128	//
	129	// Main constructor.
	130	//
c79c04e1	131
	132	// ----> set TPC range for PID and calibration
	133	SetTPCrange(5.0, 3.0);
	134	SetTPCpLimit(0.35);
	135
	136	// ----> set ITS range for PID
	137	SetITSband(4.0);
	138
	139	// ----> set TPC calibration
	140	if (isSim) SetTPCpar(2.15898 / 50.0, 1.75295E1, 3.40030E-9, 1.96178, 3.91720);
	141	else SetTPCpar(1.41543 / 50.0, 2.63394E1, 5.0411E-11, 2.12543, 4.88663);
	142
	143	// ----> set standard quality cuts for TPC global tracks
	144	fESDtrackCutsTPC.SetRequireTPCStandAlone(kTRUE); // require to have the projection at inner TPC wall
	145	fESDtrackCutsTPC.SetMinNClustersTPC(70);
	146	fESDtrackCutsTPC.SetMaxChi2PerClusterTPC(4);
	147	fESDtrackCutsTPC.SetAcceptKinkDaughters(kFALSE);
	148	fESDtrackCutsTPC.SetRequireTPCRefit(kTRUE);
	149	fESDtrackCutsTPC.SetRequireITSRefit(kTRUE);
	150	fESDtrackCutsTPC.SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
	151	fESDtrackCutsTPC.SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9"); // DCA pt dependent: 7*(0.0050+0.0060/pt0.9)
	152	fESDtrackCutsTPC.SetMaxDCAToVertexZ(1e6); // disabled
	153	fESDtrackCutsTPC.SetDCAToVertex2D(kFALSE); // each DCA is checked separately
	154	fESDtrackCutsTPC.SetRequireSigmaToVertex(kFALSE);
	155
	156	// ----> set standard quality cuts for ITS standalone tracks
0274b76f	157	fESDtrackCutsITS.SetRequireITSStandAlone(kTRUE);
c79c04e1	158	fESDtrackCutsITS.SetRequireITSRefit(kTRUE);
	159	fESDtrackCutsITS.SetMinNClustersITS(4);
	160	fESDtrackCutsITS.SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
	161	fESDtrackCutsITS.SetMaxChi2PerClusterITS(1.);
	162	fESDtrackCutsITS.SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55"); // DCA pt dependent
	163	fESDtrackCutsITS.SetMaxDCAToVertexZ(1e6); // disabled
	164	fESDtrackCutsITS.SetDCAToVertex2D(kFALSE); // each DCA is checked separately
	165
	166	// ----> set the TOF calibration depending on type of input (sim/data)
	167	SetTOFcorrectTExp(kTRUE);
	168	SetTOFuseT0(kTRUE);
	169	SetTOFresolution(100.0);
	170	if (isSim)
	171	{
	172	SetTOFcalibrateESD(kFALSE);
	173	SetTOFtuneMC(kTRUE);
	174	}
	175	else
	176	{
	177	//if (isPass2) SetTOFcalibrateESD(kFALSE); // potrebbe anche essere kFALSE
	178	SetTOFcalibrateESD(kTRUE);
	179	SetTOFtuneMC(kFALSE);
	180	}
2dab9030	181	}
	182
	183	//_________________________________________________________________________________________________
	184	void AliRsnCutESD2010::SetEvent(AliRsnEvent *event)
	185	{
	186	// don't do anything if the event is the same as before
	187	if (fEvent != 0x0 && fEvent == event) return;
	188
	189	// retrieve the ESD event
	190	AliESDEvent *esd = event->GetRefESD();
	191	if (!esd)
	192	{
	193	fEvent = 0x0;
	194	return;
	195	}
	196	else
	197	{
	198	fEvent = event;
	199	}
	200
4820b1ae	201	// if absent, initialize ESD pid responst
	202	if (!fESDpid)
	203	{
	204	fESDpid = new AliESDpid;
	205	fESDpid->GetTPCResponse().SetBetheBlochParameters(fTPCpar[0],fTPCpar[1],fTPCpar[2],fTPCpar[3],fTPCpar[4]);
	206	}
	207
2dab9030	208	// initialize DB to current run
	209	Int_t run = esd->GetRunNumber();
	210	if (run != fLastRun)
	211	{
	212	cout << "Run = " << run << " -- LAST = " << fLastRun << endl;
	213	fLastRun = run;
4820b1ae	214
	215	// setup TOF maker & calibration
	216	if (!fTOFcalib) fTOFcalib = new AliTOFcalib;
	217	fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
	218	if (!fTOFmaker) fTOFmaker = new AliTOFT0maker(fESDpid, fTOFcalib);
	219	fTOFmaker->SetTimeResolution(fTOFresolution);
	220
2dab9030	221	AliCDBManager *cdb = AliCDBManager::Instance();
6256671b	222	cdb->ClearCache(); // suggestion by Annalisa
6256671b	223	cdb->Clear(); // suggestion by Annalisa
2dab9030	224	cdb->SetDefaultStorage("raw://");
2dab9030	225	cdb->SetRun(run);
6256671b	226
2dab9030	227	fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
	228	fTOFcalib->Init();
	229	}
	230
	231	// if required, calibrate the TOF t0 maker with current event
	232	if (fTOFcalibrateESD) fTOFcalib->CalibrateESD(esd);
	233	if (fTOFtuneMC) fTOFmaker->TuneForMC(esd);
	234	if (fTOFuseT0)
	235	{
	236	fTOFmaker->ComputeT0TOF(esd);
	237	fTOFmaker->ApplyT0TOF(esd);
	238	fESDpid->MakePID(esd, kFALSE, 0.);
	239	}
	240	}
	241
	242	//_________________________________________________________________________________________________
	243	Bool_t AliRsnCutESD2010::IsSelected(TObject obj1, TObject /obj2/)
	244	{
	245	//
	246	// Cut checker.
	247	//
	248
	249	// coherence check: require an ESD track
	250	AliRsnDaughter daughter = dynamic_cast<AliRsnDaughter>(obj1);
	251	if (!daughter) return kFALSE;
	252	AliESDtrack *track = daughter->GetRefESDtrack();
	253	if (!track) return kFALSE;
	254
	255	// if no reference event, skip
	256	if (!fEvent) return kFALSE;
	257
	258	// ITS stuff #1 create the response function
	259	AliITSPIDResponse itsrsp(fIsMC);
	260
	261	// TOF: define fixed function for compatibility range
	262	Double_t a1 = 0.01, a2 = -0.03;
	263	Double_t b1 = 0.25, b2 = 0.25;
	264	Double_t c1 = 0.05, c2 = -0.03;
	265	Double_t ymax, ymin;
	266
	267	ULong_t status;
	268	Int_t k, nITS;
	269	Double_t times[10], tpcNSigma, tpcMaxNSigma, itsSignal, itsNSigma, mom, tofTime, tofSigma, tofRef, tofRel;
0d73200d	270	Bool_t okQuality, okTOF, okTPC, okITS, okTrack, isTPC, isITSSA;
2dab9030	271	UChar_t itsCluMap;
	272
	273	// get commonly used variables
	274	status = (ULong_t)track->GetStatus();
	275	mom = track->P();
	276	isTPC = ((status & AliESDtrack::kTPCin) != 0);
	277	isITSSA = ((status & AliESDtrack::kTPCin) == 0 && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
	278
	279	// accept only tracks which are TPC+ITS or ITS standalone
35765294	280	if (!isTPC && !isITSSA) return kFALSE;
	281	if ( isTPC && !fUseGlobal) return kFALSE;
	282	if ( isITSSA && !fUseITSSA) return kFALSE;
2dab9030	283
	284	if (isTPC)
	285	{
	286	// check standard ESD cuts
0d73200d	287	okQuality = fESDtrackCutsTPC.IsSelected(track);
	288	//cout << "GLOBAL -- quality = " << (okQuality ? "GOOD" : "BAD") << endl;
	289	if (!okQuality) return kFALSE;
	290
2dab9030	291	// check TPC dE/dx
	292	if (fCheckTPC)
	293	{
	294	tpcNSigma = TMath::Abs(fESDpid->NumberOfSigmasTPC(track, AliPID::kKaon));
	295	if (track->GetInnerParam()->P() > fTPCpLimit) tpcMaxNSigma = fMinTPCband; else tpcMaxNSigma = fMaxTPCband;
0d73200d	296	okTPC = (tpcNSigma <= tpcMaxNSigma);
	297	//cout << "RSN -- TPC -- nsigma = " << tpcNSigma << ", max = " << tpcMaxNSigma << " --> " << (okTPC ? "OK" : "FAILED") << endl;
	298	//cout << "RSNTPC -- " << fTPCpar[0] << ' ' << fTPCpar[1] << ' ' << fTPCpar[2] << ' ' << fTPCpar[3] << ' ' << fTPCpar[4] << endl;
	299	}
	300	else
	301	{
	302	okTPC = kTRUE;
2dab9030	303	}
	304
	305	// check TOF (only if momentum is large than function asymptote and flags are OK)
	306	if (fCheckTOF)
	307	{
2dab9030	308	if (((status & AliESDtrack::kTOFout) != 0) && ((status & AliESDtrack::kTIME) != 0) && mom > TMath::Max(b1, b2))
	309	{
	310	track->GetIntegratedTimes(times);
	311	tofTime = (Double_t)track->GetTOFsignal();
	312	tofSigma = fTOFmaker->GetExpectedSigma(mom, times[AliPID::kKaon], AliPID::ParticleMass(AliPID::kKaon));
	313	tofRef = times[AliPID::kKaon];
	314	if (tofRef > 0.0)
	315	{
	316	tofRel = (tofTime - tofRef) / tofRef;
	317	ymax = a1 / (mom - b1) + c1;
	318	ymin = a2 / (mom - b2) + c2;
	319	okTOF = (tofRel >= ymin && tofRel <= ymax);
0d73200d	320	//cout << "TOF -- diff = " << tofDiff << ", rel diff = " << tofRel << ", range = " << ymin << " to " << ymax << ", sigma = " << tofSigma << " --> " << (okTOF ? "OK" : "FAILED") << endl;
	321	}
	322	else
	323	{
	324	okTOF = kTRUE;
c79c04e1	325	if (!fCheckTPC) okTOF = kFALSE;
0d73200d	326	//cout << "TOF -- not checked due to ZERO reference time" << endl;
2dab9030	327	}
2dab9030	328	}
0d73200d	329	else
	330	{
	331	okTOF = kTRUE;
c79c04e1	332	if (!fCheckTPC) okTOF = kFALSE;
0d73200d	333	//cout << "TOF -- not checked because TOF pid absent" << endl;
	334	}
	335	}
	336	else
	337	{
	338	okTOF = kTRUE;
2dab9030	339	}
0d73200d	340
	341	// combine checks
	342	okTrack = okQuality && okTPC && okTOF;
	343	//cout << "GLOBAL -- overall = " << (okTrack ? "ACCEPTED" : "REJECTED") << endl;
2dab9030	344	}
	345	else
	346	{
	347	// check standard ESD cuts
0d73200d	348	okQuality = fESDtrackCutsITS.IsSelected(track);
	349	//cout << "ITSSA -- quality = " << (okQuality ? "GOOD" : "BAD") << endl;
	350	if (!okQuality) return kFALSE;
2dab9030	351
	352	// check dE/dx
	353	if (fCheckITS)
	354	{
2dab9030	355	itsSignal = track->GetITSsignal();
	356	itsCluMap = track->GetITSClusterMap();
	357	nITS = 0;
	358	for(k = 2; k < 6; k++) if(itsCluMap & (1 << k)) ++nITS;
0d73200d	359	if (nITS < 3)
	360	{
	361	okITS = kFALSE;
	362	//cout << "ITS -- not checked due to too few PID clusters" << endl;
	363	}
	364	else
	365	{
	366	itsNSigma = itsrsp.GetNumberOfSigmas(mom, itsSignal, AliPID::kKaon, nITS, kTRUE);
	367	okITS = (TMath::Abs(itsNSigma) <= fMaxITSband);
	368	//cout << "ITS -- nsigma = " << itsNSigma << ", max = " << fMaxITSband << " --> " << (okITS ? "OK" : "FAILED") << endl;
	369	}
2dab9030	370	}
0d73200d	371	else
	372	{
	373	okITS = kTRUE;
	374	}
	375
	376	okTrack = okQuality && okITS;
	377	//cout << "ITSSA -- overall = " << (okTrack ? "ACCEPTED" : "REJECTED") << endl;
2dab9030	378	}
2dab9030	379
0d73200d	380	return okTrack;
2dab9030	381	}