doc/html/PfoAnalysis_8h_source.html

 #ifndef PFO_ANALYSIS_H

 #define PFO_ANALYSIS_H 1


 #include "EVENT/LCStrVec.h"


 #include "marlin/Processor.h"


 #include "CalibrationHelper.h"


 #include <set>

 #include <vector>


 class TFile;

 class TH1F;

 class TTree;


 //------------------------------------------------------------------------------------------------------------------------------------------


 class PfoAnalysis : public marlin::Processor

 {

 public:

     PfoAnalysis();


     virtual Processor *newProcessor();


     virtual void init();


     virtual void processRunHeader(lcio::LCRunHeader *pLCRunHeader);


     virtual void processEvent(EVENT::LCEvent *pLCEvent);


     virtual void check(EVENT::LCEvent *pLCEvent);


     virtual void end();


 private:

     typedef std::vector<const EVENT::ReconstructedParticle *> ParticleVector;

     typedef std::vector<const EVENT::MCParticle*> MCParticleVector;

     typedef std::set<const EVENT::MCParticle*> MCParticleList;

     typedef std::vector<std::string> StringVector;


     void Clear();


     void ExtractCollections(EVENT::LCEvent *pLCEvent);


     void ApplyPfoSelectionRules(const EVENT::MCParticle *pMCParticle, MCParticleList &mcPfoCandidates) const;


     void MakeQuarkVariables(EVENT::LCEvent *pLCEvent);


     void PerformPfoAnalysis();


     static bool SortPfoTargetsByEnergy(const EVENT::MCParticle *const pLhs, const EVENT::MCParticle *const pRhs);


     int                 m_nRun;

     int                 m_nEvt;


     int                 m_nRunSum;

     int                 m_nEvtSum;


     std::string         m_inputPfoCollection;

     std::string         m_mcParticleCollection;


     int                 m_printing;

     std::string         m_rootFile;


     int                 m_lookForQuarksWithMotherZ;


     float               m_mcPfoSelectionRadius;

     float               m_mcPfoSelectionMomentum;

     float               m_mcPfoSelectionLowEnergyNPCutOff;


     ParticleVector      m_pfoVector;

     MCParticleVector    m_pfoTargetVector;


     int                 m_nPfosTotal;

     int                 m_nPfosNeutralHadrons;

     int                 m_nPfosPhotons;

     int                 m_nPfosTracks;

     float               m_pfoEnergyTotal;

     float               m_pfoEnergyNeutralHadrons;

     float               m_pfoEnergyPhotons;


     float               m_pfoEnergyTracks;

     float               m_pfoECalToEmEnergy;

     float               m_pfoECalToHadEnergy;

     float               m_pfoHCalToEmEnergy;

     float               m_pfoHCalToHadEnergy;

     float               m_pfoMuonToEnergy;

     float               m_pfoOtherEnergy;


     float               m_pfoMassTotal;


     typedef std::vector<float> FloatVector;

     FloatVector         m_pfoEnergies;

     FloatVector         m_pfoPx;

     FloatVector         m_pfoPy;

     FloatVector         m_pfoPz;

     FloatVector         m_pfoCosTheta;


     FloatVector         m_pfoTargetEnergies;

     FloatVector         m_pfoTargetPx;

     FloatVector         m_pfoTargetPy;

     FloatVector         m_pfoTargetPz;

     FloatVector         m_pfoTargetCosTheta;


     typedef std::vector<int> IntVector;

     IntVector           m_pfoPdgCodes;

     IntVector           m_pfoTargetPdgCodes;


     int                 m_nPfoTargetsTotal;

     int                 m_nPfoTargetsNeutralHadrons;

     int                 m_nPfoTargetsPhotons;

     int                 m_nPfoTargetsTracks;


     float               m_pfoTargetsEnergyTotal;

     float               m_pfoTargetsEnergyNeutralHadrons;

     float               m_pfoTargetsEnergyPhotons;

     float               m_pfoTargetsEnergyTracks;


     float               m_mcEnergyENu;

     float               m_mcEnergyFwd;

     float               m_eQQ;

     float               m_eQ1;

     float               m_eQ2;

     float               m_costQQ;

     float               m_costQ1;

     float               m_costQ2;

     float               m_mQQ;

     float               m_thrust;

     int                 m_qPdg;


     TFile              *m_pTFile;

     TTree              *m_pTTree;

     TH1F               *m_hPfoEnergySum;

     TH1F               *m_hPfoEnergySumL7A;


     int                                             m_collectCalibrationDetails;

     pandora_analysis::CalibrationHelper            *m_pCalibrationHelper;

     pandora_analysis::CalibrationHelper::Settings   m_calibrationHelperSettings;

 };


 //------------------------------------------------------------------------------------------------------------------------------------------


 inline marlin::Processor *PfoAnalysis::newProcessor()

 {

     return new PfoAnalysis;

 }


 #endif // #ifndef PFO_ANALYSIS_H

PfoAnalysis::end
virtual void end()
End, called at shutdown.
Definition: PfoAnalysis.cc:320

PfoAnalysis::PfoAnalysis
PfoAnalysis()
Default constructor.
Definition: PfoAnalysis.cc:29

pandora_analysis::CalibrationHelper
CalibrationHelper class.
Definition: CalibrationHelper.h:29

PfoAnalysis::processEvent
virtual void processEvent(EVENT::LCEvent *pLCEvent)
Process event, main entry point.
Definition: PfoAnalysis.cc:292

PfoAnalysis::processRunHeader
virtual void processRunHeader(lcio::LCRunHeader *pLCRunHeader)
Process run header.
Definition: PfoAnalysis.cc:283

pandora_analysis::CalibrationHelper::Settings
Settings class.
Definition: CalibrationHelper.h:35

PfoAnalysis::check
virtual void check(EVENT::LCEvent *pLCEvent)
Checks for event.
Definition: PfoAnalysis.cc:314

PfoAnalysis::init
virtual void init()
Initialize, called at startup.
Definition: PfoAnalysis.cc:204

PfoAnalysis::newProcessor
virtual Processor * newProcessor()
Create new processor.
Definition: PfoAnalysis.h:210

PfoAnalysis
PfoAnalysis class.
Definition: PfoAnalysis.h:30