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.
//
// 
//
//
// Authors: Hywel Phillips
//          Peter Clarke
//          Peter Sherwood
//          Richard Steward
//          Elzbieta Richter-Was
//
// Created 22/08/2000
//
//**************************************************

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

#ifndef CLHEP_LORENTZVECTOR_H
#include "CLHEP/Vector/LorentzVector.h"
#define CLHEP_LORENTZVECTOR_H
#endif

#ifndef ATLFAST_MCWEIGHTCONTAINERCOLLECTION_H
#include "AtlfastEvent/MCweightContainerCollection.h"
#endif


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 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 double sumET,
                  const HepLorentzVector pEscaped,
                  const MCweightContainerCollection mcWeightContainers) :
        DataObject(),
        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_sumET(sumET),
        m_pEscaped(pEscaped),
        m_mcWeightContainers(mcWeightContainers)
 { };

      EventHeader() :
        DataObject(),
        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_sumET(0.),
        m_pEscaped(0.0,0.0,0.0,0.0),
        m_mcWeightContainers(MCweightContainerCollection()){};
      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 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; }
      double sumET()              const { return m_sumET; }
      HepLorentzVector pEscaped() const { return m_pEscaped; }
                                                  // includes neutrinos and LSP

      MCweightContainer firstFewWeights(int n) 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_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;
      double m_sumET;
      HepLorentzVector m_pEscaped;
      MCweightContainerCollection m_mcWeightContainers;
  };
  
  
}// end of namespace bracket
#endif

---