StandardHistogramMaker.h

Go to the documentation of this file.

// ================================================
//StandardHistogramMaker class description
// ================================================
//
// THIS TEXT TO BE REPLACED BY ATLAS STANDARD FORMAT
//
//
// This version....
//
//
// Namespace Atlfast::
//
// class: StandardHistogramMaker
//
// Description: 
//
//  Algorithm which makes some standard Atlfast debug histograms
//
//
// ................................................................
//

#ifndef ATLFAST_STANDARDHISTOGRAMMAKER_H
#define ATLFAST_STANDARDHISTOGRAMMAKER_H

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

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

#include "AIDA/IHistogram1D.h"

// Other
#include "CLHEP/Vector/LorentzVector.h"
#include "HepMC/GenEvent.h"
#include "HepMC/GenParticle.h"

// Atlfast
//#include "AtlfastEvent/ReconstructedParticle.h"
#include "AtlfastEvent/IKinematic.h"
#include "AtlfastUtils/TesIO.h"

//***************************************************************
//                 StandardHistogramMaker class declaration
//
// A "Gaudi algorithm" is something which gets scheduled and controlled
// by the framework. In its simplest definition it is something which
//  - gets clled for each event 
//  - can get anything it wants out of the Transient Event Store"
//  - can put anything it makes into the store.
//
// It must inherit from the  Algorithm base class
//****************************************************************
 
namespace Atlfast {
  using std::string;
class StandardHistogramMaker : public Algorithm
{

 public:

  //-------------------------
  // Constructors/Destructors
  //
  // Gaudi requires that the constructor takes certain arguments
  // (and passes them directly to the constructor of the base class)
  //-------------------------

  StandardHistogramMaker( const std::string& name, ISvcLocator* pSvcLocator ) ; 
  ~StandardHistogramMaker();


  //------------------------------------------------------
  // Methods used by Gaudi to run the algorithm
  //------------------------------------------------------

  StatusCode initialize() ;
  StatusCode execute() ;
  StatusCode finalize() ;



 private:


  //-------------------------------
  // Private methods
  //-------------------------------
 
  void bookNonIsolatedElectronHistograms();
  void bookNonIsolatedPhotonHistograms();
  void bookNonIsolatedMuonHistograms();
  void bookIsolatedElectronHistograms();
  void bookIsolatedPhotonHistograms();
  void bookIsolatedMuonHistograms();
  void bookCellHistograms();
  void bookClusterHistograms();
  void bookJetHistograms();
  void bookEventHeaderHistograms();

  template<class Collection>
    void kinHistogramFiller(const std::string&,
                            IHistogram1D*,
                            IHistogram1D*,
                            IHistogram1D*,
                            IHistogram1D*,
                            IHistogram1D*,
                            IHistogram1D*
                            ) ;

  TesIO* m_tesIO;
  //holds the Stotegate MC location
  std::string m_mcLocation;


  // 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_isolatedElectronLocation;
  std::string m_photonLocation ;
  std::string m_isolatedPhotonLocation;
  std::string m_muonLocation ;
  std::string m_isolatedMuonLocation;
  std::string m_cellLocation;
  std::string m_clusterLocation;
  std::string m_jetLocation;
  std::string m_eventHeaderLocation;
  std::string m_mcTruthLocation;


  // The following are the actual histograms
  // htp has added his own naming convention here
  // m_h_ means a histogram!

  // electron histograms
  IHistogram1D* m_h_electronMultiplicity;
  IHistogram1D* m_h_electronPx;
  IHistogram1D* m_h_electronPy;
  IHistogram1D* m_h_electronPz;
  IHistogram1D* m_h_electronE;
  IHistogram1D* m_h_electronPt;

  // isolatedElectron histograms
  IHistogram1D* m_h_isolatedElectronMultiplicity;
  IHistogram1D* m_h_isolatedElectronPx;
  IHistogram1D* m_h_isolatedElectronPy;
  IHistogram1D* m_h_isolatedElectronPz;
  IHistogram1D* m_h_isolatedElectronE;
  IHistogram1D* m_h_isolatedElectronPt;

  // photon histograms
  IHistogram1D* m_h_photonMultiplicity;
  IHistogram1D* m_h_photonPx;
  IHistogram1D* m_h_photonPy;
  IHistogram1D* m_h_photonPz;
  IHistogram1D* m_h_photonE;
  IHistogram1D* m_h_photonPt;

