AtlfastDumper.cxx

Go to the documentation of this file.

// ================================================
//AtlfastDumper class Implementation
// ================================================
//
// Namespace Atlfast::
//
#include "AtlfastAlgs/AtlfastDumper.h"
#include "AtlfastEvent/CollectionDefs.h"
#include "AtlfastEvent/EventHeader.h"
#include "AtlfastAlgs/GlobalEventData.h"

#include <cmath> 
#include <algorithm>
#include <iomanip>
// Gaudi includes
#include "GaudiKernel/DataSvc.h"
#include "GaudiKernel/ISvcLocator.h"

#include <assert.h>
#include <cmath>
//--------------------------------
// Constructors and destructors
//--------------------------------

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

  AtlfastDumper::AtlfastDumper
  ( 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_jetBLocation            = "/Event/AtlfastBJets";
    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";
    m_coordinates             = "PxPyPzE";

    declareProperty( "clusterLocation",     m_clusterLocation ) ;
    declareProperty( "jetLocation",         m_jetLocation ) ;
    declareProperty( "jetBLocation",        m_jetBLocation ) ;
    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 ) ;
    declareProperty( "coordinates",         m_coordinates ) ;
    
    m_eventNo = 0;
  }
  
  
  AtlfastDumper::~AtlfastDumper() {} 
  



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


    MsgStream log( messageService(), name() ) ;
    log<<MSG::DEBUG<<"Initialising "<<endreq;
    //Helper class: IO from Transient store
    m_tesIO = new TesIO(m_mcLocation, ged->justHardScatter()); 
  
    return StatusCode::SUCCESS ;
  }
  
  //---------------------------------
  // finalise() 
  //---------------------------------
  
  StatusCode AtlfastDumper::finalize()
  {
    // .. put any finalisation in here...
    
    return StatusCode::SUCCESS ;
  }
  
  
  //----------------------------------------------
  // execute() method called once per event
  //----------------------------------------------
  //
  
  StatusCode AtlfastDumper::execute( )
  {
    //................................
    // make a message logging stream
    
    MsgStream log( messageService(), name() ) ;
    log<<MSG::DEBUG<<"Executing "<<endreq;
    
    ++m_eventNo;


    std::cout<<"------------ New Event "
             <<std::setw(8)<<m_eventNo<<" -----------"
             <<std::endl<<std::endl;

    //IsolatedPhotons: read from TES and dump
    std::vector<ReconstructedParticle*> iphotons;
    m_tesIO->copy<ReconstructedParticleCollection>(
                                                   iphotons, 
                                                   m_iphotonLocation
                                                   );

    this->sortAndDump(iphotons.begin(), iphotons.end(), m_iphotonLocation);
    //
    // NonIsolatedPhotons: read, sort and dump
    //
    std::vector<ReconstructedParticle*> niphotons;
    m_tesIO->copy<ReconstructedParticleCollection> (niphotons, 
                                                    m_niphotonLocation
                                                    );
    this->sortAndDump(niphotons.begin(), niphotons.end(), m_niphotonLocation);
    
    //
    // IsolatedElectrons: read, sort and dump
    //

    std::vector<ReconstructedParticle*> ielectrons;
    m_tesIO->copy<ReconstructedParticleCollection>(ielectrons, 
                                                   m_ielectronLocation
                                                   );
    this->sortAndDump(ielectrons.begin(), 
                      ielectrons.end(),
                      m_ielectronLocation 
                      );

    
    //
    // NonIsolatedElectrons: read, sort and dump
    //

    std::vector<ReconstructedParticle*> nielectrons;
    m_tesIO->copy<ReconstructedParticleCollection>(nielectrons, 
                                                   m_nielectronLocation
                                                   );
    this->sortAndDump(nielectrons.begin(), 
                      nielectrons.end(),
                      m_nielectronLocation );

    
    //
    // IsolatedMuons: read, sort and dump
    //

    std::vector<ReconstructedParticle*> imuons;
    m_tesIO->copy<ReconstructedParticleCollection>(imuons, 
                                                   m_imuonLocation
                                                   );

    this->sortAndDump(imuons.begin(), imuons.end(), m_imuonLocation );

    
    //
    // NonIsolatedMuons: read, sort and dump
    //

    std::vector<ReconstructedParticle*> nimuons;
    m_tesIO->copy<ReconstructedParticleCollection>(nimuons, 
                                                   m_nimuonLocation
                                                   );
    this->sortAndDump(nimuons.begin(), nimuons.end(), m_nimuonLocation );
    
    //
    // Clusters: read, sort and dump
    //

    std::vector<ICluster*> clusters;
    m_tesIO->copy<IClusterCollection>(clusters, m_clusterLocation);
    this->sortAndDump(clusters.begin(), clusters.end(), m_clusterLocation );

    //
    // Jets: read, sort and dump
    //

    std::vector<Jet*> jets;
    m_tesIO->copy<JetCollection>(jets, m_jetLocation);
    this->sortAndDump(jets.begin(), jets.end(), m_jetLocation );

    //
    // AtlfastB Jets: read, sort and dump
    //

    std::vector<Jet*> bjets;
    m_tesIO->copy<JetCollection>(bjets, m_jetBLocation);
    this->sortAndDump(bjets.begin(), bjets.end(), m_jetBLocation );

    //
    // ITwoCptCells: read, sort and dump
    //

    std::vector<ITwoCptCell*> cells;
    m_tesIO->copy<ITwoCptCellCollection>(cells, m_cellLocation);
    this->sortAndDump(cells.begin(), cells.end(), m_cellLocation );

    //
    // EventHeader: read  and dump
    //

    const EventHeader* eventHeader(0);
    m_tesIO->getDH(eventHeader);
    this->dumpEH(eventHeader);
  
    log<<MSG::INFO<<"End of execute "<<std::endl;    

    return StatusCode::SUCCESS;

  }
  void AtlfastDumper::dumpEH(const EventHeader* eventHeader)const{
    
    if(!eventHeader){
      std::cout<<"\n\n"<<std::string(73,' ')<<"EventHeader"<<std::endl;
    }else{
      std::cout<<"\n\n"
               <<"b, c tau Jets:     "  
               <<std::setw(6)<<eventHeader->nBJets()
               <<std::setw(6)<<eventHeader->nCJets()
               <<std::setw(6)<<eventHeader->nTauJets()
               <<std::string(36,' ')<<"EventHeader"<<std::endl;

      std::cout<<std::setprecision(3);
      std::cout
        <<"px, py Miss:       "  
        <<std::setw(12)<<eventHeader->pMiss().x()       
        <<std::setw(12)<<eventHeader->pMiss().y()
        <<std::string(30,' ')<<"EventHeader"<<std::endl;

      std::cout
        <<"px, py Escaped:    "  
        <<std::setw(12)<<eventHeader->pEscaped().x()    
        <<std::setw(12)<<eventHeader->pEscaped().y()
        <<std::string(30,' ')<<"EventHeader"<<std::endl;


      HepMC::WeightContainer weights = eventHeader->firstFewWeights(3);
      std::cout
        <<"weight1, 2, 3:     "  
        <<std::setw(12)<<weights[0]
        <<std::setw(12)<<weights[1]
        <<std::setw(12)<<weights[2]
        <<std::string(18,' ')<<"EventHeader"<<std::endl;
    }
  }
}  // end of namespace bracket

---