AtlfastC.cxx

Go to the documentation of this file.

// ================================================
// AtlfastC class Implementation
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
// Namespace ATLF::
//

#include <fstream>
#include <cmath>
#include <string>

#include "AtlfastAlgs/AtlfastC.h"
#include "AtlfastAlgs/GlobalEventData.h"


#include "AtlfastEvent/Jet.h"
#include "AtlfastEvent/ReconstructedParticle.h"
#include "AtlfastEvent/IKinematic.h"
#include "AtlfastEvent/CollectionDefs.h"
#include "AtlfastEvent/Interpolator.h"

#include "AtlfastUtils/TesIO.h"
#include "AtlfastUtils/HeaderPrinter.h"

// Gaudi includes
#include "GaudiKernel/DataSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"

//Other Packages used by this class
// Other Packages used by this class:-

#include "CLHEP/Random/Ranlux64Engine.h"
#include "CLHEP/Random/RandFlat.h"
#include "CLHEP/Units/SystemOfUnits.h"

#include "PathResolver/PathResolver.h"

//sea: header file for our interface class

//--------------------------------
// Constructors and destructors
//--------------------------------

namespace Atlfast {
  
  using std::abs;
  AtlfastC::AtlfastC( const std::string& name, ISvcLocator* pSvcLocator ) 
    : Algorithm( name, pSvcLocator )
    , m_tesIO( 0 )
    , m_pRandomEngine( 0 )
    , m_pRandFlatGenerator( 0 )
    , m_AtlfastCJets( 0 )
    , m_electron_interpolator( 0 )
    , m_photon_interpolator( 0 )
    , m_muon_interpolator( 0 )
    , m_jet_interpolator( 0 )
    , m_elecphot_interpolator( 0 )
    , m_elecmuon_interpolator( 0 )
    , m_elecjet_interpolator( 0 )
    , m_photelec_interpolator( 0 )
    , m_photmuon_interpolator( 0 )
    , m_photjet_interpolator( 0 )
    , m_muonelec_interpolator( 0 )
    , m_muonphot_interpolator( 0 )
    , m_muonjet_interpolator( 0 )
    , m_jetelec_interpolator( 0 )
    , m_jetphot_interpolator( 0 )
    , m_jetmuon_interpolator( 0 )
{
     //Default private parameters
    
    m_ApplyElecElecEff  =  true;
    m_ApplyElecPhotEff  =  true;
    m_ApplyElecMuonEff  =  true;
    m_ApplyPhotPhotEff  =  true;
    m_ApplyPhotElecEff  =  true; 
    m_ApplyPhotMuonEff  =  true; 
    m_ApplyMuonPhotEff  =  true;
    m_ApplyMuonElecEff  =  true; 
    m_ApplyMuonMuonEff  =  true;
    m_ApplyJetJetEff    =  true;
    m_ApplyJetPhotEff   =  true;
    m_ApplyJetElecEff   =  true; 
    m_ApplyJetMuonEff   =  true;
    m_ApplyPhotJetEff   =  false;
    m_ApplyElecJetEff   =  false; 
    m_ApplyMuonJetEff   =  false;
 


 
    
    // Default paths for entities in the TES
    m_inputeLocation         = "/Event/AtlfastIsolatedElectrons";
    m_inputphotonLocation    = "/Event/AtlfastIsolatedPhotons";
    m_inputmuonLocation      = "/Event/AtlfastIsolatedMuons" ;
    m_inputjetLocation       = "/Event/AtlfastJets" ;
    // input from AtlfastB jets
    //    m_inputjetLocation       = "/Event/AtlfastCalJets" ;

    m_outputeLocation        = "/Event/AtlfastCElectrons";
    m_outputphotonLocation   = "/Event/AtlfastCPhotons";
    m_outputmuonLocation     = "/Event/AtlfastCMuons" ;
    m_outputjetLocation      = "/Event/AtlfastCJets" ;


    m_elecelecEfile          = "atlfastDatafiles/electron_electronEff.dat";
    m_elecphotEfile          = "atlfastDatafiles/electron_photonEff.dat";
    m_elecmuonEfile          = "atlfastDatafiles/electron_muid_muonEff.dat";
    m_elecjetEfile           = "atlfastDatafiles/electron_ktjetEff.dat";
    //    m_elecmuonEfile          = "atlfastDatafiles/electron_staco_muonEff.dat";
    m_photelecEfile          = "atlfastDatafiles/photon_electronEff.dat";
    m_photphotEfile          = "atlfastDatafiles/photon_photonEff.dat";
    m_photmuonEfile          = "atlfastDatafiles/photon_muid_muonEff.dat";
    m_photjetEfile           = "atlfastDatafiles/photon_ktjetEff.dat";
    //    m_photmuonEfile          = "atlfastDatafiles/photon_staco_muonEff.dat";
    m_muonelecEfile          = "atlfastDatafiles/muon_electronEff.dat";
    m_muonphotEfile          = "atlfastDatafiles/muon_photonEff.dat";
    m_muonmuonEfile          = "atlfastDatafiles/muon_muid_muonEff.dat";
    m_muonjetEfile           = "atlfastDatafiles/muon_ktjetEff.dat";
    //    m_muonmuonEfile          = "atlfastDatafiles/muon_staco_muonEff.dat";
    m_jetelecEfile           = "atlfastDatafiles/ktjet_electronEff.dat";
    m_jetphotEfile           = "atlfastDatafiles/ktjet_photonEff.dat";
    m_jetmuonEfile           = "atlfastDatafiles/ktjet_muid_muonEff.dat";
    m_jetjetEfile            = "atlfastDatafiles/ktjet_ktjetEff.dat";
    //    m_jetmuonEfile          = "atlfastDatafiles/jet_staco_muonEff.dat";


    // This is how you declare the paramemters to Gaudi so that
    // they can be over-written via the job options file
        
    declareProperty( "InputeLocation",           m_inputeLocation ) ;
    declareProperty( "InputphotonLocation",      m_inputphotonLocation ) ;
    declareProperty( "InputmuonLocation",        m_inputmuonLocation ) ;
    declareProperty( "InputjetLocation",         m_inputjetLocation ) ;

    declareProperty( "OutputeLocation",          m_outputeLocation ) ;
    declareProperty( "OutputphotonLocation",     m_outputphotonLocation ) ;
    declareProperty( "OutputmuonLocation",       m_outputmuonLocation ) ;
    declareProperty( "OutputjetLocation",        m_outputjetLocation ) ;
    
    declareProperty( "ApplyElecElecEff",         m_ApplyElecElecEff);
    declareProperty( "ApplyElecPhotEff",         m_ApplyElecPhotEff);
    declareProperty( "ApplyElecMuonEff",         m_ApplyElecMuonEff);
    declareProperty( "ApplyPhotPhotEff",         m_ApplyPhotPhotEff);
    declareProperty( "ApplyPhotElecEff",         m_ApplyPhotElecEff);
    declareProperty( "ApplyPhotMuonEff",         m_ApplyPhotMuonEff);
    declareProperty( "ApplyMuonElecEff",         m_ApplyMuonElecEff);
    declareProperty( "ApplyMuonPhotEff",         m_ApplyMuonPhotEff);
    declareProperty( "ApplyMuonMuonEff",         m_ApplyMuonMuonEff);
    declareProperty( "ApplyJetElecEff",          m_ApplyJetElecEff);
    declareProperty( "ApplyJetPhotEff",          m_ApplyJetPhotEff);
    declareProperty( "ApplyJetMuonEff",          m_ApplyJetMuonEff);
    declareProperty( "ApplyJetJetEff",           m_ApplyJetJetEff);
    declareProperty( "ApplyElecJetEff",          m_ApplyElecJetEff);
    declareProperty( "ApplyPhotJetEff",          m_ApplyPhotJetEff);
    declareProperty( "ApplyMuonJetEff",          m_ApplyMuonJetEff);



    declareProperty( "ElecElecFile", m_elecelecEfile);
    declareProperty( "ElecPhotFile", m_elecphotEfile);
    declareProperty( "ElecMuonFile", m_elecmuonEfile);
    declareProperty( "PhotElecFile", m_photelecEfile);
    declareProperty( "PhotPhotFile", m_photphotEfile);
    declareProperty( "PhotMuonFile", m_photmuonEfile);
    declareProperty( "MuonElecFile", m_muonelecEfile);
    declareProperty( "MuonPhotFile", m_muonphotEfile);
    declareProperty( "MuonMuonFile", m_muonmuonEfile);
    declareProperty( "JetElecFile", m_jetelecEfile);
    declareProperty( "JetPhotFile", m_jetphotEfile);
    declareProperty( "JetMuonFile", m_jetmuonEfile);
    declareProperty( "JetJetFile",  m_jetjetEfile);
    declareProperty( "ElecJetFile", m_elecjetEfile);
    declareProperty( "PhotJetFile", m_photjetEfile);
    declareProperty( "MuonJetFile", m_muonjetEfile);

  }
  
