/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/ElectronPhotonSelectorTools/ElectronPhotonSelectorTools/AsgElectronChargeIDSelectorTool.h

// Dear emacs, this is -*-c++-*-

#ifndef __ASGELECTRONCHARGEIDSELECTORTOOL__
#define __ASGELECTRONCHARGEIDSELECTORTOOL__


// Atlas includes
#include "AsgTools/AsgTool.h"
#include "MVAUtils/BDT.h"
#include "ElectronPhotonSelectorTools/TElectronLikelihoodTool.h"
#include "ElectronPhotonSelectorTools/IAsgElectronLikelihoodTool.h"
#include <unordered_map>
//#include "xAODEgamma/ElectronFwd.h"

class AsgElectronChargeIDSelectorTool : public asg::AsgTool, 
                  virtual public IAsgElectronLikelihoodTool
{
  ASG_TOOL_CLASS2(AsgElectronChargeIDSelectorTool, IAsgElectronLikelihoodTool, IAsgSelectionTool)

public:
  AsgElectronChargeIDSelectorTool( const std::string myname);


  virtual ~AsgElectronChargeIDSelectorTool();
public:
  virtual StatusCode initialize();

  virtual StatusCode finalize();

  // Main methods for IAsgSelectorTool interface
  const Root::TAccept& accept( const xAOD::IParticle* part ) const;

  const Root::TAccept& accept( const xAOD::Electron* eg ) const {
    return accept (eg, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

  const Root::TAccept& accept( const xAOD::Egamma* eg ) const {
    return accept (eg, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

  const Root::TAccept& accept( const xAOD::Electron* eg, double mu ) const;

  const Root::TAccept& accept( const xAOD::Egamma* eg, double mu ) const;
  
  virtual const Root::TAccept& accept( const xAOD::IParticle& part ) const {
    return accept (&part);
  }

  virtual const Root::TAccept& accept( const xAOD::Electron& part ) const {
    return accept (&part, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

  virtual const Root::TAccept& accept( const xAOD::Egamma& part ) const {
    return accept (&part, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

  virtual const Root::TAccept& accept( const xAOD::Electron& part, double mu ) const {
    return accept (&part, mu);
  }

  virtual const Root::TAccept& accept( const xAOD::Egamma& part, double mu ) const {
    return accept (&part, mu);
  }

  // Main methods for IAsgCalculatorTool interface

  const Root::TResult& calculate( const xAOD::IParticle* part ) const;

  const Root::TResult& calculate( const xAOD::Electron* eg ) const {
    return calculate (eg, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

  const Root::TResult& calculate( const xAOD::Egamma* eg ) const {
    return calculate (eg, -99); // mu = -99 as input will force accept to grab the pileup variable from the xAOD object
  }

  const Root::TResult& calculate( const xAOD::Electron* eg, double mu ) const;

  const Root::TResult& calculate( const xAOD::Egamma* eg, double mu ) const; 

  inline virtual const Root::TAccept& getTAccept( ) const
  {
    // return m_rootTool->getTAccept();
    return m_acceptDummy;
  }


  inline virtual const Root::TResult& getTResult( ) const
  {
    // return m_rootTool->getTResult();
    return m_resultDummy;
  }

  inline virtual std::string getOperatingPointName( ) const
  // std::string AsgElectronChargeIDSelectorTool::getOperatingPointName() const
  {    return m_WorkingPoint;  };
  
  // Private methods
private:
  unsigned int getNPrimVertices() const;

  //BDT instances for different ID operating points (Tight, Medium, Loose) and the vector corresponds to n-fold
  const unsigned m_nfold  =1;
  const unsigned bdt_index=0;
  std::vector<MVAUtils::BDT*> m_v_bdts;

  TString m_pid_name;
  float m_cutOnBDT;

  int m_cutPosition_bdt;
  int m_resultPosition_bdt;

  std::string m_WorkingPoint;

  Root::TAccept m_acceptDummy;

  Root::TResult m_resultDummy;

  mutable Root::TAccept m_acceptBDT;
  mutable Root::TResult m_resultBDT;

  bool m_usePVCont;

  unsigned int m_nPVdefault;

  std::string m_primVtxContName;

  std::string m_trainingFile;

  //bool m_caloOnly;

  // BDT input variables
  mutable std::unordered_map<std::string,float> m_map_inputs;
  mutable std::vector<std::string> m_inputVars;

  bool SetVariableRefs(std::vector<std::string> inputs, std::vector<float*> &inputPointers);

}; // End: class definition





#endif

---