PndPidMvaAssociatorTask Class Reference

#include <PndPidMvaAssociatorTask.h>

Inheritance diagram for PndPidMvaAssociatorTask:

Public Member Functions
	PndPidMvaAssociatorTask ()
	PndPidMvaAssociatorTask (char const *name)
virtual	~PndPidMvaAssociatorTask ()
virtual void	Exec (Option_t *option)
virtual InitStatus	Init ()
void	Register ()
void	Reset ()
void	SetVerbose (Bool_t verb)
virtual void	SetParContainers ()
virtual void	Finish ()
virtual void	SetVarNames (std::vector< std::string > const &vNames)
void	SetClassNames (std::vector< std::string > const &clNames)
void	SetWeightFileName (std::string const &wFileName)
void	SetClassifier (Mva_MethodType const &methodT)
void	SetClassifier (std::string const &methodName)
void	SetNumNeigh (size_t val)
void	SetKnnEventParams (float scFact, double weight)

Private Member Functions
	PndPidMvaAssociatorTask (PndPidMvaAssociatorTask const &other)
PndPidMvaAssociatorTask &	operator= (PndPidMvaAssociatorTask const &other)
void	DoPidMatch (PndPidCandidate &pidcand, PndPidProbability &prob)
std::vector< float > const *	PrepareEvtVect (PndPidCandidate const &pidcand) const
void	SetDefaultWeightsPath ()
	ClassDef (PndPidMvaAssociatorTask, 0)

Private Attributes
FairRootManager *	fManager
std::vector< std::string >	fVarNames
	Variable names container. More...
std::vector< std::string >	fClassNames
	Class names container. More...
std::string	fWeightsFileName
	Path to the file holding weights (proto-types, examples, ...) More...
size_t	fNumNeigh
	Number of neighbors. More...
float	fScFact
double	fWeight
PndMvaClassifier *	fClassifier
	MVA classifier object. More...
Mva_MethodType	fMethodType
	MVA Method name. More...
TClonesArray *	fPidChargedCand
TClonesArray *	fPidChargedProb
	PndPidCandidate TCA for charged particles. More...
TClonesArray *	fMCTrack
	PndPidProbability TCA for charged particles. More...
std::string	fMethodName
	Monte-Carlo Truth track TCA. More...

Detailed Description

Definition at line 42 of file PndPidMvaAssociatorTask.h.

Constructor & Destructor Documentation

PndPidMvaAssociatorTask::PndPidMvaAssociatorTask

(

)

Default Constructor.

PndPidMvaAssociatorTask::PndPidMvaAssociatorTask

(

char const *

name

)

Constructor.

Definition at line 86 of file PndPidMvaAssociatorTask.cxx.

  : FairTask(name),
    fManager(0),
    fVarNames  (std::vector<std::string>()),
    fClassNames(std::vector<std::string>()),
    fWeightsFileName(std::string(getenv("VMCWORKDIR")) + std::string("/tools/MVA/PndMVAWeights/")),
    fNumNeigh(200),
    fScFact(0.8),
    fWeight(1.00),
    fClassifier(0),
    fMethodType(UNKNOWN_METHOD),
    fPidChargedCand(0),
    fPidChargedProb(new TClonesArray("PndPidProbability")),
    fMCTrack(0),
    fMethodName("UNKNOWN_METHOD")
{
  // Init neutral probab. containers.
  // fPidNeutralProb = new TClonesArray("PndPidProbability");

  // Set Default path to the weight file
  //SetDefaultWeightsPath();
}

PndPidMvaAssociatorTask::~PndPidMvaAssociatorTask ( )

virtual

Destructor.

Definition at line 125 of file PndPidMvaAssociatorTask.cxx.

References fClassifier, fManager, fMCTrack, fPidChargedCand, and fPidChargedProb.

