IKinematicDumper.cxx

Go to the documentation of this file.

// ================================================
//IKinematicDumper class Implementation
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
// Namespace Atlfast::
//
#include "AtlfastAlgs/IKinematicDumper.h"
#include "AtlfastEvent/ICluster.h"
#include "AtlfastEvent/Jet.h"
#include "AtlfastEvent/ITwoCptCell.h"
#include "AtlfastEvent/CollectionDefs.h"
#include "AtlfastEvent/ReconstructedParticle.h"
#include "AtlfastUtils/FunctionObjects.h"
#include "EventKernel/I4Momentum.h"
#include "AtlfastAlgs/GlobalEventData.h"

#include <cmath> 
#include <algorithm>
#include <iomanip>
// Gaudi includes
#include "GaudiKernel/DataSvc.h"
#include <assert.h>
#include <cmath>
//--------------------------------
// Constructors and destructors
//--------------------------------

namespace Atlfast {
  using std::cout;
  using std::endl;
  using std::ios;

  IKinematicDumper::IKinematicDumper
  ( const std::string& name, ISvcLocator* pSvcLocator ) 
    : Algorithm( name, pSvcLocator ){
    
    
    // Default paths for entities in the TES
    m_clusterLocation         = "/Event/AtlfastClusters";
    m_jetLocation             = "/Event/AtlfastJets";
    m_cellLocation            = "/Event/AtlfastCells";
    m_imuonLocation           = "/Event/AtlfastIsolatedMuons";
    m_nimuonLocation          = "/Event/AtlfastNonIsolatedMuons";
    m_ielectronLocation       = "/Event/AtlfastIsolatedElectrons";
    m_nielectronLocation      = "/Event/AtlfastNonIsolatedElectrons";
    m_iphotonLocation         = "/Event/AtlfastIsolatedPhotons";
    m_niphotonLocation        = "/Event/AtlfastNonIsolatedPhotons";

    declareProperty( "clusterLocation",     m_clusterLocation ) ;
    declareProperty( "jetLocation",         m_jetLocation ) ;
    declareProperty( "cellLocation",        m_cellLocation ) ;
    declareProperty( "imuonLocation",       m_imuonLocation ) ;
    declareProperty( "nimuonLocation",      m_nimuonLocation ) ;
    declareProperty( "ielectronLocation",   m_ielectronLocation ) ;
    declareProperty( "nielectronLocation",  m_nielectronLocation ) ;    
    declareProperty( "iphotonLocation",     m_iphotonLocation ) ;
    declareProperty( "niphotonLocation",    m_niphotonLocation ) ;
    
  }
  
  
  IKinematicDumper::~IKinematicDumper() {} 
  
  
  //---------------------------------
  // initialise() 
  //---------------------------------
  
  StatusCode IKinematicDumper::initialize()
  {
    MsgStream log( messageService(), name() ) ;
    log<<MSG::DEBUG<<"Initialising "<<endreq;

    //get the Global Event Data using singleton pattern
    GlobalEventData* ged = GlobalEventData::Instance();
    // load the location of the MC in StoreGate
    m_mcLocation       = ged -> mcLocation();

    //set up TesIO
    //    m_tesIO = new TesIO(eventDataService());
    m_tesIO = new TesIO(m_mcLocation, ged->justHardScatter());
    
    return StatusCode::SUCCESS ;
  }
  
  //---------------------------------
  // finalise() 
  //---------------------------------
  
  StatusCode IKinematicDumper::finalize()
  {
    // .. put any finalisation in here...
    
    return StatusCode::SUCCESS ;
  }
  
  
  //----------------------------------------------
  // execute() method called once per event
  //----------------------------------------------
  //
  