  AtlfastC::~AtlfastC() {
    
    MsgStream log( messageService(), name() ) ;
    log << MSG::DEBUG << "Destructor" << endreq;
    if( m_tesIO) {
      delete m_tesIO;
    }
    if( m_pRandomEngine) {
      delete m_pRandomEngine;
    }
    if( m_pRandFlatGenerator) {
      delete m_pRandFlatGenerator;
    }

    //    delete dummy_cluster ;

  }
  
  
  
  //---------------------------------
  // initialise() 
  //---------------------------------
  
  StatusCode AtlfastC::initialize(){
    MsgStream log( messageService(), name() ) ;
    log << MSG::DEBUG << "instantiating an AtlfastC" << endreq;
    

     m_elecelecEfile = PathResolver::find_file (m_elecelecEfile, "DATAPATH"); 
     m_elecphotEfile = PathResolver::find_file (m_elecphotEfile, "DATAPATH");  
     m_elecmuonEfile = PathResolver::find_file (m_elecmuonEfile, "DATAPATH");  
     m_photelecEfile = PathResolver::find_file (m_photelecEfile, "DATAPATH"); 
     m_photphotEfile = PathResolver::find_file (m_photphotEfile, "DATAPATH"); 
     m_photmuonEfile = PathResolver::find_file (m_photmuonEfile, "DATAPATH");  
     m_muonelecEfile = PathResolver::find_file (m_muonelecEfile, "DATAPATH"); 
     m_muonphotEfile = PathResolver::find_file (m_muonphotEfile, "DATAPATH");  
     m_muonmuonEfile = PathResolver::find_file (m_muonmuonEfile, "DATAPATH");  
     m_jetelecEfile  = PathResolver::find_file (m_jetelecEfile, "DATAPATH"); 
     m_jetphotEfile  = PathResolver::find_file (m_jetphotEfile, "DATAPATH");  
     m_jetmuonEfile  = PathResolver::find_file (m_jetmuonEfile, "DATAPATH");  
     m_jetjetEfile   = PathResolver::find_file (m_jetjetEfile, "DATAPATH");  
     m_elecjetEfile  = PathResolver::find_file (m_elecjetEfile, "DATAPATH"); 
     m_photjetEfile  = PathResolver::find_file (m_photjetEfile, "DATAPATH");  
     m_muonjetEfile  = PathResolver::find_file (m_muonjetEfile, "DATAPATH");  

     log << MSG::DEBUG << " m_elecelecEfile after PathResolver" << m_elecelecEfile << endreq;
     log << MSG::DEBUG << " m_elecphotEfile after PathResolver" << m_elecphotEfile << endreq;
     log << MSG::DEBUG << " m_photelecEfile after PathResolver" << m_photelecEfile << endreq;
     log << MSG::DEBUG << " m_photphotEfile after PathResolver" << m_photphotEfile << endreq;

     m_electron_interpolator = new Interpolator(m_elecelecEfile);
     m_photon_interpolator =   new Interpolator(m_photphotEfile);
     m_muon_interpolator =     new Interpolator(m_muonmuonEfile);
     m_jet_interpolator =      new Interpolator(m_jetjetEfile);
     m_elecphot_interpolator = new Interpolator(m_elecphotEfile);
     m_elecmuon_interpolator = new Interpolator(m_elecmuonEfile);
     m_elecjet_interpolator  = new Interpolator(m_elecjetEfile);
     m_photelec_interpolator = new Interpolator(m_photelecEfile);
     m_photmuon_interpolator = new Interpolator(m_photmuonEfile);
     m_photjet_interpolator = new Interpolator(m_photjetEfile);
     m_muonelec_interpolator = new Interpolator(m_muonelecEfile);
     m_muonphot_interpolator = new Interpolator(m_muonphotEfile);
     m_muonjet_interpolator = new Interpolator(m_muonjetEfile);
     m_jetelec_interpolator = new Interpolator(m_jetelecEfile);
     m_jetphot_interpolator = new Interpolator(m_jetphotEfile);
     m_jetmuon_interpolator = new Interpolator(m_jetmuonEfile);

    //Flat random number generator
    //get the Global Event Data using singleton pattern

    GlobalEventData* ged = GlobalEventData::Instance();
    int randSeed = ged->randSeed() ;
    // load the location of the MC in StoreGate
    m_mcLocation       = ged -> mcLocation();

    m_tesIO= new TesIO(m_mcLocation, ged->justHardScatter());

    m_pRandomEngine = new Ranlux64Engine(randSeed);
    m_pRandFlatGenerator=new RandFlat(*m_pRandomEngine);
    
    
    HeaderPrinter hp("AtlfastC:", log);
    
    hp.add("TES Locations:              "); 
    hp.add( "Electrons from                      ",m_inputeLocation ) ;
    hp.add( "Photons from                        ",m_inputphotonLocation ) ;
    hp.add( "Muons from                          ",m_inputmuonLocation ) ;
    hp.add( "Jets from                           ",m_inputjetLocation ) ;

    hp.add( "Electrons after efficiency & mis-id ",m_outputeLocation ) ;
    hp.add( "Photons after efficiency & mis-id   ",m_outputphotonLocation ) ;
    hp.add( "Muons after efficiency & mis-id     ",m_outputmuonLocation ) ;
    hp.add( "Jets after efficiency & mis-id      ",m_outputjetLocation ) ;
    
    hp.add( "Apply ElecElec Efficiency            ",         m_ApplyElecElecEff);
    hp.add( "Apply ElecPhot Mis id                ",         m_ApplyElecPhotEff);
    hp.add( "Apply ElecMuon Mis id                ",         m_ApplyElecMuonEff);
    hp.add( "Apply PhotPhot Efficiency            ",         m_ApplyPhotPhotEff);
    hp.add( "Apply PhotElec Mis id                ",         m_ApplyPhotElecEff);
    hp.add( "Apply PhotMuon Mis id                ",         m_ApplyPhotMuonEff);
    hp.add( "Apply MuonPhot Efficiency            ",         m_ApplyMuonPhotEff);
    hp.add( "Apply MuonElec Mis id                ",         m_ApplyMuonElecEff);
    hp.add( "Apply MuonMuon Mis id                ",         m_ApplyMuonMuonEff);
    hp.add( "Apply JetJet Efficiency             ",         m_ApplyJetJetEff);
    hp.add( "Apply JetPhot Mis id                ",         m_ApplyJetPhotEff);
    hp.add( "Apply JetElec Mis id                ",         m_ApplyJetElecEff);
    hp.add( "Apply JetMuon Mis id                ",         m_ApplyJetMuonEff);
    hp.add( "Apply PhotJet Mis id                ",         m_ApplyPhotJetEff);
    hp.add( "Apply ElecJet Mis id                ",         m_ApplyElecJetEff);
    hp.add( "Apply MuonJet Mis id                ",         m_ApplyMuonJetEff);

    hp.print();
    
    return StatusCode::SUCCESS ;
  }  

  
  //---------------------------------
  // finalise() 
  //---------------------------------
  