{
  // Clean-up allocated stuff.
  if(fManager) {
    fManager->Write();
    delete fManager;
  }

  if(fPidChargedCand) {
    delete fPidChargedCand;
  }
  
  if(fPidChargedProb) {
    delete fPidChargedProb;
  }
  //if(fPidNeutralCand)
  //delete fPidNeutralCand;  
  
  //if(fPidNeutralProb)
  //delete fPidNeutralProb;
  
  if(fMCTrack) {
    delete  fMCTrack;
  }

  if(fClassifier) {
    delete fClassifier;
  }
}

PndPidMvaAssociatorTask::PndPidMvaAssociatorTask ( PndPidMvaAssociatorTask const &  other )

private

Member Function Documentation

PndPidMvaAssociatorTask::ClassDef ( PndPidMvaAssociatorTask  , 0    )

private

void PndPidMvaAssociatorTask::DoPidMatch ( PndPidCandidate &  pidcand, PndPidProbability &  prob  )

private

Performs the actual classification.

Parameters

pidcand	Current pid candidate to be classified.
prob	Output probabilities.

Definition at line 387 of file PndPidMvaAssociatorTask.cxx.

References fClassifier, fClassNames, PndPidCandidate::GetDrcThetaC(), PndPidCandidate::GetEmcCalEnergy(), PndPidCandidate::GetEmcClusterE1(), PndPidCandidate::GetEmcClusterE25(), PndPidCandidate::GetEmcClusterE9(), PndPidCandidate::GetEmcClusterLat(), PndPidCandidate::GetEmcClusterZ20(), PndPidCandidate::GetEmcClusterZ53(), PndPidCandidate::GetEnergy(), PndPidCandidate::GetMomentum(), PndMvaClassifier::GetMvaValues(), PndPidCandidate::GetMvdDEDX(), PndPidCandidate::GetSttMeanDEDX(), i, name, out, PrepareEvtVect(), PndPidProbability::SetElectronPdf(), PndPidProbability::SetKaonPdf(), PndPidProbability::SetMuonPdf(), PndPidProbability::SetPionPdf(), and PndPidProbability::SetProtonPdf().

Referenced by Exec().

{
  
  std::map<std::string, float> out;
  std::vector<float> const* evtPidData = PrepareEvtVect(pidcand);
  
  // Perform Recognition.
  if( evtPidData ) {
    fClassifier->GetMvaValues( *evtPidData, out);
    delete evtPidData;
  }
  else {
    // Feature vector is empty or damaged.
    delete evtPidData;
    evtPidData = 0;
    return;
  }

#if ( PIDMVA_ASSOCIATORT_DEBUG != 0 )
  std::cout << "****************************************************\n"
            << "Momentum = " << (pidcand.GetMomentum()).Mag()
            << "\nGetEnergy = " << pidcand.GetEnergy()
            << "\nEMC = " << pidcand.GetEmcCalEnergy()
            << "\nEMC/P = "
            << (pidcand.GetEmcCalEnergy())/((pidcand.GetMomentum()).Mag())
            << "\nEMCZ20 = " << pidcand.GetEmcClusterZ20()
            << "\nEMCZ53 = " << pidcand.GetEmcClusterZ53()
            << "\nEMCLAT = " << pidcand.GetEmcClusterLat()
            << "\nEmcE1 = "  << pidcand.GetEmcClusterE1()
            << "\nEmcE9 = "  << pidcand.GetEmcClusterE9()
            << "\nEmcE25 = " << pidcand.GetEmcClusterE25()
            << "\nSTT = " << pidcand.GetSttMeanDEDX()
            << "\nMVD = " << pidcand.GetMvdDEDX()
            << "\nDRC_TC = " << pidcand.GetDrcThetaC()
            << '\n';
  printResult(out);
  std::cout << "====================================================\n";
#endif

  // Set probs.
  for(size_t i = 0; i < fClassNames.size(); i++)
  {
    std::string name = fClassNames[i];
    
    if(name == "electron")
    {
      prob.SetElectronPdf(out[name]);
    }
    else if(name == "muon")
    {
      prob.SetMuonPdf(out[name]);
    }
    else if(name == "pion")
    {
      prob.SetPionPdf(out[name]);
    }
    else if(name == "kaon")
    {
      prob.SetKaonPdf(out[name]);
    }
    else if(name == "proton")
    {
      prob.SetProtonPdf(out[name]);
    }
    else
    {
      std::cerr << "<ERROR> Unknown label (class Name).\n"
                << std::flush;
    }
  }
}

