Hgc digithr g4cutrange

Geometry/HGCalSimData/data/hgcProdCuts.xml

@@ -5,16 +5,16 @@
   <SpecPar name="hgcee">
     <PartSelector path="//HGCalEE"/>
     <Parameter name="CMSCutsRegion" value="HGCalEERegion" eval="false"/>
-    <Parameter name="ProdCutsForElectrons" value="0.1*mm"/>
-    <Parameter name="ProdCutsForPositrons" value="0.1*mm"/>
-    <Parameter name="ProdCutsForGamma" value="0.1*mm"/>
+    <Parameter name="ProdCutsForElectrons" value="0.03*mm"/>
+    <Parameter name="ProdCutsForPositrons" value="0.03*mm"/>
+    <Parameter name="ProdCutsForGamma" value="0.03*mm"/>
   </SpecPar>
   <SpecPar name="hgche">
     <PartSelector path="//HGCalHE"/>
     <Parameter name="CMSCutsRegion" value="HGCalHERegion" eval="false"/>
-    <Parameter name="ProdCutsForElectrons" value="0.1*mm"/>
-    <Parameter name="ProdCutsForPositrons" value="0.1*mm"/>
-    <Parameter name="ProdCutsForGamma" value="0.1*mm"/>
+    <Parameter name="ProdCutsForElectrons" value="0.03*mm"/>
+    <Parameter name="ProdCutsForPositrons" value="0.03*mm"/>
+    <Parameter name="ProdCutsForGamma" value="0.03*mm"/>
   </SpecPar>
 </SpecParSection>
 

RecoLocalCalo/HGCalRecProducers/plugins/HGCalRecHitWorkerSimple.cc

