ReconstructedParticleDumper.cxx

Go to the documentation of this file.

// ================================================
//ReconstructedParticleDumper class Implementation
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
// Namespace Atlfast::
//

// This algorithm includes
#include "AtlfastAlgs/ReconstructedParticleDumper.h"
#include "AtlfastEvent/ReconstructedParticle.h"
#include "AtlfastEvent/Cluster.h"
#include "AtlfastEvent/MsgStreamDefs.h"
#include "AtlfastEvent/CollectionDefs.h"
#include "AtlfastEvent/TypeVisitor.h"
#include "AtlfastEvent/SimpleAssocsDispatcher.h"
//#include "AtlfastAlgs/AssocTypeRecoverer.h"
#include "AtlfastAlgs/GlobalEventData.h"

#include <cmath> 
#include <algorithm>

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

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

namespace Atlfast {
  ReconstructedParticleDumper::ReconstructedParticleDumper
  ( const std::string& name, ISvcLocator* pSvcLocator ) 
    : Algorithm( name, pSvcLocator ){
    
    
    // Default paths for entities in the TES
    m_inputLocation    = "/Event/Atlfast/ReconstructedParticle";
    
    m_writePDG        = true;
    m_writeFourVector = true;
    m_writeEta        = true;
    m_writePhi        = true;
    m_writePt         = true;
    m_writeEt         = false;
    m_writeMt         = false;
    m_writeTruth      = true;
    
    declareProperty( "InputLocation", m_inputLocation ) ;
    
    declareProperty( "WritePDG", m_writePDG );
    declareProperty( "WriteFourVector", m_writeFourVector );
    declareProperty( "WriteEta", m_writeEta );
    declareProperty( "WritePhi", m_writePhi );
    declareProperty( "WritePt", m_writePt );
    declareProperty( "WriteEt", m_writeEt );
    declareProperty( "WriteMt", m_writeMt );
    declareProperty( "WriteTruth", m_writeTruth );
    
  }
  
  
  ReconstructedParticleDumper::~ReconstructedParticleDumper() {} 
  
  
  //---------------------------------
  // initialise() 
  //---------------------------------
  
  StatusCode ReconstructedParticleDumper::initialize(){
    //MsgStream log( messageService(), name() ) ;
    
    // .. put any initialisation in here...
    
    // will need to build an appropriate smearer object here
    // when tools become avialble we will instead just pass an appropriate
    // tool via job options

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

    
    //  m_tesIO = new TesIO(eventDataService());
    m_tesIO = new TesIO(m_mcLocation, ged->justHardScatter());
    
    return StatusCode::SUCCESS ;
  }
  
  //---------------------------------
  // finalise() 
  //---------------------------------
  
  StatusCode ReconstructedParticleDumper::finalize(){
    // .. put any finalisation in here...
    
    return StatusCode::SUCCESS ;
  }
  
  
  //----------------------------------------------
  // execute() method called once per event
  //----------------------------------------------
  //
  
  StatusCode ReconstructedParticleDumper::execute( ){
    //................................
    // make a message logging stream
    
    MsgStream log( messageService(), name() ) ;
    
    //.............................
    // Make some locals stores which be used to keep pointers to
    // all of the entities from the event store which are needed by
    // this algorithm. These are all local and are typedefed in this class
    
    //t_reconstructedParticleCollection  myParticles ;
    //...............................
    // Extract the input particles which are to be tested for isolation.
    
    
    std::vector<ReconstructedParticle*> particles;
    if(!m_tesIO->copy<ReconstructedParticleCollection >
       (particles, m_inputLocation)){
      log << MSG::INFO 
          << "No reconstructed particles in TES at " 
          << m_inputLocation 
          << endreq ;
      return StatusCode::FAILURE ;
    }
    log << MSG::INFO << particles.size()  
        << " Reconstructed particles retrieved from TES at " 
        << m_inputLocation 
        << endreq;
    
    
    
    int count = 0;
    std::vector<ReconstructedParticle*>::const_iterator particle  = 
      particles.begin();
    for (; particle != particles.end(); ++particle) {
      count++;
      log << MSG::INFO << count;
      if (m_writePDG) {
        log << " PDG " << (*particle)->pdg_id();
      }
      if (m_writeFourVector) {
        log << " px " << (*particle)->momentum().px() 
            << " py " << (*particle)->momentum().py()
            << " pz " << (*particle)->momentum().pz()
            << " e  " << (*particle)->momentum().e();
      }
      if (m_writeEta) {
        log << " eta " << (*particle)->eta();
      }
      if (m_writePhi) {
        log << " phi " << (*particle)->phi();
      }
      if (m_writePt) {
        log << " pt " << (*particle)->pT();
      }
      if (m_writeEt) {
        log << " et " << (*particle)->eT();
      }
      if (m_writeMt) {
        log << " mt " << (*particle)->mT();
      }
      if (m_writeTruth) {
        log << " MC truth " << (*particle)->truth()->momentum();
      }
      
      log << endreq;
      
      // Now print any associations
      TypeVisitor tv = SimpleAssocsDispatcher( *particle, TypeVisitor());
      Cluster c;
      log << "     it has " << (tv.typeVector( Cluster() )).size() 
          << " associated clusters " << endreq;
      /*      
      std::vector<IAOO*> v;
      v.push_back(*particle);
      AssocTypeRecoverer atr(v.begin(), v.end());
      Cluster c;
      log << "     it has " << (atr.typeVector( c ))->size() 
          << " associated clusters " << endreq;
      */
    }
    
    return StatusCode::SUCCESS;
  }
  
}  // end of namespace bracket

---