void PndPidMvaAssociatorTask::Exec ( Option_t *  option )

virtual

Execute the method.

Definition at line 323 of file PndPidMvaAssociatorTask.cxx.

References DoPidMatch(), fPidChargedCand, fPidChargedProb, fVerbose, PndPidCandidate::GetLorentzVector(), and i.

{
  std::cout << option << '\n';

  if (fPidChargedProb->GetEntriesFast() != 0)
  {
    fPidChargedProb->Delete();
  }

#if ( PIDMVA_ASSOCIATORT_DEBUG != 0 )
  std::cout << "<INFO> Call to Exec with options = " << option
            << "___\n";
#endif

  if(fVerbose > 1)
  {
    std::cout << "-I- Start PndPidMvaAssociatorTask.\n";
  }

  // Charged Candidates Loop
  for(int i = 0; i < fPidChargedCand->GetEntriesFast(); i++)
  {
    PndPidCandidate* pidcand = (PndPidCandidate*)fPidChargedCand->At(i);
    TClonesArray& pidRef = *fPidChargedProb;

    // initializes with zeros
    PndPidProbability* prob = new(pidRef[i]) PndPidProbability();
    
    if(fVerbose > 1)
    {
      std::cout << "-I- PndPidMVAAssociatorTask Ch BEFORE  "
                << pidcand->GetLorentzVector().M()
                << '\n';
    }
    // Classify
    DoPidMatch(*pidcand, *prob);
    
    if(fVerbose > 1)
    {
      std::cout << "-I- PndPidMVAAssociatorTask Ch AFTER "
                << pidcand->GetLorentzVector().M()
                << '\n';
    }
  }
  
  // Get the Neutral Candidates
  /*
    for(int i = 0; i < fPidNeutralCand->GetEntriesFast(); i++)
    {
    PndPidCandidate* pidcand = (PndPidCandidate*)fPidNeutralCand->At(i);
    TClonesArray& pidRef = *fPidNeutralProb;
    // initializes with zeros
    PndPidProbability* prob = new(pidRef[i]) PndPidProbability();
    // Classify
    DoPidMatch(*pidcand, *prob);
    }
  */
}

void PndPidMvaAssociatorTask::Finish ( )

virtual

Definition at line 564 of file PndPidMvaAssociatorTask.cxx.

{}

InitStatus PndPidMvaAssociatorTask::Init ( )

virtual

Initialize the method. Called by runner.

Definition at line 156 of file PndPidMvaAssociatorTask.cxx.

References fClassifier, fClassNames, fManager, fMethodName, fMethodType, fNumNeigh, fPidChargedCand, fScFact, fVarNames, fWeight, fWeightsFileName, PndMvaClassifier::Initialize(), PndMultiClassMlpClassify::Initialize(), PndMultiClassBdtClassify::Initialize(), PndKnnClassify::Initialize(), KNN, LVQ, Register(), PndKnnClassify::SetEvtParam(), PndKnnClassify::SetKnn(), TMVA_BDT, and TMVA_MLP.