  // isolatedPhoton histograms
  IHistogram1D* m_h_isolatedPhotonMultiplicity;
  IHistogram1D* m_h_isolatedPhotonPx;
  IHistogram1D* m_h_isolatedPhotonPy;
  IHistogram1D* m_h_isolatedPhotonPz;
  IHistogram1D* m_h_isolatedPhotonE;
  IHistogram1D* m_h_isolatedPhotonPt;

  // muon histograms
  IHistogram1D* m_h_muonMultiplicity;
  IHistogram1D* m_h_muonPx;
  IHistogram1D* m_h_muonPy;
  IHistogram1D* m_h_muonPz;
  IHistogram1D* m_h_muonE;
  IHistogram1D* m_h_muonPt;

  // isolatedMuon histograms
  IHistogram1D* m_h_isolatedMuonMultiplicity;
  IHistogram1D* m_h_isolatedMuonPx;
  IHistogram1D* m_h_isolatedMuonPy;
  IHistogram1D* m_h_isolatedMuonPz;
  IHistogram1D* m_h_isolatedMuonE;
  IHistogram1D* m_h_isolatedMuonPt;

  // cell histograms
  IHistogram1D* m_h_cellMultiplicity;
  IHistogram1D* m_h_cellPx;
  IHistogram1D* m_h_cellPy;
  IHistogram1D* m_h_cellPz;
  IHistogram1D* m_h_cellE;
  IHistogram1D* m_h_cellPt;


  // cluster histograms
  IHistogram1D* m_h_clusterMultiplicity;
  IHistogram1D* m_h_clusterPx;
  IHistogram1D* m_h_clusterPy;
  IHistogram1D* m_h_clusterPz;
  IHistogram1D* m_h_clusterE;
  IHistogram1D* m_h_clusterPt;

  // jet histograms
  IHistogram1D* m_h_jetMultiplicity;
  IHistogram1D* m_h_jetPx;
  IHistogram1D* m_h_jetPy;
  IHistogram1D* m_h_jetPz;
  IHistogram1D* m_h_jetE;
  IHistogram1D* m_h_jetPt;

  // EventHeader histograms
  IHistogram1D* m_h_njetb;
  IHistogram1D* m_h_njetc;
  IHistogram1D* m_h_njettau;
  IHistogram1D* m_h_pxmiss;
  IHistogram1D* m_h_pymiss;
  IHistogram1D* m_h_pxnue;
  IHistogram1D* m_h_pynue;
  IHistogram1D* m_h_mcWeight0;
  IHistogram1D* m_h_mcWeight1;
  IHistogram1D* m_h_mcWeight2;



  // histogram numbers, start at...
  int m_histStart;
  // and current count
  int m_nHist;
};

 class FillKHist{
 public:
   FillKHist(IHistogram1D* hpx, 
             IHistogram1D* hpy, 
             IHistogram1D* hpz, 
             IHistogram1D* he, 
             IHistogram1D* hpt
             ):
     m_hpx(hpx), m_hpy(hpy), m_hpz(hpz), m_he(he), m_hpt(hpt){
   }

   template<class T> 
     void operator()(T* tt){
     
     //concrete classs private inheritance forces use through interface.
     IKinematic* t = tt; 
     m_hpx->fill(float( t->px()), 1.0);
     m_hpy->fill(float( t->py()), 1.0);
     m_hpz->fill(float( t->pz()), 1.0);
     m_he ->fill(float( t->e()),  1.0);
     m_hpt->fill(float( t->pT()), 1.0);
   }
 private:
   IHistogram1D* m_hpx;
   IHistogram1D* m_hpy;
   IHistogram1D* m_hpz;
   IHistogram1D* m_he;
   IHistogram1D* m_hpt;
 };

template<class Collection>
  inline 
  void StandardHistogramMaker::kinHistogramFiller(
                                                  const std::string& location,
                                                  IHistogram1D* hmul,
                                                  IHistogram1D* hpx,
                                                  IHistogram1D* hpy,
                                                  IHistogram1D* hpz,
                                                  IHistogram1D* he,
                                                  IHistogram1D* hpt
                                                  
                                                  ) {
  
  MsgStream log( messageService(), name() ) ;
  log << MSG::DEBUG << "Getting Particles from  "<<location << endreq;
  
  const Collection* rps;

  if(!m_tesIO->getDH(rps, location)){
    log << MSG::DEBUG << "no rps found in the TES at "<<location << endreq; 

    // fill any histograms that have meaning in the absence of rps

    hmul->fill(0.0,1.0);
  } else {
    // fill all histograms
    hmul->fill(float(rps->size()),1.0);
    std::for_each(rps->begin(), rps->end(), FillKHist(hpx, hpy, hpz, he, hpt));
  }
  return;
}


} // end of namespace bracket

#endif

---