In AliMUONGeometryModuleTransformer, AliMUONVGeometryBuilder:

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

//
// Class AliRsnCutPID
//
// 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 "TMath.h"

#include "AliExternalTrackParam.h"

#include "AliRsnDaughter.h"
#include "AliRsnCutPID.h"

ClassImp(AliRsnCutPID)

//_________________________________________________________________________________________________
AliRsnCutPID::AliRsnCutPID() :
  AliRsnCut(AliRsnCut::kDaughter),
  fPerfect(kFALSE),
  fUseDefault(kTRUE)
{
//
// Default constructor.
// Sets the cut to realistic PID with default weights,
// and defines the 'fMinI' value of the base class as the PID
// to which we want to compare this object.
//

  Int_t i;
  
  for (i = 0; i < kDetectors; i++) 
  {
    fUseDetector[i] = kFALSE;
    fPtThreshold[i] = 0.0;
    fGoAboveThreshold[i] = kTRUE;
  }
  
  for (i = 0; i < AliPID::kSPECIES; i++)
  {
    fWeight[i] = 0.0;
    fPrior[i] = 1.0;
  }
}

//_________________________________________________________________________________________________
AliRsnCutPID::AliRsnCutPID(const char *name, AliPID::EParticleType pid, Double_t probMin, Bool_t perfectPID) :
  AliRsnCut(name, AliRsnCut::kDaughter, (Int_t)pid),
  fPerfect(perfectPID),
  fUseDefault(kTRUE)
{
//
// Default constructor.
// Sets the cut to realistic PID with default weights,
// and defines the 'fMinI' value of the base class as the PID
// to which we want to compare this object.
//

  Int_t i;
  
  for (i = 0; i < kDetectors; i++) 
  {
    fUseDetector[i] = kFALSE;
    fPtThreshold[i] = 0.0;
    fGoAboveThreshold[i] = kTRUE;
  }
  
  for (i = 0; i < AliPID::kSPECIES; i++)
  {
    fWeight[i] = 0.0;
    fPrior[i] = 1.0;
  }
  
  fMinD = probMin;
  fMaxD = 1.000001;
}

//_____________________________________________________________________________
Bool_t AliRsnCutPID::CheckThreshold(EDetector det, Double_t value)
{
//
// Checks if the passed value (track pT) stays in the 
// interval where the detector should be accepted
//

  if (!CheckBounds(det)) return kFALSE;
  
  if (fGoAboveThreshold[det]) return (value >= fPtThreshold[det]);
  else return (value <= fPtThreshold[det]);
}

//_________________________________________________________________________________________________
Bool_t AliRsnCutPID::ComputeWeights(AliRsnDaughter *daughter)
{
//
// Compute the PID weights using the class settings.
// If the argument is an ESD track, customized weights can be computed
// It the argument is a track (ESD or AOD), at least default weights
// can be computed, otherwise, no weights can be defined.
// The return value tells if the operation was successful.
//

  Int_t  i, j;
  Bool_t useDefault = fUseDefault;
  Bool_t perfectPID = fPerfect;
  if (perfectPID && !daughter->GetRefMC()) return kFALSE;
  if (!daughter->GetRefESDtrack()) useDefault = kTRUE;
  if (!daughter->GetRefESDtrack() && !daughter->GetRefAODtrack()) return kFALSE;
  
  // if perfect PID ise required, 
  // compare the PDG code of the type stored in 'fMinI' of the cut
  // and that of the particle which is checked, looking at its MC
  if (perfectPID)
  {
    i = TMath::Abs(AliPID::ParticleCode(fMinI));
    j = TMath::Abs(daughter->GetRefMC()->Particle()->GetPdgCode());
    return (i == j);
  }
  
  // if default weights are (or need to be) used,
  // they are taken directly and function exits
  if (useDefault)
  {
    if (daughter->GetRefESDtrack())
      daughter->GetRefESDtrack()->GetESDpid(fWeight);
    else
    {
      for (i = 0; i < AliPID::kSPECIES; i++)
        fWeight[i] = daughter->GetRefAODtrack()->PID()[i];
    }
    return kTRUE;
  }
  
  // if we arrive here, this means that we have an ESD track
  // and we want to customize the PID
  AliESDtrack *track = daughter->GetRefESDtrack();
  Double_t     w[kDetectors][AliPID::kSPECIES];
  track->GetITSpid(w[kITS]);
  track->GetTPCpid(w[kTPC]);
  track->GetTRDpid(w[kTRD]);
  track->GetTOFpid(w[kTOF]);
  track->GetHMPIDpid(w[kHMPID]);

  // if a detector is excluded or the track has not the right pT
  // all related weights are set to 1 in order not to contribute
  // to final multiplication
  for (i = 0; i < kDetectors; i++) 
  {
    if (!fUseDetector[i] || !CheckThreshold((EDetector)i, track->Pt())) 
    {
      for (j = 0; j < AliPID::kSPECIES; j++) {
        w[i][j] = 1.0;
      }
    }
  }

  // multiplicate all weights to compute final one
  for (i = 0; i < AliPID::kSPECIES; i++) 
  {
    fWeight[i] = w[kITS][i] * w[kTPC][i] * w[kTRD][i] * w[kTOF][i] * w[kHMPID][i];
  }
  
  return kTRUE;
}