{
  std::cout << "<-I-> InitStatus PndPidMvaAssociatorTask::Init()\n";

  fManager = FairRootManager::Instance();
  if( !fManager ) {
    std::cerr << "<ERROR> PndPidMvaAssociatorTask::Init:\n"
              << "\t Could not init FairRootManager."
              << std::endl;

    return kERROR;
  }
  
  // Get charged candidates.
  fPidChargedCand = (TClonesArray *)fManager->GetObject("PidChargedCand");
  if ( !fPidChargedCand) {
    std::cerr << "<ERROR> PndPidMvaAssociatorTask::Init: No PidChargedCand there!"
              << std::endl;
    return kERROR;
  }
  
  // Get Neutral candidates.
  /*
    fPidNeutralCand = (TClonesArray *)fManager->GetObject("PidNeutralCand");
    if ( ! fPidNeutralCand)
    {
    std::cerr << "<ERROR> PndPidMvaAssociatorTask::Init: No PidNeutralCand there!"
    << std::endl;
    return kERROR;
    }
  */
  
  std::cout << "<INFO> Using weight file  " << fWeightsFileName
            << '\n';
  
  // Init Classifier object
  switch(fMethodType)
  {
  case TMVA_MLP:// Multi label MLP classifier from TMVA.
  {
    PndMultiClassMlpClassify* TmvaMlpCls = new PndMultiClassMlpClassify(fWeightsFileName, fClassNames,
                                                                        fVarNames);
    if(!TmvaMlpCls)
    {
      std::cerr << "<Error> Failed to initialize TMVA_MLP classifier."
                << std::endl;
      return kERROR;
    }
    // Init
    TmvaMlpCls->Initialize();
    
    //fClassifier = dynamic_cast<PndMultiClassMlpClassify*>(TmvaMlpCls);
    fClassifier = TmvaMlpCls;
    std::cout << "<INFO> TMVA_MLP initialized using " << fWeightsFileName << '\n';

    fMethodName = "TMVAMLP";
  }
  break;
  
  case TMVA_BDT:// Multi label BDT classifier from TMVA.
  {
    PndMultiClassBdtClassify* TmvaBdtCls = new PndMultiClassBdtClassify(fWeightsFileName, fClassNames,
                                                                        fVarNames);
    if(!TmvaBdtCls)
    {
      std::cerr << "<Error> Failed to initialize TMVA_BDT classifier."
                << std::endl;
      return kERROR;
    }
    // INIT
    TmvaBdtCls->Initialize();
    
    //fClassifier = dynamic_cast<PndMultiClassBdtClassify*>(TmvaBdtCls);
    fClassifier = TmvaBdtCls;
    std::cout << "<INFO> TMVA_BDT initialized using " << fWeightsFileName << '\n';

    fMethodName = "TMVABDT";
  }
  break;
  
  case LVQ:
  {
    PndLVQClassify* LvqCls = new PndLVQClassify(fWeightsFileName, fClassNames, fVarNames);
    
    if(!LvqCls)
    {
      std::cerr << "<Error> Failed to initialize LVQ classifier."
                << std::endl;
      return kERROR;
    }
    // Init
    LvqCls->Initialize();
    
    //fClassifier = dynamic_cast<PndMvaClassifier*>(LvqCls);
    fClassifier = LvqCls;
    std::cout << "<INFO> LVQ initialized using " << fWeightsFileName << '\n';

    fMethodName = "LVQ";
  }
  break;
  
  case KNN:
  default:
  {
    PndKnnClassify* KnnCls = new PndKnnClassify(fWeightsFileName, fClassNames, fVarNames);
    
    if(!KnnCls)
    {
      std::cerr << "<Error> Failed to initialize KNN classifier."
                << std::endl;
      return kERROR;
    }
    
    // Set parameters.
    KnnCls->SetEvtParam(fScFact, fWeight);
    KnnCls->SetKnn(fNumNeigh);
    KnnCls->Initialize();
    
    //fClassifier = dynamic_cast<PndMvaClassifier*>(KnnCls);
    fClassifier = KnnCls;
    std::cout << "<INFO> KNN initialized using " << fWeightsFileName << '\n';

    fMethodName = "KNN";
  }
  break;
  }// End of switch(fMethodType)
  
  // Register objects in the output chain
  Register();

  std::cout << "<INFO> PndPidMvaAssociatorTask::Init: Success!\n";
  return kSUCCESS;
}

PndPidMvaAssociatorTask& PndPidMvaAssociatorTask::operator= ( PndPidMvaAssociatorTask const &  other )

