PndPidEmcAssociatorTask Class Reference

#include <PndPidEmcAssociatorTask.h>

Inheritance diagram for PndPidEmcAssociatorTask:

Public Member Functions
	PndPidEmcAssociatorTask ()
	PndPidEmcAssociatorTask (char const *name)
virtual	~PndPidEmcAssociatorTask ()
	Destructor. More...
virtual void	Exec (Option_t *option)
virtual InitStatus	Init ()
void	Register ()
void	Reset ()
void	SetVerbose (Bool_t verb)
virtual void	SetParContainers ()
virtual void	Finish ()
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
	PndPidEmcAssociatorTask (PndPidMvaAssociatorTask const &other)
PndPidEmcAssociatorTask &	operator= (PndPidMvaAssociatorTask const &other)
void	SetVarNames (std::vector< std::string > const &vNames)
	Set Variables to use. More...
std::vector< std::string > const *	SetEmcParNames () const
	Set Emc related variable names. More...
	ClassDef (PndPidEmcAssociatorTask, 0)

Detailed Description

Definition at line 16 of file PndPidEmcAssociatorTask.h.

Constructor & Destructor Documentation

PndPidEmcAssociatorTask::PndPidEmcAssociatorTask

(

)

Default Constructor.

Definition at line 19 of file PndPidEmcAssociatorTask.cxx.

References SetEmcParNames(), and SetVarNames().

  : PndPidMvaAssociatorTask("PndPidMvaAssociatorTaskSTD")
{
  std::vector<std::string> const* vNames = SetEmcParNames();
  SetVarNames(*vNames);
  delete vNames;
}

PndPidEmcAssociatorTask::PndPidEmcAssociatorTask

(

char const *

name

)

Constructor.

Definition at line 31 of file PndPidEmcAssociatorTask.cxx.

References SetEmcParNames(), and SetVarNames().

  : PndPidMvaAssociatorTask(name)
{
  std::vector<std::string> const* vNames = SetEmcParNames();
  SetVarNames(*vNames);
  delete vNames;
}

PndPidEmcAssociatorTask::~PndPidEmcAssociatorTask ( )

virtual

Destructor.

Destructor.

Definition at line 40 of file PndPidEmcAssociatorTask.cxx.

{}

PndPidEmcAssociatorTask::PndPidEmcAssociatorTask ( PndPidMvaAssociatorTask const &  other )

private

Member Function Documentation

PndPidEmcAssociatorTask::ClassDef ( PndPidEmcAssociatorTask  , 0    )

private

void PndPidMvaAssociatorTask::Exec ( Option_t *  option )

virtualinherited

Execute the method.

Definition at line 323 of file PndPidMvaAssociatorTask.cxx.

References PndPidMvaAssociatorTask::DoPidMatch(), PndPidMvaAssociatorTask::fPidChargedCand, PndPidMvaAssociatorTask::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 ( )

virtualinherited

Definition at line 564 of file PndPidMvaAssociatorTask.cxx.

{}

InitStatus PndPidMvaAssociatorTask::Init ( )

virtualinherited

Initialize the method. Called by runner.

Definition at line 156 of file PndPidMvaAssociatorTask.cxx.

References PndPidMvaAssociatorTask::fClassifier, PndPidMvaAssociatorTask::fClassNames, PndPidMvaAssociatorTask::fManager, PndPidMvaAssociatorTask::fMethodName, PndPidMvaAssociatorTask::fMethodType, PndPidMvaAssociatorTask::fNumNeigh, PndPidMvaAssociatorTask::fPidChargedCand, PndPidMvaAssociatorTask::fScFact, PndPidMvaAssociatorTask::fVarNames, PndPidMvaAssociatorTask::fWeight, PndPidMvaAssociatorTask::fWeightsFileName, PndMvaClassifier::Initialize(), PndMultiClassMlpClassify::Initialize(), PndMultiClassBdtClassify::Initialize(), PndKnnClassify::Initialize(), KNN, LVQ, PndPidMvaAssociatorTask::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;
}

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

private

void PndPidMvaAssociatorTask::Register ( )

inherited

Definition at line 555 of file PndPidMvaAssociatorTask.cxx.

References PndPidMvaAssociatorTask::fMethodName, and PndPidMvaAssociatorTask::fPidChargedProb.

Referenced by PndPidMvaAssociatorTask::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 ( )

inherited

Definition at line 567 of file PndPidMvaAssociatorTask.cxx.

{}

void PndPidMvaAssociatorTask::SetClassifier ( Mva_MethodType const &  methodT )

inlineinherited

Set the classifier type.

Parameters

methodT

The method to be used.

Definition at line 201 of file PndPidMvaAssociatorTask.h.

References PndPidMvaAssociatorTask::fMethodType.

{
  fMethodType = methodT;
};

void PndPidMvaAssociatorTask::SetClassifier ( std::string const &  methodName )

inherited

Set the classifier type.

Parameters

methodName

The method to be used.

Definition at line 294 of file PndPidMvaAssociatorTask.cxx.

References PndPidMvaAssociatorTask::fMethodName, PndPidMvaAssociatorTask::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 )

inlineinherited

Parameters

clNames

Input class names.

Definition at line 186 of file PndPidMvaAssociatorTask.h.

References PndPidMvaAssociatorTask::fClassNames.

{
  fClassNames = clNames;
};

std::vector< std::string > const * PndPidEmcAssociatorTask::SetEmcParNames ( ) const

private

Set Emc related variable names.

Definition at line 52 of file PndPidEmcAssociatorTask.cxx.

Referenced by PndPidEmcAssociatorTask().

{
  std::vector<std::string>* VarNames = new std::vector<std::string>();
  VarNames->push_back("emc");
  VarNames->push_back("lat");
  VarNames->push_back("z20");
  VarNames->push_back("z53");
  VarNames->push_back("e1");
  VarNames->push_back("e9");
  VarNames->push_back("e25");
  
  return VarNames;
}

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

inlineinherited

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 PndPidMvaAssociatorTask::fScFact, and PndPidMvaAssociatorTask::fWeight.

{
  fScFact = scFact;
  fWeight = weight;
};

void PndPidMvaAssociatorTask::SetNumNeigh ( size_t  val )

inlineinherited

Parameters

val	nNumber of neighbors to be uset for KNN classifier.

Definition at line 196 of file PndPidMvaAssociatorTask.h.

References PndPidMvaAssociatorTask::fNumNeigh, and val.

{
  fNumNeigh = val;
};

void PndPidMvaAssociatorTask::SetParContainers ( )

virtualinherited

Set parameter containers

Definition at line 291 of file PndPidMvaAssociatorTask.cxx.

{}

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

privatevirtual

Set Variables to use.

Reimplemented from PndPidMvaAssociatorTask.

Definition at line 44 of file PndPidEmcAssociatorTask.cxx.

References PndPidMvaAssociatorTask::SetVarNames().

Referenced by PndPidEmcAssociatorTask().

{
  std::cout<< "<INFO> Filling EMC related Variable names.\n";
  
  PndPidMvaAssociatorTask::SetVarNames(vNames);
}

void PndPidMvaAssociatorTask::SetVerbose ( Bool_t  verb )

inlineinherited

Definition at line 176 of file PndPidMvaAssociatorTask.h.

References fVerbose.

{
  fVerbose = verb;
};

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

inlineinherited

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 PndPidMvaAssociatorTask::fWeightsFileName.

{
  fWeightsFileName = wFileName;
};

---

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

• PndPidEmcAssociatorTask.h
• PndPidEmcAssociatorTask.cxx