  StatusCode IKinematicDumper::execute( )
  {
    //................................
    // make a message logging stream
    
    MsgStream log( messageService(), name() ) ;
    log<<MSG::DEBUG<<"Executing "<<endreq;
    

    std::vector<ReconstructedParticle*>::const_iterator rp_iter;

    //IsolatedPhotons: read from TES and dump
    std::vector<ReconstructedParticle*> iphotons;
    m_tesIO->copy<ReconstructedParticleCollection>(iphotons, m_iphotonLocation);
    std::sort(iphotons.begin(), iphotons.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  Isolated Photons "<<iphotons.size()<<std::endl;
    std::cout<<"--------------------------- "<<std::endl;    
    rp_iter = iphotons.begin();
    this->header();
    for(;rp_iter!=iphotons.end();++rp_iter) this->dump(*rp_iter);

    //NonIsolatedPhotons: read from TES and dump
    std::vector<ReconstructedParticle*> niphotons;
    m_tesIO->copy<ReconstructedParticleCollection> (niphotons, m_niphotonLocation);
    std::sort(niphotons.begin(), niphotons.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  NonIsolated Photons "<<niphotons.size()<<std::endl;
    std::cout<<"------------------------------ "<<std::endl;    
    rp_iter = niphotons.begin();
    this->header();
    for(;rp_iter!=niphotons.end();++rp_iter) this->dump(*rp_iter);
    
    //IsolatedElectrons: read from TES and dump
    std::vector<ReconstructedParticle*> ielectrons;
    m_tesIO->copy<ReconstructedParticleCollection>(ielectrons, m_ielectronLocation);
    std::sort(ielectrons.begin(), ielectrons.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  Isolated Electrons "<<ielectrons.size()<<std::endl;
    std::cout<<"--------------------------- "<<std::endl;    
    rp_iter = ielectrons.begin();
    this->header();
    for(;rp_iter!=ielectrons.end();++rp_iter) this->dump(*rp_iter);

    //NonIsolatedElectrons: read from TES and dump
    std::vector<ReconstructedParticle*> nielectrons;
    m_tesIO->copy<ReconstructedParticleCollection> (nielectrons, m_nielectronLocation);
    std::sort(nielectrons.begin(), nielectrons.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  NonIsolated Electrons "<<nielectrons.size()<<std::endl;
    std::cout<<"------------------------------ "<<std::endl;    
    rp_iter = nielectrons.begin();
    this->header();
    for(;rp_iter!=nielectrons.end();++rp_iter) this->dump(*rp_iter);
    


    //IsolatedMuons: read from TES and dump
    std::vector<ReconstructedParticle*> imuons;
    m_tesIO->copy<ReconstructedParticleCollection>(imuons, m_imuonLocation);
    std::sort(imuons.begin(), imuons.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  Isolated Muons "<<imuons.size()<<std::endl;
    std::cout<<"----------------------- "<<std::endl;    
    rp_iter = imuons.begin();
    this->header();
    for(;rp_iter!=imuons.end();++rp_iter) this->dump(*rp_iter);


    //    std::cout<<"Interface comparison "<<imuons.size()<<std::endl;
    //    std::cout<<"------------------- "<<std::endl;        
    //    for(rp_iter = imuons.begin(); rp_iter!=imuons.end(); ++rp_iter) {
    //      this->iki4comp(*rp_iter);
    //    }


    //NonIsolatedMuons: read from TES and dump
    std::vector<ReconstructedParticle*> nimuons;
    m_tesIO->copy<ReconstructedParticleCollection> (nimuons, m_nimuonLocation);
    std::sort(nimuons.begin(), nimuons.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  NonIsolated Muons "<<nimuons.size()<<std::endl;
    std::cout<<"-------------------------- "<<std::endl;    
    rp_iter = nimuons.begin();
    this->header();
    for(;rp_iter!=nimuons.end();++rp_iter) this->dump(*rp_iter);

    //    std::cout<<"Interface comparison "<<nimuons.size()<<std::endl;
    //    std::cout<<"------------------- "<<std::endl;        
    //    for(rp_iter = nimuons.begin(); rp_iter!=nimuons.end(); ++rp_iter) {
    //      this->iki4comp(*rp_iter);
    //    }

    //Clusters: read from TES and dump
    std::vector<ICluster*> clusters;
    m_tesIO->copy<IClusterCollection> (clusters, m_clusterLocation);
    std::sort(clusters.begin(), clusters.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  Clusters "<<clusters.size()<<std::endl;
    std::cout<<"------------------- "<<std::endl;    
    std::vector<ICluster*>::const_iterator cl_iter = clusters.begin();
    this->header();
    for(;cl_iter!=clusters.end();++cl_iter) this->dump(*cl_iter);


    //    std::cout<<"Interface comparison "<<clusters.size()<<std::endl;
    //    std::cout<<"------------------- "<<std::endl;        
    //    for(cl_iter = clusters.begin(); cl_iter!=clusters.end(); ++cl_iter) {
    //      this->iki4comp(*cl_iter);
    //    }



    //Jets: read from TES and dump
    std::vector<Jet*> jets;
    m_tesIO->copy<JetCollection>(jets, m_jetLocation);
    std::sort(jets.begin(), jets.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  Jets "<<jets.size()<<std::endl;
    std::cout<<"------------------- "<<std::endl;    
    std::vector<Jet*>::const_iterator jet_iter = jets.begin();
    this->header();
    for(;jet_iter!=jets.end();++jet_iter) this->dump(*jet_iter);

    //    std::cout<<"Interface comparison "<<jets.size()<<std::endl;
    //    std::cout<<"------------------- "<<std::endl;        
    //    for(jet_iter = jets.begin(); jet_iter!=jets.end(); ++jet_iter) {
    //      this->iki4comp(*jet_iter);
    //    }

    //Cells: read from TES and dump
    std::vector<ITwoCptCell*> cells;
    m_tesIO->copy<ITwoCptCellCollection>(cells, m_cellLocation);
    std::sort(cells.begin(), cells.end(), SortAttribute::AscendingEta());
    std::cout<<"Dumping  Cells "<<cells.size()<<std::endl;
    std::cout<<"------------------- "<<std::endl;    
    std::vector<ITwoCptCell*>::const_iterator cell_iter = cells.begin();
    this->header();
    for(;cell_iter!=cells.end();++cell_iter) this->dump(*cell_iter);

    //    std::cout<<"Interface comparison "<<cells.size()<<std::endl;
    //    std::cout<<"------------------- "<<std::endl;        
    //    for(cell_iter = cells.begin(); cell_iter!=cells.end(); ++cell_iter) {
    //      this->iki4comp(*cell_iter);
    //    }

    log<<MSG::INFO<<"End of execute "<<std::endl;    
    return StatusCode::SUCCESS;
  }
  
  void IKinematicDumper::header()const{
    cout<<"     eta      phi       pt        e"<<endl;
    cout<<"-----------------------------------"<<endl;
  }
  void IKinematicDumper::dump(const IKinematic* p)const{
    cout<<setiosflags(ios::fixed);
    cout<<std::setprecision(3);
    cout
        <<std::setw(8)<<std::setprecision(3)<<p->momentum().pseudoRapidity()<<" "
        <<std::setw(8)<<std::setprecision(3)<<p->momentum().phi()<<" "
        <<std::setw(8)<<std::setprecision(3)<<p->momentum().perp()<<" "
        <<std::setw(8)<<std::setprecision(3)<<p->momentum().e()<<" "
        <<endl;
  }
}  // end of namespace bracket

---