private

std::vector< float > const * PndPidMvaAssociatorTask::PrepareEvtVect ( PndPidCandidate const &  pidcand ) const

private

Definition at line 460 of file PndPidMvaAssociatorTask.cxx.

References fVarNames, PndPidCandidate::GetDrcThetaC(), PndPidCandidate::GetEmcCalEnergy(), PndPidCandidate::GetEmcClusterE1(), PndPidCandidate::GetEmcClusterE25(), PndPidCandidate::GetEmcClusterE9(), PndPidCandidate::GetEmcClusterLat(), PndPidCandidate::GetEmcClusterZ20(), PndPidCandidate::GetEmcClusterZ53(), PndPidCandidate::GetMomentum(), PndPidCandidate::GetMvdDEDX(), PndPidCandidate::GetSttMeanDEDX(), i, and mom.

Referenced by DoPidMatch().

{
  std::vector<float>* vect = new std::vector<float>();
  float mom = (pidcand.GetMomentum()).Mag();
  
  for(size_t i = 0; i < fVarNames.size(); i++)
  {  
    if( fVarNames[i] == "p" )
    {
      vect->push_back((pidcand.GetMomentum()).Mag());
    }
    else if(fVarNames[i] == "emc")
    {
      if(mom > 0.00) { // E/p
        vect->push_back( (pidcand.GetEmcCalEnergy())/mom);
      }
      else {
        std::cerr << "<WARNING> (p > 0) failed. The event is skipped.\n"
                  << "<ER-I> p = " << mom << std::endl;
        delete vect;
        vect = 0;
        return 0;// Can not proceed. Break the procedure
      }
    }
    // Cluster Ex parameters.
    else if( (fVarNames[i] == "e1") || (fVarNames[i] == "E1") )
    {
      vect->push_back(pidcand.GetEmcClusterE1());
    }
    else if( (fVarNames[i] == "e9") || (fVarNames[i] == "E9") )
    {
      vect->push_back(pidcand.GetEmcClusterE9());
    }
    else if( (fVarNames[i] == "e25") || (fVarNames[i] == "E25") )
    {
      vect->push_back(pidcand.GetEmcClusterE25());
    }
    else if( (fVarNames[i] == "e1e9") || (fVarNames[i] == "E1E9") )
    {
      if( pidcand.GetEmcClusterE9() > 0 ) {
        vect->push_back(pidcand.GetEmcClusterE1()/pidcand.GetEmcClusterE9());
      }
      else {
        std::cerr << "<WARNING> (EmcClusterE9 > 0) failed. The event is skipped.\n"
                  << std::flush;
        delete vect;
        vect = 0;
        return 0;// Can not proceed. Break the procedure
      }
    }
    else if( (fVarNames[i] == "e9e25") || (fVarNames[i] == "E9E25") )
    {
      if( pidcand.GetEmcClusterE25() > 0 ) {
        vect->push_back(pidcand.GetEmcClusterE9()/pidcand.GetEmcClusterE25());
      }
      else {
        std::cerr << "<WARNING> (EmcClusterE25 > 0) failed. The event is skipped.\n"
                  << std::flush;
        delete vect;
        vect = 0;
        return 0;// Can not proceed. Break the procedure
      }
    }
    //======== Zernike & moments
    else if(fVarNames[i] == "z20")
    {
      vect->push_back(pidcand.GetEmcClusterZ20());
    }
    else if(fVarNames[i] == "z53")
    {
      vect->push_back(pidcand.GetEmcClusterZ53());
    }
    // Cluster Second lat. moment
    else if(fVarNames[i] == "lat")
    {
      vect->push_back(pidcand.GetEmcClusterLat());
    }
    // ========== other detectors
    else if(fVarNames[i] == "stt")
    {
      vect->push_back(pidcand.GetSttMeanDEDX());
    }
    else if(fVarNames[i] == "mvd")
    {
      vect->push_back(pidcand.GetMvdDEDX());
    }    
    else if(fVarNames[i] == "thetaC")
    {
      vect->push_back(pidcand.GetDrcThetaC());
    }
  }
  return vect;
}

