---

EventHeaderMaker.h

Go to the documentation of this file.

// ================================================
// EventHeaderMaker class description
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
//
// This version....
//
//
// Namespace Atlfast::
//
// class: EventHeaderMaker
//
// Description: 
//
//  Algorithm which makes the Atlfast Event Header
//  This must be run as the final algorithm in the 
//  Atlfast suite as it requires the information from
//  all the earlier makers.
//
//
// ................................................................
//

#ifndef ATLFAST_EVENTHEADERMAKER_H
#define ATLFAST_EVENTHEADERMAKER_H

// STL
#include <string>
//#include <iterator>
#include <vector>

// Gaudi 
#include "GaudiKernel/Algorithm.h"
//#include "GaudiKernel/DataObject.h"

// Other
#include "CLHEP/Vector/LorentzVector.h"

// Atlfast
#include "AtlfastEvent/Jet.h"          //no forward dec: used in inline function
#include "AtlfastUtils/TesIO.h"        //no forward dec: used in inline function

#ifndef ATLFAST_COLLECTIONDEFS_H
#include "AtlfastEvent/CollectionDefs.h"
#endif

class ISvcLocator;
class MsgStream;
namespace HepMC_helper{
  class IMCselector;
}
namespace Atlfast {
  class TesIO;
  class Jet;
  using std::string;
  class EventHeaderMaker : public Algorithm{
    
  public:
    
    //-------------------------
    // Constructors/Destructors
    //
    // Gaudi requires that the constructor takes certain arguments
    // (and passes them directly to the constructor of the base class)
    //-------------------------
    EventHeaderMaker( const std::string& name, ISvcLocator* pSvcLocator ) ; 
    virtual ~EventHeaderMaker();
    
    
    //------------------------------------------------------
    // Methods used by Gaudi to run the algorithm
    //------------------------------------------------------
    
    StatusCode initialize() ;
    StatusCode execute() ;
    StatusCode finalize() ;
    
    
    
  private:
    
    
    //-------------------------------
    // Private methods
    //-------------------------------
    
    template <class Collection> int numberInList(std::string tesAddress);
    int numberJetFlavor(std::string tesAddress, int);
    HepLorentzVector missingMomentum(MsgStream&);
    HepLorentzVector escapedMomentum(MsgStream&);
    template <class Collection> 
      HepLorentzVector momentumSum(std::string tesAddress);
    template <class Type> 
      HepLorentzVector smearAndSum(std::string tesAddress, Type dummy);
    template <class Collection, class AssType> 
      HepLorentzVector assocMomentumSum(std::string tesAddress);
    HepLorentzVector unusedClusterSum(); 
    HepLorentzVector unusedMuonSum();    
    HepLorentzVector unusedCellSum();    
    
    
    //-------------------------------
    // Data members
    //-------------------------------
    
    // the following data members tell the
    // algorithm where to retrieve its input particles from
    // in the TES. These are written by the job Options service.
    std::string m_electronLocation ;
    std::string m_photonLocation ;
    std::string m_isolatedMuonLocation;
    std::string m_nonIsolatedMuonLocation;
    std::string m_jetLocation;
    std::string m_cellLocation;
    std::string m_clusterLocation;
    std::string m_mcTruthLocation;
    std::string m_outputLocation;
    std::string m_missingMomentumLocation;
    
    
    bool m_testMode;
    double m_beamEnergy; // beam energy in GeV
    std::vector <int> m_escapingParticles; // PDG ids for escaping particles
    
    
    int           m_lumi;
    
    //htp random number seed will need to be removed eventually
    //    currently used to set up Smearer's random number seed
    //    SHOULD BE REPLACED BY FRAMEWORK SERVICE!! 
    double        m_barrelForwardEta;
    
    TesIO*        m_tesIO;
    HepMC_helper::IMCselector*  m_visibleToAtlas;
  };

  //-------------------------------------------------------
  // numberInList
  //-------------------------------------------------------
  template <class Collection> inline 
    int EventHeaderMaker::numberInList(std::string tesAddress) {
    DataHandle<Collection> dh;
    if( !m_tesIO->getDH(dh, tesAddress) ) throw "Error in numberInList";
    return dh->size();
    //    Collection aList;
    //    if( !m_tesIO->copy<(aList, tesAddress) ) throw "Error in numberInList";
    //if( !m_tesIO->get(aList) ) throw "Error in numberInList";
    //    return aList.size();
  }
  
  //-------------------------------------------------------
  // numberJetFlavor
  //-------------------------------------------------------
  inline
    int EventHeaderMaker::numberJetFlavor(
                                          std::string tesAddress, 
                                          int flavor) {
    std::vector<Jet*> theJets;
    int temp=0;
    if(m_tesIO->copy<JetCollection >(theJets, tesAddress)){
      //if(m_tesIO->get(theJets)){
      std::vector<Jet*>::const_iterator jet  = theJets.begin();
      for (; jet != theJets.end(); ++jet) {
        if( (*jet)->pdg_id()==flavor ) ++temp;
      }
    }
    return temp;
  }
  
  //-------------------------------------------------------
  // momentumSum
  //-------------------------------------------------------
  template <class Collection> inline HepLorentzVector
    EventHeaderMaker::momentumSum(std::string tesAddress) {
    //
    //    Collection aList;
    //
    //    if(!m_tesIO->copy
    //       <Collection, 
    //       Collection> 
    //   (aList, tesAddress) ){throw "Error in momentumSum";
    //    }
    //
    //    HepLorentzVector temp(0.0,0.0,0.0,0.0);
    //    typename Collection::const_iterator iter = aList.begin();
    //
    //    for (; iter != aList.end(); ++iter) temp += (*iter)->momentum();
    HepLorentzVector temp(0.0,0.0,0.0,0.0);

    DataHandle<Collection> dh;
    if( !m_tesIO->getDH(dh, tesAddress) ) throw "Error in numberInList";

    typename Collection::const_iterator iter = dh->begin();
    typename Collection::const_iterator end  = dh->end();

    for (; iter != end; ++iter) temp += (*iter)->momentum();
    
    return temp;
  }
  
  //-------------------------------------------------------
  // assocMomentumSum
  //-------------------------------------------------------
  template <class Collection, class AssType> inline HepLorentzVector 
    EventHeaderMaker::assocMomentumSum(std::string tesAddress) {
    
    HepLorentzVector temp(0.0,0.0,0.0,0.0);

    DataHandle<Collection> dh;
    if( !m_tesIO->getDH(dh, tesAddress) ) throw "Error in assocMomentumSum";

    typename Collection::const_iterator iter = dh->begin();
    typename Collection::const_iterator end  = dh->end();

    for (; iter != end; ++iter){
      IAssociationManager* ia  = *iter;
      AssType assType;
      std::vector<const AssType*> aList  = ia->associations(assType);
      typename std::vector<const AssType*>::const_iterator aIter = aList.begin();
      for(; aIter<aList.end(); ++aIter) temp+=(*aIter)->momentum();
    }
    return temp;  
  }
} // end of namespace bracket

#endif

---