//_________________________________________________________________________________________________
Int_t AliRsnCutPID::RealisticPID(AliRsnDaughter * const daughter, Double_t &prob)
{
//
// Combines the weights collected from chosen detectors with the priors
// and gives the corresponding particle with the largest probability,
// in terms of the AliPID particle type enumeration.
// The argument, passed by reference, gives the corresponding probability,
// since the cut could require that it is larger than a threshold.
//

  // try to compute the weights
  if (!ComputeWeights(daughter)) 
  {
    prob = -1.0;
    return AliPID::kUnknown;
  }
  
  // combine with priors and normalize
  Int_t    i;
  Double_t sum = 0.0, w[AliPID::kSPECIES];
  for (i = 0; i < AliPID::kSPECIES; i++)
  {
    w[i] = fWeight[i] * fPrior[i];
    sum += w[i];
  }
  if (sum <= 0.0)
  {
    AliError("Sum = 0");
    prob = -1.0;
    return AliPID::kUnknown;
  }
  for (i = 0; i < AliPID::kSPECIES; i++) w[i] /= sum;
  
  // find the largest probability and related PID
  Int_t ibest = 0;
  prob = w[0];
  for (i = 1; i < AliPID::kSPECIES; i++)
  {
    if (w[i] > prob) 
    {
      prob = w[i];
      ibest = i;
    }
  }
  
  // return the value, while the probability
  // will be consequentially set
  return ibest;
}
  
//_________________________________________________________________________________________________
Int_t AliRsnCutPID::PerfectPID(AliRsnDaughter * const daughter)
{
//
// If MC is present, retrieve the particle corresponding to the used track
// (using the fRefMC data member) and then return the true particle type
// taken from the PDG code of the reference particle itself, converted
// into the enumeration from AliPID object.
//

  // works only if the MC is present
  if (!daughter->GetRefMC()) return AliPID::kUnknown;
  
  // get the PDG code of the particle
  TParticle *part = daughter->GetRefMC()->Particle();
  Int_t      pdg  = TMath::Abs(part->GetPdgCode());
  
  // loop over all species listed in AliPID to find the match
  Int_t i;
  for (i = 0; i < AliPID::kSPECIES; i++)
  {
    if (AliPID::ParticleCode(i) == pdg) return i;
  }
  
  return AliPID::kUnknown;
}

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

  // coherence check
  if (!AliRsnCut::TargetOK(obj1))
  {
    AliError(Form("Wrong target '%s'. Skipping cut", GetName()));
    return kTRUE;
  }
  
  // convert the object into the unique correct type
  AliRsnDaughter *daughter = dynamic_cast<AliRsnDaughter*>(obj1);
  
  // depending on the PID type, recalls the appropriate method:
  // in case of perfect PID, checks only if the PID type is 
  // corresponding to the request in the cut (fMinI)
  // while in case of realistic PID checks also the probability
  // to be within the required interval
  if (fPerfect)
  {
    fCutValueI = PerfectPID(daughter);
    return OkValueI();
  }
  else
  {
    fCutValueI = RealisticPID(daughter, fCutValueD);
    return OkValueI() && OkRangeD();
  }
}

//__________________________________________________________________________________________________
void AliRsnCutPID::IncludeDetector(EDetector det, Double_t threshold, Bool_t goAbove)
{
//
// Include a detector for a customized weight computing
// and specify also its eventual threshold and if the detector
// must be used above or below the threshold.
// By default the threshold is zero and detector is always used.
//

  if (!CheckBounds(det)) return;
  
  fUseDetector[det] = kTRUE;
  fPtThreshold[det] = threshold;
  fGoAboveThreshold[det] = goAbove;
}