void PndPidMvaAssociatorTask::Register

(

)

Definition at line 555 of file PndPidMvaAssociatorTask.cxx.

References fMethodName, and fPidChargedProb.

Referenced by Init().

{
  std::string tcaName = fMethodName + "MvaProb";
  //---
  FairRootManager::Instance()->Register(tcaName.c_str(),"Pid", fPidChargedProb, kTRUE); 
  // FairRootManager::Instance()->Register("MvaNeutralProb","Pid", fPidNeutralProb, kTRUE);
}

void PndPidMvaAssociatorTask::Reset

(

)

Definition at line 567 of file PndPidMvaAssociatorTask.cxx.

{}

void PndPidMvaAssociatorTask::SetClassifier ( Mva_MethodType const &  methodT )

inline

Set the classifier type.

Parameters

methodT

The method to be used.

Definition at line 201 of file PndPidMvaAssociatorTask.h.

References fMethodType.

{
  fMethodType = methodT;
};

void PndPidMvaAssociatorTask::SetClassifier

(

std::string const &

methodName

)

Set the classifier type.

Parameters

methodName

The method to be used.

Definition at line 294 of file PndPidMvaAssociatorTask.cxx.

References fMethodName, fMethodType, KNN, LVQ, TMVA_BDT, and TMVA_MLP.

{
  if(methodNameStr == "KNN")
  {
    fMethodType = KNN;
    fMethodName = "KNN";
  }
  else if(methodNameStr == "LVQ")
  {
    fMethodType = LVQ;
    fMethodName = "LVQ";
  }
  else if(methodNameStr == "TMVA_MLP")
  {
    fMethodType = TMVA_MLP;
    fMethodName = "TMVAMLP";
  }
  else if(methodNameStr == "TMVA_BDT")
  {
    fMethodType = TMVA_BDT;
    fMethodName = "TMVABDT";
  }
  else
  {
    std::cerr << "<ERROR> Unknown Method."
              << std::endl;
  }
};

void PndPidMvaAssociatorTask::SetClassNames ( std::vector< std::string > const &  clNames )

inline

Parameters

clNames

Input class names.

Definition at line 186 of file PndPidMvaAssociatorTask.h.

References fClassNames.

{
  fClassNames = clNames;
};

void PndPidMvaAssociatorTask::SetDefaultWeightsPath ( )

private

Definition at line 112 of file PndPidMvaAssociatorTask.cxx.

References fWeightsFileName.

{
  fWeightsFileName  = std::string(getenv("VMCWORKDIR"));
  fWeightsFileName += std::string("/tools/MVA/PndMVAWeights/");
  std::cout<<"<INFO> Default Weights path is set to "
           << fWeightsFileName
           << '\n';
}

void PndPidMvaAssociatorTask::SetKnnEventParams ( float  scFact, double  weight  )

inline

Set the scale factor and the event weight for KNN classifier.

Parameters

scFact	Scale factor.
weight	Events weight.

Definition at line 206 of file PndPidMvaAssociatorTask.h.

References fScFact, and fWeight.

{
  fScFact = scFact;
  fWeight = weight;
};

void PndPidMvaAssociatorTask::SetNumNeigh ( size_t  val )

inline

Parameters

val	nNumber of neighbors to be uset for KNN classifier.

Definition at line 196 of file PndPidMvaAssociatorTask.h.

References fNumNeigh, and val.

{
  fNumNeigh = val;
};

void PndPidMvaAssociatorTask::SetParContainers ( )

virtual

Set parameter containers

Definition at line 291 of file PndPidMvaAssociatorTask.cxx.

{}

void PndPidMvaAssociatorTask::SetVarNames ( std::vector< std::string > const &  vNames )

inlinevirtual

Parameters

vNames

Input variable names.

Reimplemented in PndPidEmcAssociatorTask.

