TrackingTruthAccumulator.h

Go to the documentation of this file.

#ifndef TrackingAnalysis_TrackingTruthAccumulator_h
#define TrackingAnalysis_TrackingTruthAccumulator_h

#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "Geometry/Records/interface/TrackerTopologyRcd.h"
#include "FWCore/Framework/interface/FrameworkfwdMostUsed.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
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_;
  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> tTopoToken_;

  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"