---

EventHeader.h

Go to the documentation of this file.

#ifndef ATLFAST_EVENTHEADER_H
#define ATLFAST_EVENTHEADER_H

//**************************************************
//
// Atlfast Event Header class
//
// Contains infomation on the whole Event, such as
// event shape variables and missing momentum.
//
// Also summarises the number of various particles
// found in the event, for rapid event selection in
// user analysis code.
//
// At present this class is just a big "bag" of
// possibly useful numbers to be stored on the TES.
//
// Some more thought and development of the header will
// come in the future - eg should it summarise the
// Atlfast final output lists? Should it have
// SmartRef's to them? This may become important for
// Persistency later on...
//
// 
//
//
// Authors: Hywel Phillips
//          Peter Clarke
//          Peter Sherwood
//          Richard Steward
//          Elzbieta Richter-Was
//
// Created 22/08/2000
//
//**************************************************

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

#include "CLHEP/Vector/LorentzVector.h"
class MsgStream;


//Class ID for EventHeader class
static const CLID CLID_ATLFAST_EVENT_HEADER=2303 ;



namespace Atlfast {

  class EventHeader;

  MsgStream& operator<<(MsgStream&, const EventHeader&);
  MsgStream& operator<<(MsgStream&, const EventHeader* const );

  class EventHeader : public DataObject {
  
    public:

      //
      // constructors, desctructors and operators
      //
      EventHeader(
                  const int runNumber,
                  const int evtNumber,
                  const int nElectrons, 
                  const int nIsolatedMuons, 
                  const int nNonIsolatedMuons,
                  const int nPhotons,   
                  const int nJets, 
                  const int nBJets, 
                  const int nCJets,     
                  const int nTauJets, 
                  const double jetCircularity,
                  const double eventCircularity, 
                  const double thrust, 
                  const double oblateness,
                  const HepLorentzVector pMiss, 
                  const HepLorentzVector pEscaped) :
        DataObject(),
        m_runNumber(runNumber),
        m_evtNumber(evtNumber),
        m_nElectrons(nElectrons), 
        m_nIsolatedMuons(nIsolatedMuons),
        m_nNonIsolatedMuons(nNonIsolatedMuons), 
        m_nPhotons(nPhotons),
        m_nJets(nJets), 
        m_nBJets(nBJets), 
        m_nCJets(nCJets),
        m_nTauJets(nTauJets), 
        m_jetCircularity(jetCircularity),
        m_eventCircularity(eventCircularity), 
        m_thrust(thrust), 
        m_oblateness(oblateness), 
        m_pMiss(pMiss), 
        m_pEscaped(pEscaped) { };

      EventHeader() :
        DataObject(),
        m_runNumber(0), 
        m_evtNumber(0), 
        m_nElectrons(0), 
        m_nIsolatedMuons(0),
        m_nNonIsolatedMuons(0), 
        m_nPhotons(0),          
        m_nJets(0), 
        m_nBJets(0), 
        m_nCJets(0),
        m_nTauJets(0), 
        m_jetCircularity(0.0),
        m_eventCircularity(0.0), 
        m_thrust(0.0), 
        m_oblateness(0.0), 
        m_pMiss(0.0,0.0,0.0,0.0), 
        m_pEscaped(0.0,0.0,0.0,0.0) { };
      virtual ~EventHeader() { };
      
      //
      // the default copy constructor and assignment operator should be fine
      // so we don't need this...
      //EventHeader(const EventHeader &rhs);
      //EventHeader& operator=(const EventHeader &rhs);

      //
      int runNumber()      const { return m_runNumber; }
      int evtNumber()      const { return m_evtNumber; }
      int nElectrons()     const { return m_nElectrons; }
      int nIsolatedMuons() const { return m_nIsolatedMuons; }
      int nMuons()         const {return m_nIsolatedMuons+m_nNonIsolatedMuons;}
      int nNonIsolatedMuons() const { return m_nNonIsolatedMuons; }
      int nPhotons()          const { return m_nPhotons; }

      //Numbers of Jets:
      int nJets()    const { return m_nJets; }         // total
      int nBJets()   const { return m_nBJets; }       // b-jet candidates
      int nCJets()   const { return m_nCJets; }       // c-jet candidates
      int nTauJets() const { return m_nTauJets; }   // tau jet candidates

      // Event shapes 
      double jetCircularity()     const {return m_jetCircularity;}
      double eventCircularity()   const { return m_eventCircularity; }
      double thrust()             const { return m_thrust; }
      double oblateness()         const { return m_oblateness; }
      HepLorentzVector pMiss()    const { return m_pMiss; }
      HepLorentzVector pEscaped() const { return m_pEscaped; }
                                                  // includes neutrinos and LSP
      virtual StreamBuffer& serialize(StreamBuffer& s);

      virtual StreamBuffer& serialize(StreamBuffer& s) const;

      //.........................
      // Athena mandatory methods
      // htp FIXME check the const's 
      //
      static const CLID& classID() { return CLID_ATLFAST_EVENT_HEADER; }
      virtual const CLID& clID() const {  return CLID_ATLFAST_EVENT_HEADER; }
 

    private:
      
      int m_runNumber;
      int m_evtNumber;
      int m_nElectrons;
      int m_nIsolatedMuons;
      int m_nNonIsolatedMuons;
      int m_nPhotons;
      int m_nJets;
      int m_nBJets;
      int m_nCJets;
      int m_nTauJets;
      double m_jetCircularity;
      double m_eventCircularity;
      double m_thrust;
      double m_oblateness;
      HepLorentzVector m_pMiss;
      HepLorentzVector m_pEscaped;

  };
  
  
}// end of namespace bracket
#endif

---