/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/ElectronEfficiencyCorrection/ElectronEfficiencyCorrection/AsgElectronEfficiencyCorrectionTool.h

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

#ifndef __ASGELECTRONEFFICIENCYCORRECTIONTOOL__
#define __ASGELECTRONEFFICIENCYCORRECTIONTOOL__

// STL includes
#include <vector>
#include <string>
#include <iterator>
#include <map>
// Utility includes
#include "boost/unordered_map.hpp"
// Include the return object and the underlying ROOT tool
#include "PATCore/TResult.h"
#include "AthContainers/AuxElement.h"
//xAOD includes
#include "AsgTools/AsgTool.h"
#include "AsgTools/AsgMetadataTool.h"

#include "PATInterfaces/ISystematicsTool.h"
#include "PATInterfaces/SystematicRegistry.h"
#include "PATInterfaces/CorrectionCode.h"
#include "ElectronEfficiencyCorrection/TElectronEfficiencyCorrectionTool.h"
#include "ElectronEfficiencyCorrection/IAsgElectronEfficiencyCorrectionTool.h"
#include "xAODEgamma/ElectronFwd.h"

class AsgElectronEfficiencyCorrectionTool
  : virtual public IAsgElectronEfficiencyCorrectionTool, public asg::AsgMetadataTool
{
  ASG_TOOL_CLASS(AsgElectronEfficiencyCorrectionTool, IAsgElectronEfficiencyCorrectionTool)

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

  virtual ~AsgElectronEfficiencyCorrectionTool();


public:
  virtual StatusCode initialize();

  virtual StatusCode finalize();

  // Introducing to check if  METADATA working
  virtual StatusCode beginInputFile();    
  virtual StatusCode beginEvent();
  virtual StatusCode endInputFile();    
 
  // Main methods from IUserDataCalcTool
public:

  int getNumberOfToys( ){return m_number_of_toys;} ;


  CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::Electron& inputObject, double& efficiencyScaleFactor) const;
  CP::CorrectionCode applyEfficiencyScaleFactor(const xAOD::Electron& inputObject) const;

  void printCorrelationModels() {
    ATH_MSG_INFO(" Available Correlation Models for the ElectronEfficiencyCorrectionTool");
    ATH_MSG_INFO("FULL");
    ATH_MSG_INFO("SIMPLIFIED");
    ATH_MSG_INFO("MCTOYS");
    ATH_MSG_INFO("SYST");
    ATH_MSG_INFO("COMBMCTOYS");
    ATH_MSG_INFO("TOTAL");
  } ;

  virtual bool isAffectedBySystematic( const CP::SystematicVariation& systematic ) const ;
  
  virtual CP::SystematicSet affectingSystematics() const ;
  
  virtual CP::SystematicSet recommendedSystematics() const ;

  const CP::SystematicSet& appliedSystematics() const {
    return *m_appliedSystematics;
  }

  virtual CP::SystematicCode applySystematicVariation ( const CP::SystematicSet& systConfig ) ;

  CP::SystematicCode registerSystematics();

  // Private member variables
private:
  // To check if the metadat can be retrieved 
  bool m_metadata_retrieved = false;

  // Get the simulation type from metadata
  StatusCode get_simType_from_metadata(PATCore::ParticleDataType::DataType& result) const;


  const Root::TResult& calculate( const xAOD::Electron& egam, const unsigned int runnumber, int &currentElectronSimplifiedUncorrSystRegion, int& currentElectronUncorrSystRegion ) const ;
  CP::SystematicCode InitSystematics();

  // struct for toys
  struct SystConf{
    float m_total;
    unsigned m_toy_index;
    float m_toy_scale;
  };

  // Gets the correction filename from map  
  virtual StatusCode getFile(const std::string& recokey, const std::string& idkey, const std::string& isokey, const std::string& trigkey);

  // Convert reco, ID, iso and trigger key values into a 
  // single key according to the map file key format
  std::string convertToOneKey(const std::string& recokey, const std::string& idkey, const std::string& isokey, const std::string& trigkey) const;

  // Retrieves the value from the provided map file as 
  // associated with the provided key
  std::string getValueByKey(const std::string& mapFile, const std::string& key);

  // Reads the provided map file
  // and construct the map
  StatusCode read (const std::string& strFile);
      
  // Retrieves the value from the provided map file if 
  // even the provided key is found. If the key has an 
  // association then, the actual retrieved value would
  // be assigned to the 2nd argument of this method 
  std::string getValue(const std::string& strKey, std::string& strValue);  

  Root::TElectronEfficiencyCorrectionTool* m_rootTool;

  Root::TResult m_resultDummy;

  boost::unordered_map<CP::SystematicSet, CP::SystematicSet> m_systFilter;

  CP::SystematicSet m_affectedSys;

  CP::SystematicSet* m_appliedSystematics;

  // Correlation Model
  std::string m_correlation_model_name;
  int  m_correlation_model;

  // Map-key properties
  std::map<std::string,std::string> m_map;
  std::string  m_mapFile;
  
  //Four SF key Properties 
  std::string  m_recoKey;
  std::string  m_idKey;
  std::string  m_isoKey;
  std::string  m_trigKey;
  
  std::vector< std::string > m_corrFileNameList;

  std::string m_resultPrefix;

  std::string m_resultName;

  // The prefix for the systematic name
  std::string m_sysSubstring;

  std::string m_eventInfoCollectionName;

  //use RandomRun Number
  bool m_useRandomRunNumber;
  unsigned int m_defaultRandomRunNumber;

  //The data type
  PATCore::ParticleDataType::DataType m_dataType;

  int m_dataTypeOverwrite;

  // Number of toys:
  int m_number_of_toys;

  // seed for toys:
  int m_seed_toys;
    
  // scale for toy uncertainty:
  double m_scale_toys;

  // number if systematics uncertainty    
  int m_nCorrSyst;
  int m_nUncorrSyst ;
  std::map<float, std::vector<float> > m_pteta_bins;
  
  // simplified uncorrelation regions
  TH2F * m_UncorrRegions;
  int m_nSimpleUncorrSyst;

}; // End: class definition



#endif

---