Definition at line 181 of file PndPidMvaAssociatorTask.h.

References fVarNames.

Referenced by PndPidEmcAssociatorTask::SetVarNames().

{
  fVarNames = vNames;
};

void PndPidMvaAssociatorTask::SetVerbose ( Bool_t  verb )

inline

Definition at line 176 of file PndPidMvaAssociatorTask.h.

References fVerbose.

{
  fVerbose = verb;
};

void PndPidMvaAssociatorTask::SetWeightFileName ( std::string const &  wFileName )

inline

Parameters

wFileName

Input weight file. If not specified the standard file from the standard location is loaded.

Definition at line 191 of file PndPidMvaAssociatorTask.h.

References fWeightsFileName.

{
  fWeightsFileName = wFileName;
};

Member Data Documentation

PndMvaClassifier* PndPidMvaAssociatorTask::fClassifier

private

MVA classifier object.

Definition at line 161 of file PndPidMvaAssociatorTask.h.

Referenced by DoPidMatch(), Init(), and ~PndPidMvaAssociatorTask().

std::vector<std::string> PndPidMvaAssociatorTask::fClassNames

private

Class names container.

Definition at line 150 of file PndPidMvaAssociatorTask.h.

Referenced by DoPidMatch(), Init(), and SetClassNames().

FairRootManager* PndPidMvaAssociatorTask::fManager

private

Definition at line 140 of file PndPidMvaAssociatorTask.h.

Referenced by Init(), and ~PndPidMvaAssociatorTask().

TClonesArray* PndPidMvaAssociatorTask::fMCTrack

private

PndPidProbability TCA for charged particles.

Definition at line 168 of file PndPidMvaAssociatorTask.h.

Referenced by ~PndPidMvaAssociatorTask().

std::string PndPidMvaAssociatorTask::fMethodName

private

Monte-Carlo Truth track TCA.

Definition at line 171 of file PndPidMvaAssociatorTask.h.

Referenced by Init(), Register(), and SetClassifier().

Mva_MethodType PndPidMvaAssociatorTask::fMethodType

private

MVA Method name.

Definition at line 164 of file PndPidMvaAssociatorTask.h.

Referenced by Init(), and SetClassifier().

size_t PndPidMvaAssociatorTask::fNumNeigh

private

Number of neighbors.

Definition at line 156 of file PndPidMvaAssociatorTask.h.

Referenced by Init(), and SetNumNeigh().

TClonesArray* PndPidMvaAssociatorTask::fPidChargedCand

private

Definition at line 166 of file PndPidMvaAssociatorTask.h.

Referenced by Exec(), Init(), and ~PndPidMvaAssociatorTask().

TClonesArray* PndPidMvaAssociatorTask::fPidChargedProb

private

PndPidCandidate TCA for charged particles.

Definition at line 167 of file PndPidMvaAssociatorTask.h.

Referenced by Exec(), Register(), and ~PndPidMvaAssociatorTask().

float PndPidMvaAssociatorTask::fScFact

private

Definition at line 157 of file PndPidMvaAssociatorTask.h.

Referenced by Init(), and SetKnnEventParams().

std::vector<std::string> PndPidMvaAssociatorTask::fVarNames

private

Variable names container.

Definition at line 147 of file PndPidMvaAssociatorTask.h.

Referenced by Init(), PrepareEvtVect(), and SetVarNames().

double PndPidMvaAssociatorTask::fWeight

private

Definition at line 158 of file PndPidMvaAssociatorTask.h.

Referenced by Init(), and SetKnnEventParams().

std::string PndPidMvaAssociatorTask::fWeightsFileName

private

Path to the file holding weights (proto-types, examples, ...)

Definition at line 153 of file PndPidMvaAssociatorTask.h.

Referenced by Init(), SetDefaultWeightsPath(), and SetWeightFileName().

---

The documentation for this class was generated from the following files:

• PndPidMvaAssociatorTask.h
• PndPidMvaAssociatorTask.cxx