@@ -12,19 +12,19 @@ HGCalRecHitWorkerSimple::HGCalRecHitWorkerSimple(const edm::ParameterSet&ps) :
 {
         rechitMaker_ = new HGCalRecHitSimpleAlgo();
 	// HGCee constants 
-	HGCEEmipInKeV_ =  ps.getUntrackedParameter<double>("HGCEEmipInKeV");
-	HGCEElsbInMIP_ =  ps.getUntrackedParameter<double>("HGCEElsbInMIP");
-	HGCEEmip2noise_ = ps.getUntrackedParameter<double>("HGCEEmip2noise");
+	HGCEEmipInKeV_ =  ps.getParameter<double>("HGCEEmipInKeV");
+	HGCEElsbInMIP_ =  ps.getParameter<double>("HGCEElsbInMIP");
+	HGCEEmip2noise_ = ps.getParameter<double>("HGCEEmip2noise");
 	hgceeADCtoGeV_ = HGCEEmipInKeV_ * HGCEElsbInMIP_/1000000; 
 	// HGChef constants
-	HGCHEFmipInKeV_ =  ps.getUntrackedParameter<double>("HGCHEFmipInKeV");
-	HGCHEFlsbInMIP_ =  ps.getUntrackedParameter<double>("HGCHEFlsbInMIP");
-	HGCHEFmip2noise_ = ps.getUntrackedParameter<double>("HGCHEFmip2noise");
+	HGCHEFmipInKeV_ =  ps.getParameter<double>("HGCHEFmipInKeV");
+	HGCHEFlsbInMIP_ =  ps.getParameter<double>("HGCHEFlsbInMIP");
+	HGCHEFmip2noise_ = ps.getParameter<double>("HGCHEFmip2noise");
 	hgchefADCtoGeV_ = HGCHEFmipInKeV_ * HGCHEFlsbInMIP_/1000000;
 	// HGCheb constants
-	HGCHEBmipInKeV_ =  ps.getUntrackedParameter<double>("HGCHEBmipInKeV");
-	HGCHEBlsbInMIP_ =  ps.getUntrackedParameter<double>("HGCHEBlsbInMIP");
-	HGCHEBmip2noise_ = ps.getUntrackedParameter<double>("HGCHEBmip2noise");
+	HGCHEBmipInKeV_ =  ps.getParameter<double>("HGCHEBmipInKeV");
+	HGCHEBlsbInMIP_ =  ps.getParameter<double>("HGCHEBlsbInMIP");
+	HGCHEBmip2noise_ = ps.getParameter<double>("HGCHEBmip2noise");
 	hgchebADCtoGeV_ = HGCHEBmipInKeV_ * HGCHEBlsbInMIP_/1000000;
 	//        v_chstatus_ = ps.getParameter<std::vector<int> >("ChannelStatusToBeExcluded");
 	//	v_DB_reco_flags_ = ps.getParameter<std::vector<int> >("flagsMapDBReco");

SimCalorimetry/HGCSimProducers/interface/HGCDigitizer.h

@@ -17,6 +17,7 @@
 
 #include <vector>
 #include <map>
+#include <memory>
 
 class PCaloHit;
 class PileUpEventPrincipal;
@@ -25,9 +26,8 @@ class HGCDigitizer
 {
 public:
 
-  explicit HGCDigitizer(const edm::ParameterSet& ps);
-  virtual ~HGCDigitizer();
-
+  HGCDigitizer(const edm::ParameterSet& ps);
+  ~HGCDigitizer() { }
 
   /**
      @short handle SimHit accumulation
@@ -44,9 +44,9 @@ class HGCDigitizer
 
   /**
    */
-  bool producesEEDigis()       { return (hitCollection_.find("EE")!=std::string::npos);      } 
-  bool producesHEfrontDigis()  { return (hitCollection_.find("HEfront")!=std::string::npos); } 
-  bool producesHEbackDigis()   { return (hitCollection_.find("HEback")!=std::string::npos);  } 
+  bool producesEEDigis()       { return (mySubDet_==ForwardSubdetector::HGCEE);  }
+  bool producesHEfrontDigis()  { return (mySubDet_==ForwardSubdetector::HGCHEF); }
+  bool producesHEbackDigis()   { return (mySubDet_==ForwardSubdetector::HGCHEB); }
   std::string digiCollection() { return digiCollection_; }
 
   /**
@@ -63,19 +63,19 @@ private :
   //input/output names
   std::string hitCollection_,digiCollection_;
 
-  //flag for trivial digitization
-  bool doTrivialDigis_;
+  //digitization type (it's up to the specializations to decide it's meaning)
+  int digitizationType_;
 
   //handle sim hits
   int maxSimHitsAccTime_;
   int bxTime_;
-  HGCSimHitDataAccumulator simHitAccumulator_;  
+  std::unique_ptr<HGCSimHitDataAccumulator> simHitAccumulator_;  
   void resetSimHitDataAccumulator();
 
   //digitizers
-  HGCEEDigitizer theHGCEEDigitizer_;
-  HGCHEbackDigitizer theHGCHEbackDigitizer_;
-  HGCHEfrontDigitizer theHGCHEfrontDigitizer_;
+  std::unique_ptr<HGCEEDigitizer>      theHGCEEDigitizer_;
+  std::unique_ptr<HGCHEbackDigitizer>  theHGCHEbackDigitizer_;
+  std::unique_ptr<HGCHEfrontDigitizer> theHGCHEfrontDigitizer_;
 
   //subdetector id
   ForwardSubdetector mySubDet_;

SimCalorimetry/HGCSimProducers/interface/HGCDigitizerBase.h

@@ -1,17 +1,20 @@
 #ifndef SimCalorimetry_HGCSimProducers_hgcdigitizerbase
 #define SimCalorimetry_HGCSimProducers_hgcdigitizerbase
 
+#include <array>
 #include <iostream>
 #include <vector>
 #include <memory>
+#include <unordered_map>
 
 #include "DataFormats/HGCDigi/interface/HGCDigiCollections.h"
 #include "FWCore/Utilities/interface/EDMException.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "CLHEP/Random/RandGauss.h"
 
-typedef std::vector<double> HGCSimHitData;
-typedef std::map<uint32_t, HGCSimHitData> HGCSimHitDataAccumulator;
+typedef float HGCSimEn_t;
+typedef std::array<HGCSimEn_t,10> HGCSimHitData;
+typedef std::unordered_map<uint32_t, HGCSimHitData> HGCSimHitDataAccumulator;
 
 template <class D>
 class HGCDigitizerBase {
@@ -24,10 +27,12 @@ class HGCDigitizerBase {
    */
   HGCDigitizerBase(const edm::ParameterSet &ps) : simpleNoiseGen_(0)
     {
-      myCfg_     = ps.getUntrackedParameter<edm::ParameterSet>("digiCfg"); 
-      mipInKeV_  = myCfg_.getUntrackedParameter<double>("mipInKeV");
-      lsbInMIP_  = myCfg_.getUntrackedParameter<double>("lsbInMIP");
-      mip2noise_ = myCfg_.getUntrackedParameter<double>("mip2noise");
+      myCfg_         = ps.getParameter<edm::ParameterSet>("digiCfg"); 
+      mipInKeV_      = myCfg_.getParameter<double>("mipInKeV");
+      lsbInMIP_      = myCfg_.getParameter<double>("lsbInMIP");
+      mip2noise_     = myCfg_.getParameter<double>("mip2noise");
+      adcThreshold_  = myCfg_.getParameter< uint32_t >("adcThreshold");
+      doTimeSamples_ = myCfg_.getParameter< bool >("doTimeSamples");
     }
 
   /**
@@ -41,10 +46,10 @@ class HGCDigitizerBase {
   /**
      @short steer digitization mode
    */
-  void run(std::auto_ptr<DColl> &digiColl,HGCSimHitDataAccumulator &simData,bool doTrivialDigis)
+  void run(std::auto_ptr<DColl> &digiColl,HGCSimHitDataAccumulator &simData,uint32_t digitizationType)
   {
-    if(doTrivialDigis) runTrivial(digiColl,simData);
-    else               runDigitizer(digiColl,simData);
+    if(digitizationType==0) runTrivial(digiColl,simData);
+    else                    runDigitizer(digiColl,simData,digitizationType);
   }
 
 
@@ -59,21 +64,25 @@ class HGCDigitizerBase {
       {
 	//convert total energy GeV->keV->ADC counts
 	double totalEn(0);
-	for(size_t i=0; i<it->second.size(); i++) totalEn+= (it->second)[i];
+	size_t maxSampleToInteg(doTimeSamples_ ? 1 : it->second.size());
+	for(size_t i=0; i<maxSampleToInteg; i++) {
+	  totalEn+= (it->second)[i];
+	}
 	totalEn*=1e6;
 
 	//add noise (in keV)
 	double noiseEn=simpleNoiseGen_->fire();
-	if(noiseEn<0) noiseEn=0;
-
+	totalEn += noiseEn;
+	if(totalEn<0) totalEn=0;
+
 	//round to integer (sample will saturate the value according to available bits)
-	uint16_t totalEnInt = floor( ((totalEn+noiseEn)/mipInKeV_) / lsbInMIP_ );
+	uint16_t totalEnInt = floor( (totalEn/mipInKeV_) / lsbInMIP_ );
 
 	//0 gain for the moment
 	HGCSample singleSample;
 	singleSample.set(0, totalEnInt );
 
-	if(singleSample.adc()==0) continue;
+	if(singleSample.adc()<adcThreshold_) continue;
 
 	//no time information
 	D newDataFrame( it->first );
@@ -87,7 +96,7 @@ class HGCDigitizerBase {
   /**
      @short to be specialized by top class
    */
-  virtual void runDigitizer(std::auto_ptr<DColl> &coll,HGCSimHitDataAccumulator &simData)
+  virtual void runDigitizer(std::auto_ptr<DColl> &coll,HGCSimHitDataAccumulator &simData,uint32_t digitizerType)
   {
     throw cms::Exception("HGCDigitizerBaseException") << " Failed to find specialization of runDigitizer";
   }
@@ -103,13 +112,19 @@ class HGCDigitizerBase {
   //baseline configuration
   edm::ParameterSet myCfg_;
 
- private:
+  //minimum ADC counts to produce DIGIs
+  uint32_t adcThreshold_;
 
-  //
-  double mipInKeV_, lsbInMIP_, mip2noise_;
+  //flag to apply or not time sampling (if false digitize the full energy from SimHit)
+  bool doTimeSamples_;
 
-  //
+  //a simple noise generator
   mutable CLHEP::RandGauss *simpleNoiseGen_;
+
+  //parameters for the trivial digitization scheme
+  double mipInKeV_, lsbInMIP_, mip2noise_;
+
+ private:
 
 };
 

SimCalorimetry/HGCSimProducers/interface/HGCEEDigitizer.h

@@ -8,7 +8,7 @@ class HGCEEDigitizer : public HGCDigitizerBase<HGCEEDataFrame>
 {
  public:
   HGCEEDigitizer(const edm::ParameterSet& ps);
-  void runDigitizer(std::auto_ptr<HGCEEDigiCollection> &digiColl,HGCSimHitDataAccumulator &simData);
+  void runDigitizer(std::auto_ptr<HGCEEDigiCollection> &digiColl,HGCSimHitDataAccumulator &simData,uint32_t digitizationType);
   ~HGCEEDigitizer();
  private:
 

SimCalorimetry/HGCSimProducers/interface/HGCHEbackDigitizer.h

@@ -4,14 +4,24 @@
 #include "SimCalorimetry/HGCSimProducers/interface/HGCDigitizerBase.h"
 #include "DataFormats/HGCDigi/interface/HGCDigiCollections.h"
 
+#include "CLHEP/Random/RandPoisson.h"
+
 class HGCHEbackDigitizer : public HGCDigitizerBase<HGCHEDataFrame>
 {
  public:
+
   HGCHEbackDigitizer(const edm::ParameterSet& ps);
-  void runDigitizer(std::auto_ptr<HGCHEDigiCollection> &digiColl,HGCSimHitDataAccumulator &simData);
+  void setRandomNumberEngine(CLHEP::HepRandomEngine& engine);
+  void runDigitizer(std::auto_ptr<HGCHEDigiCollection> &digiColl,HGCSimHitDataAccumulator &simData,uint32_t digitizationType);
   ~HGCHEbackDigitizer();
+
  private:
 
+  //calice-like digitization parameters
+  float nPEperMIP_, nTotalPE_, xTalk_, sdPixels_;
+  mutable CLHEP::RandPoisson *peGen_;
+  mutable CLHEP::RandGauss *sigGen_;
+  void runCaliceLikeDigitizer(std::auto_ptr<HGCHEDigiCollection> &digiColl,HGCSimHitDataAccumulator &simData);
 };
 
 #endif 

SimCalorimetry/HGCSimProducers/interface/HGCHEfrontDigitizer.h

@@ -8,7 +8,7 @@ class HGCHEfrontDigitizer : public HGCDigitizerBase<HGCHEDataFrame>
 {
  public:
   HGCHEfrontDigitizer(const edm::ParameterSet& ps);
-  void runDigitizer(std::auto_ptr<HGCHEDigiCollection> &digiColl,HGCSimHitDataAccumulator &simData);
+  void runDigitizer(std::auto_ptr<HGCHEDigiCollection> &digiColl,HGCSimHitDataAccumulator &simData,uint32_t digitizationType);
   ~HGCHEfrontDigitizer();
  private:
 

SimCalorimetry/HGCSimProducers/plugins/HGCDigiProducer.cc

@@ -6,48 +6,57 @@
 //
 HGCDigiProducer::HGCDigiProducer(edm::ParameterSet const& pset, edm::EDProducer& mixMod) :
   DigiAccumulatorMixMod(),
-  theDigitizer_(pset) 
+  theDigitizer_(new HGCDigitizer(pset) ) 
+{
+  if( theDigitizer_->producesEEDigis()     )
+    mixMod.produces<HGCEEDigiCollection>(theDigitizer_->digiCollection());
+  if( theDigitizer_->producesHEfrontDigis() || theDigitizer_->producesHEbackDigis() )
+    mixMod.produces<HGCHEDigiCollection>(theDigitizer_->digiCollection());
+}
+
+//
+HGCDigiProducer::~HGCDigiProducer()
 {
-  if( theDigitizer_.producesEEDigis()     )
-    mixMod.produces<HGCEEDigiCollection>(theDigitizer_.digiCollection());
-  if( theDigitizer_.producesHEfrontDigis() || theDigitizer_.producesHEbackDigis() )
-    mixMod.produces<HGCHEDigiCollection>(theDigitizer_.digiCollection());
 }
 
 //
 void HGCDigiProducer::initializeEvent(edm::Event const& event, edm::EventSetup const& es) 
 {
-  theDigitizer_.initializeEvent(event, es);
+  theDigitizer_->initializeEvent(event, es);
 }
 
 //
 void HGCDigiProducer::finalizeEvent(edm::Event& event, edm::EventSetup const& es) 
 {
-  theDigitizer_.finalizeEvent(event, es);
+  theDigitizer_->finalizeEvent(event, es);
 }
 
 //
 void HGCDigiProducer::accumulate(edm::Event const& event, edm::EventSetup const& es) 
 {
-  theDigitizer_.accumulate(event, es);
+  theDigitizer_->accumulate(event, es);
 }
 
 void HGCDigiProducer::accumulate(PileUpEventPrincipal const& event, edm::EventSetup const& es) 
 {
-  theDigitizer_.accumulate(event, es);
+  theDigitizer_->accumulate(event, es);
 }
 
 //
 void HGCDigiProducer::beginRun(edm::Run const&, edm::EventSetup const& es) 
 {
-  theDigitizer_.beginRun(es);
+  theDigitizer_->beginRun(es);
 }
 
 //
 void HGCDigiProducer::endRun(edm::Run const&, edm::EventSetup const&) 
 {
-  theDigitizer_.endRun();
+  theDigitizer_->endRun();
 }
 
+//
+//HGCDigiProducer::~HGCDigiProducer()
+//{
+//}
 
 DEFINE_DIGI_ACCUMULATOR(HGCDigiProducer);

SimCalorimetry/HGCSimProducers/plugins/HGCDigiProducer.h

@@ -4,6 +4,8 @@
 #include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h"
 #include "SimCalorimetry/HGCSimProducers/interface/HGCDigitizer.h"
 
+#include <memory>
+
 namespace edm {
   class EDProducer;
   class ParameterSet;
@@ -18,10 +20,10 @@ class HGCDigiProducer : public DigiAccumulatorMixMod {
   virtual void accumulate(PileUpEventPrincipal const&, edm::EventSetup const&) override;
   virtual void beginRun(edm::Run const&, edm::EventSetup const&) override;
   virtual void endRun(edm::Run const&, edm::EventSetup const&) override;
+  ~HGCDigiProducer();
 private:
-
-
-  HGCDigitizer theDigitizer_;
+  //the digitizer
+  std::unique_ptr<HGCDigitizer> theDigitizer_;
 };
 
 #endif