MTDDigitizerBase.h

Go to the documentation of this file.

#ifndef FastTimingSimProducers_FastTimingCommon_MTDDigitizerBase_h
#define FastTimingSimProducers_FastTimingCommon_MTDDigitizerBase_h

#include "FWCore/Framework/interface/ProducerBase.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"

#include "SimDataFormats/TrackingHit/interface/PSimHit.h"
#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h"

#include "DataFormats/FTLDigi/interface/FTLDigiCollections.h"
#include "DataFormats/FTLDigi/interface/PMTDSimAccumulator.h"
#include "SimFastTiming/FastTimingCommon/interface/MTDDigitizerTypes.h"

#include "CLHEP/Units/GlobalPhysicalConstants.h"

#include <string>

namespace CLHEP {
  class HepRandomEngine;
}

namespace edm {
  class Event;
  class EventSetup;
}

class PileUpEventPrincipal;

class MTDDigitizerBase {
 public:
 MTDDigitizerBase(const edm::ParameterSet& config, 
          edm::ConsumesCollector& iC,
          edm::ProducerBase& parent) :
  inputSimHits_( config.getParameter<edm::InputTag>("inputSimHits") ),
  digiCollection_( config.getParameter<std::string>("digiCollectionTag") ),
  verbosity_( config.getUntrackedParameter< uint32_t >("verbosity",0) ),   
  refSpeed_( 0.1*CLHEP::c_light ),   
  premixStage1MinCharge_( config.getParameter<double>("premixStage1MinCharge") ),
  premixStage1MaxCharge_( config.getParameter<double>("premixStage1MaxCharge") ),
  premixStage1_( config.getParameter<bool>("premixStage1")),
  name_( config.getParameter<std::string>("digitizerName") ) {
    iC.consumes<std::vector<PSimHit> >(inputSimHits_);

    if ( name_ == "BTLTileDigitizer" || name_ == "BTLBarDigitizer" ) {
      if(premixStage1_) {
        parent.produces<PMTDSimAccumulator>(digiCollection_);
      }
      else {
        parent.produces<BTLDigiCollection>(digiCollection_);
      }
    }
    else if ( name_ == "ETLDigitizer" )
      if(premixStage1_) {
        parent.produces<PMTDSimAccumulator>(digiCollection_);
      }
      else {
        parent.produces<ETLDigiCollection>(digiCollection_);
      }
    else
      throw cms::Exception("[MTDDigitizerBase::MTDDigitizerBase]")
    << name_ << " is an invalid MTD digitizer name";
  }
  
  virtual ~MTDDigitizerBase() {}


  virtual void accumulate(edm::Event const& e, edm::EventSetup const& c, CLHEP::HepRandomEngine* hre) = 0;
  virtual void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, CLHEP::HepRandomEngine* hre) = 0;
  virtual void accumulate(edm::Handle<edm::PSimHitContainer> const &hits, int bxCrossing, CLHEP::HepRandomEngine* hre) = 0;
  // for premixing
  virtual void accumulate(const PMTDSimAccumulator& simAccumulator) = 0;
  
  virtual void initializeEvent(edm::Event const& e, edm::EventSetup const& c) = 0;
  virtual void finalizeEvent(edm::Event& e, edm::EventSetup const& c, CLHEP::HepRandomEngine* hre) = 0;
  
  virtual void beginRun(const edm::EventSetup & es) = 0;
  virtual void endRun() = 0;

  const std::string& name() const {
    return name_;
  }
  

 protected:
  //input/output names
  const edm::InputTag inputSimHits_;
  const std::string digiCollection_;

  //misc switches
  const uint32_t verbosity_;

  //reference speed to evaluate time of arrival at the sensititive detector, assuming the center of CMS
  const float refSpeed_;  

  // Minimum charge threshold for premixing stage1
  double premixStage1MinCharge_;
  // Maximum charge for packing in premixing stage1
  double premixStage1MaxCharge_;

  // flag telling whether we are runing in premixing stage1
  const bool premixStage1_;

 private:
  std::string name_;

};

#include "FWCore/PluginManager/interface/PluginFactory.h"
typedef edmplugin::PluginFactory< MTDDigitizerBase* (const edm::ParameterSet&, edm::ConsumesCollector&, edm::ProducerBase&) > MTDDigitizerFactory;



#endif