  StatusCode AtlfastC::finalize(){
    
    MsgStream log( messageService(), name() ) ;
    log << MSG::INFO << "finalizing" << endreq;    
    return StatusCode::SUCCESS ;
  }
  
  
  //----------------------------------------------
  // execute() method called once per event
  //----------------------------------------------
  
  StatusCode AtlfastC::execute(){
    

    StatusCode sc;
    MsgStream log( messageService(), name() ) ;  
    
    log << MSG::DEBUG<<"In execute"<<endreq;
    originalElectrons.clear();
    originalPhotons.clear();
    originalJets.clear();
    originalMuons.clear();

    if( ! m_tesIO->copy<ReconstructedParticleCollection>( originalElectrons, m_inputeLocation ) ) {
      log << MSG::INFO << "No Electrons in TES " << endreq;
    }  
    
    if( ! m_tesIO->copy<ReconstructedParticleCollection>( originalPhotons, m_inputphotonLocation ) ) {
      log << MSG::INFO << "No Photons in TES " << endreq;
      
    } 
    
    if( ! m_tesIO->copy<JetCollection>( originalJets, m_inputjetLocation ) ) {
      log << MSG::INFO << "No Jets in TES " << endreq;
    }  
    
    if( ! m_tesIO->copy<ReconstructedParticleCollection>( originalMuons, m_inputmuonLocation ) ) {
      log << MSG::INFO << "No Muons in TES " << endreq;
      
    }  
     
     m_AtlfastCElectrons = new ReconstructedParticleCollection;
     m_AtlfastCPhotons   = new ReconstructedParticleCollection;
     m_AtlfastCMuons     = new ReconstructedParticleCollection;
     m_AtlfastCJets      = new JetCollection;
     

     if(m_ApplyElecElecEff && originalElectrons.size()!=0 ){
       sc=ApplyEfficiency(originalElectrons,m_AtlfastCElectrons,m_electron_interpolator,11) ;
       if(!sc){
         log << MSG::ERROR<<"Error in Electron Electron Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }
     
     if(m_ApplyElecPhotEff && originalElectrons.size()!=0 ){
       sc=ApplyEfficiency(originalElectrons,m_AtlfastCPhotons,m_elecphot_interpolator,22) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Electron Photon Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }
     
     if(m_ApplyElecMuonEff && originalElectrons.size()!=0 ){
       sc=ApplyEfficiency(originalElectrons,m_AtlfastCMuons,m_elecmuon_interpolator,13) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Electron Muon Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyElecJetEff && originalElectrons.size()!=0 ){
       sc=ApplyEfficiency(originalElectrons,m_AtlfastCJets,m_elecjet_interpolator) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Electron Jet Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }
          
     if(m_ApplyPhotElecEff && originalPhotons.size()!=0 ){
       sc=ApplyEfficiency(originalPhotons,m_AtlfastCElectrons,m_photelec_interpolator,11) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Photon Electron Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyPhotPhotEff && originalPhotons.size()!=0 ){
       sc=ApplyEfficiency(originalPhotons,m_AtlfastCPhotons,m_photon_interpolator,22) ;
       if(!sc){
         log << MSG::ERROR<<"Error in Photon Photon Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyPhotMuonEff && originalPhotons.size()!=0 ){
       sc=ApplyEfficiency(originalPhotons,m_AtlfastCMuons,m_photmuon_interpolator,13) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Photon Muon Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyPhotJetEff && originalPhotons.size()!=0 ){
       sc=ApplyEfficiency(originalPhotons,m_AtlfastCJets,m_photjet_interpolator) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Photon Jet Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyMuonElecEff && originalMuons.size()!=0 ){
       sc=ApplyEfficiency(originalMuons,m_AtlfastCElectrons,m_muonelec_interpolator,11) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Muon Electron Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyMuonPhotEff && originalMuons.size()!=0 ){
       sc=ApplyEfficiency(originalMuons,m_AtlfastCPhotons,m_muonphot_interpolator,22) ;
       if(!sc){
         log << MSG::ERROR<<"Error in Muon Photon Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyMuonMuonEff && originalMuons.size()!=0 ){
       sc=ApplyEfficiency(originalMuons,m_AtlfastCMuons,m_muon_interpolator,13) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Muon Muon Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyMuonJetEff && originalMuons.size()!=0 ){
       sc=ApplyEfficiency(originalMuons,m_AtlfastCJets,m_muonjet_interpolator) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Muon Jet Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }

     if(m_ApplyJetElecEff && originalJets.size()!=0 ){
       sc=ApplyEfficiency(originalJets,m_AtlfastCElectrons,m_jetelec_interpolator,11) ;
       if(!sc){
         log << MSG::ERROR<<"Error in Jet Electron Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }
     
     if(m_ApplyJetPhotEff && originalJets.size()!=0 ){
       sc=ApplyEfficiency(originalJets,m_AtlfastCPhotons,m_jetphot_interpolator,22) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Jet Photon Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }
     
     if(m_ApplyJetMuonEff && originalJets.size()!=0 ){
       sc=ApplyEfficiency(originalJets,m_AtlfastCMuons,m_elecmuon_interpolator,13) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Jet Muon Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }
     
     if(m_ApplyJetJetEff && originalJets.size()!=0 ){
       sc=ApplyEfficiency(originalJets,m_AtlfastCJets,m_jet_interpolator) ;
       if(!sc){ 
         log << MSG::ERROR<<"Error in Jet Jet Element"<<endreq;
         return StatusCode::FAILURE;
       }
     }
     

     
     TesIoStat stat;
     stat = m_tesIO->store( m_AtlfastCElectrons, m_outputeLocation);
     if(!stat){
       log << MSG::ERROR << "Could not store AtlfastC electrons"<< endreq;
       return stat;
     }
     
     stat = m_tesIO->store( m_AtlfastCPhotons, m_outputphotonLocation);
     if(!stat){
       log << MSG::ERROR << "Could not store AtlfastC photons"<< endreq;
       return stat;
     }
     stat = m_tesIO->store( m_AtlfastCMuons, m_outputmuonLocation);
     if(!stat){
       log << MSG::ERROR << "Could not store AtlfastC muons"<< endreq;
       return stat;
     }
     stat = m_tesIO->store( m_AtlfastCJets, m_outputjetLocation);
     if(!stat){
       log << MSG::ERROR << "Could not store AtlfastC jets"<< endreq;
       return stat;
     }
     
     
     
     return StatusCode::SUCCESS; 
  }
  
  //-------------------------------
  // helper methods implementation
  //-------------------------------
  StatusCode AtlfastC::ApplyEfficiency(std::vector<ReconstructedParticle*> OriginalList, ReconstructedParticleCollection* NewList, Interpolator* InterpolatorName ,int pdgidnew){
   
    MsgStream log( messageService(), name() ) ;     
    //Apply randomized particle to particle efficiency
    log<<MSG::DEBUG<<"Applying randomized efficiency...."<<endreq;
    
    for(m_it=OriginalList.begin(); m_it<OriginalList.end();++m_it){
      
      log<<MSG::DEBUG<<"In the particle particle loop...."<<endreq;
      
      double recopt=(*m_it)->pT();
      double recoeta=(*m_it)->eta();
      //      int pdgid=(*m_it)->pdg_id();
      
      double randnum=m_pRandFlatGenerator->shoot(m_pRandomEngine);
      
      // pass the pt, eta, pdg_id to something else...      
      double epsilon_ij = getEfficiencyMatrixElement(recopt, recoeta, InterpolatorName );
      
      if(randnum < epsilon_ij){
        log<<MSG::DEBUG<<"in-out: " << **m_it << endreq;
        // to make a reconstructed particle and give it a different pdg_id:
        ReconstructedParticle* candidate = new ReconstructedParticle ( pdgidnew /*m_particleType*/, (*m_it)->momentum(), (*m_it)->truth() );            
        NewList->push_back(candidate);
        log<<MSG::DEBUG<<"particle put in new collection"<<endreq;
      }
    }
    return StatusCode::SUCCESS;

  }

  StatusCode AtlfastC::ApplyEfficiency(std::vector<Jet*> OriginalList, ReconstructedParticleCollection* NewList, Interpolator* InterpolatorName ,int pdgidnew){
   
    MsgStream log( messageService(), name() ) ;     
    //Apply randomized jet to particle
    log<<MSG::DEBUG<<"Applying randomized efficiency...."<<endreq;
    
    for(j_it=OriginalList.begin(); j_it<OriginalList.end();++j_it){
      
      log<<MSG::DEBUG<<"In the jet particle loop...."<<endreq;
      
      double recopt=(*j_it)->pT();
      double recoeta=(*j_it)->eta();
      //      int pdgid=(*m_it)->pdg_id();
      
      double randnum=m_pRandFlatGenerator->shoot(m_pRandomEngine);
      
      // pass the pt, eta, pdg_id to something else...      
      double epsilon_ij = getEfficiencyMatrixElement(recopt, recoeta, InterpolatorName );
      
      if(randnum < epsilon_ij){
        log<<MSG::DEBUG<<"in-out: " << **j_it << endreq;
        // to make a reconstructed particle and give it a different pdg_id:
        HepMC::GenParticle* dummy_truth(0) ;
        ReconstructedParticle* candidate = new ReconstructedParticle ( pdgidnew /*m_particleType*/, (*j_it)->momentum() , dummy_truth);         
        NewList->push_back(candidate);
        log<<MSG::DEBUG<<"particle put in new collection"<<endreq;
      }
    }
    return StatusCode::SUCCESS;

  }
  // not sure for the next two methods concerning new Jet using newpdgid
  StatusCode AtlfastC::ApplyEfficiency(std::vector<ReconstructedParticle*> OriginalList, JetCollection* NewList, Interpolator* InterpolatorName ){
   
    MsgStream log( messageService(), name() ) ;     
    //Apply randomized particle to jet efficiency
    log<<MSG::DEBUG<<"Applying randomized efficiency...."<<endreq;
    
    for(m_it=OriginalList.begin(); m_it<OriginalList.end();++m_it){
      
      log<<MSG::DEBUG<<"In the particle jet loop...."<<endreq;
      
      double recopt=(*m_it)->pT();
      double recoeta=(*m_it)->eta();
      //      int pdgid=(*m_it)->pdg_id();
      
      double randnum=m_pRandFlatGenerator->shoot(m_pRandomEngine);
      
      // pass the pt, eta, pdg_id to something else...      
      double epsilon_ij = getEfficiencyMatrixElement(recopt, recoeta, InterpolatorName );
      
      if(randnum < epsilon_ij){
        log<<MSG::DEBUG<<"in-out: " << **m_it << endreq;

        Jet* candidate = this->createJet(*m_it);
        NewList->push_back(candidate);

        log<<MSG::DEBUG<<"particle put in new collection"<<endreq;
      }
    }
    return StatusCode::SUCCESS;

  }

  StatusCode AtlfastC::ApplyEfficiency(std::vector<Jet*> OriginalList, JetCollection* NewList, Interpolator* InterpolatorName){
   
    MsgStream log( messageService(), name() ) ;     
    //Apply randomized jet to jet efficiency
    log<<MSG::DEBUG<<"Applying randomized efficiency...."<<endreq;
    
    for(j_it=OriginalList.begin(); j_it<OriginalList.end();++j_it){
      
      log<<MSG::DEBUG<<"In the jet jet loop...."<<endreq;
      
      double recopt=(*j_it)->pT();
      double recoeta=(*j_it)->eta();
      //      int pdgid=(*m_it)->pdg_id();
      
      double randnum=m_pRandFlatGenerator->shoot(m_pRandomEngine);
      
      // pass the pt, eta, pdg_id to something else...      
      double epsilon_ij = getEfficiencyMatrixElement(recopt, recoeta, InterpolatorName );
      
      if(randnum < epsilon_ij){
        log<<MSG::DEBUG<<"in-out: " << **j_it << endreq;
        // to make a reconstructed particle and give it a different pdg_id:


        Jet* candidate = new Jet ( **j_it );            
        NewList->push_back(candidate);
        log<<MSG::DEBUG<<"particle put in new collection"<<endreq;
      }
    }
    return StatusCode::SUCCESS;

  }

  double AtlfastC::getEfficiencyMatrixElement(double pt, double eta, Interpolator* InterpolatorName){
    MsgStream log( messageService(), name() ) ;
 
    double Efficiency = 0;

    deque<double> input_values;
    input_values.push_back(pt/GeV);
    input_values.push_back(fabs(eta));
    
    
    Efficiency = InterpolatorName->interpolate(input_values);

    //    log<<MSG::ERROR << "pt" << pt/GeV <<  "eta" << eta << "eff is " << Efficiency <<endreq;

    return Efficiency;
  }

  //sea:try putting converter create jet here:

 Jet* AtlfastC::createJet(const ReconstructedParticle* rp){
    
    Jet* jet = 0;
    MsgStream log( messageService(), name() );
    HepLorentzVector vec = rp->momentum();

    //No smearing applied - jets keep their particle smearing.
    
    // Get associations of ReconstructedParticle 
    const IAOO* iaooRP = rp;
    TypeVisitor tv =
      ContainerDispatcher( iaooRP->begin(), iaooRP->end(), TypeVisitor() );
    
    // Select the vector of Clusters (should just be one)
    std::vector<const Cluster*> cv = tv.typeVector(Cluster());
    log << MSG::INFO << "TypeVisitor found " << cv.size() 
        << " Clusters in this ReconstructedParticle" << endreq;
    
    if ( cv.size() == 1 ){
      Cluster* ic = const_cast<Cluster*>(cv[0]);
      jet = new Jet(vec, *ic);
      log << MSG::INFO << "Unsmeared Cluster: " << *ic << endreq;
      log << MSG::INFO << "Smeared Jet      : " << jet << endreq ;
    }

    return jet;
    
  }  



}
 //end namespace bracket

---