TrackingTruthAccumulator.h

Go to the documentation of this file.

#ifndef TrackingAnalysis_TrackingTruthAccumulator_h
#define TrackingAnalysis_TrackingTruthAccumulator_h
 
#include "FWCore/Framework/interface/ProducesCollector.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingVertexContainer.h"
#include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h"
#include "SimTracker/Common/interface/TrackingParticleSelector.h"
#include <memory>  // required for std::unique_ptr
 
// Forward declarations
namespace edm {
  class ParameterSet;
  class ConsumesCollector;
  class Event;
  class EventSetup;
  class StreamID;
}  // namespace edm
class PileUpEventPrincipal;
class PSimHit;
 
class TrackingTruthAccumulator : public DigiAccumulatorMixMod {
public:
  explicit TrackingTruthAccumulator(const edm::ParameterSet &config,
                                    edm::ProducesCollector,
                                    edm::ConsumesCollector &iC);
 
private:
  void initializeEvent(const edm::Event &event, const edm::EventSetup &setup) override;
  void accumulate(const edm::Event &event, const edm::EventSetup &setup) override;
  void accumulate(const PileUpEventPrincipal &event, const edm::EventSetup &setup, edm::StreamID const &) override;
  void finalizeEvent(edm::Event &event, const edm::EventSetup &setup) override;
 
  template <class T>
  void accumulateEvent(const T &event,
                       const edm::EventSetup &setup,
                       const edm::Handle<edm::HepMCProduct> &hepMCproduct);
 
  template <class T>
  void fillSimHits(std::vector<const PSimHit *> &returnValue, const T &event, const edm::EventSetup &setup);
 
  const std::string messageCategory_;  
 
  const double volumeRadius_;
  const double volumeZ_;
  const double vertexDistanceCut_;
  const bool ignoreTracksOutsideVolume_;
 
  const unsigned int maximumPreviousBunchCrossing_;
  const unsigned int maximumSubsequentBunchCrossing_;
  const bool createUnmergedCollection_;
  const bool createMergedCollection_;
  const bool createInitialVertexCollection_;
  const bool addAncestors_;
 
  const bool removeDeadModules_;
  const edm::InputTag simTrackLabel_;
  const edm::InputTag simVertexLabel_;
  std::vector<edm::InputTag> collectionTags_;
  edm::InputTag genParticleLabel_;
  edm::InputTag hepMCproductLabel_;
 
  bool selectorFlag_;
  TrackingParticleSelector selector_;
  bool chargedOnly_;
  bool signalOnly_;
 
  bool allowDifferentProcessTypeForDifferentDetectors_;
 
public:
  // These always go hand in hand, and I need to pass them around in the
  // internal functions, so I might as well package them up in a struct.
  struct OutputCollections {
    std::unique_ptr<TrackingParticleCollection> pTrackingParticles;
    std::unique_ptr<TrackingVertexCollection> pTrackingVertices;
    TrackingParticleRefProd refTrackingParticles;
    TrackingVertexRefProd refTrackingVertexes;
  };
 
private:
  OutputCollections unmergedOutput_;
  OutputCollections mergedOutput_;
  std::unique_ptr<TrackingVertexCollection> pInitialVertices_;
};
 
#endif  // end of "#ifndef TrackingAnalysis_TrackingTruthAccumulator_h"