HGCDigitizer Class Reference

#include <HGCDigitizer.h>

Public Types
typedef std::tuple< int, uint32_t, float >	HGCCaloHitTuple_t

Public Member Functions
void	accumulate (edm::Event const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *hre)
	handle SimHit accumulation More...
void	accumulate (PileUpEventPrincipal const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *hre)
template<typename GEOM >
void	accumulate (edm::Handle< edm::PCaloHitContainer > const &hits, int bxCrossing, const GEOM *geom, CLHEP::HepRandomEngine *hre)
void	beginRun (const edm::EventSetup &es)
	actions at the start/end of run More...
std::string	digiCollection ()
void	endRun ()
void	finalizeEvent (edm::Event &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *hre)
	HGCDigitizer (const edm::ParameterSet &ps, edm::ConsumesCollector &iC)
void	initializeEvent (edm::Event const &e, edm::EventSetup const &c)
	actions at the start/end of event More...
bool	producesEEDigis ()
bool	producesHEbackDigis ()
bool	producesHEfrontDigis ()
	~HGCDigitizer ()

Static Public Member Functions
static bool	orderByDetIdThenTime (const HGCCaloHitTuple_t &a, const HGCCaloHitTuple_t &b)

Private Member Functions
void	resetSimHitDataAccumulator ()

Private Attributes
std::array< double, 3 >	averageOccupancies_
double	bxTime_
std::vector< float >	cce_
std::string	digiCollection_
int	digitizationType_
double	ev_per_eh_pair_
const HcalGeometry *	gHcal_
const HGCalGeometry *	gHGCal_
std::string	hitCollection_
std::map< uint32_t, std::vector< std::pair< float, float > > >	hitRefs_bx0
int	maxSimHitsAccTime_
ForwardSubdetector	mySubDet_
uint32_t	nEvents_
float	refSpeed_
std::unique_ptr< hgc::HGCSimHitDataAccumulator >	simHitAccumulator_
std::unique_ptr< HGCEEDigitizer >	theHGCEEDigitizer_
std::unique_ptr< HGCHEbackDigitizer >	theHGCHEbackDigitizer_
std::unique_ptr< HGCHEfrontDigitizer >	theHGCHEfrontDigitizer_
float	tofDelay_
std::unordered_set< DetId >	validIds_
uint32_t	verbosity_

Detailed Description

Definition at line 28 of file HGCDigitizer.h.

Member Typedef Documentation

typedef std::tuple<int,uint32_t,float> HGCDigitizer::HGCCaloHitTuple_t

Definition at line 36 of file HGCDigitizer.h.

Constructor & Destructor Documentation

HGCDigitizer::HGCDigitizer	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &	iC
	)

Definition at line 131 of file HGCDigitizer.cc.

References bxTime_, cce_, edm::ConsumesCollector::consumes(), digiCollection_, digitizationType_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HGCEE, HGCHEB, HGCHEF, hitCollection_, maxSimHitsAccTime_, mySubDet_, AlCaHLTBitMon_QueryRunRegistry::string, edm::swap(), groupFilesInBlocks::temp, theHGCEEDigitizer_, theHGCHEbackDigitizer_, theHGCHEfrontDigitizer_, tofDelay_, validIds_, and verbosity_.

                                                     :
  simHitAccumulator_( new HGCSimHitDataAccumulator() ),
  mySubDet_(ForwardSubdetector::ForwardEmpty),
  refSpeed_(0.1*CLHEP::c_light), //[CLHEP::c_light]=mm/ns convert to cm/ns
  averageOccupancies_(occupancyGuesses),
  nEvents_(1)
{
  //configure from cfg
  hitCollection_     = ps.getParameter< std::string >("hitCollection");
  digiCollection_    = ps.getParameter< std::string >("digiCollection");
  maxSimHitsAccTime_ = ps.getParameter< uint32_t >("maxSimHitsAccTime");
  bxTime_            = ps.getParameter< double >("bxTime");
  digitizationType_  = ps.getParameter< uint32_t >("digitizationType");
  verbosity_         = ps.getUntrackedParameter< uint32_t >("verbosity",0);
  tofDelay_          = ps.getParameter< double >("tofDelay");  

  std::unordered_set<DetId>().swap(validIds_);
  
  iC.consumes<std::vector<PCaloHit> >(edm::InputTag("g4SimHits",hitCollection_));
  const auto& myCfg_ = ps.getParameter<edm::ParameterSet>("digiCfg");
  
  if( myCfg_.existsAs<std::vector<double> >( "chargeCollectionEfficiencies" ) ) {
    cce_.clear();
    const auto& temp = myCfg_.getParameter<std::vector<double> >("chargeCollectionEfficiencies");
    for( double cce : temp ) {
      cce_.push_back(cce);
    }
  } else {
    std::vector<float>().swap(cce_);
  }
  
  if(hitCollection_.find("HitsEE")!=std::string::npos) { 
    mySubDet_=ForwardSubdetector::HGCEE;  
    theHGCEEDigitizer_=std::unique_ptr<HGCEEDigitizer>(new HGCEEDigitizer(ps) ); 
  }
  if(hitCollection_.find("HitsHEfront")!=std::string::npos)  
    { 
      mySubDet_=ForwardSubdetector::HGCHEF;
      theHGCHEfrontDigitizer_=std::unique_ptr<HGCHEfrontDigitizer>(new HGCHEfrontDigitizer(ps) );
    }
  if(hitCollection_.find("HcalHits")!=std::string::npos)
    { 
      mySubDet_=ForwardSubdetector::HGCHEB;
      theHGCHEbackDigitizer_=std::unique_ptr<HGCHEbackDigitizer>(new HGCHEbackDigitizer(ps) );
    }
}

HGCDigitizer::~HGCDigitizer ( )

inline

Definition at line 33 of file HGCDigitizer.h.

{ }

Member Function Documentation

void HGCDigitizer::accumulate	(	edm::Event const &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	hre
	)

handle SimHit accumulation

Definition at line 258 of file HGCDigitizer.cc.

References Exception, edm::Event::getByLabel(), gHcal_, gHGCal_, hitCollection_, hfClusterShapes_cfi::hits, and edm::HandleBase::isValid().

Referenced by accumulate(), and orderByDetIdThenTime().

                                                                                                           {

  //get inputs
  edm::Handle<edm::PCaloHitContainer> hits;
  e.getByLabel(edm::InputTag("g4SimHits",hitCollection_),hits); 
  if( !hits.isValid() ){
    edm::LogError("HGCDigitizer") << " @ accumulate : can't find " << hitCollection_ << " collection of g4SimHits";
    return;
  }
  
  //accumulate in-time the main event
  if( nullptr != gHGCal_ ) {
    accumulate(hits, 0, gHGCal_, hre);
  } else if( nullptr != gHcal_ ) {
    accumulate(hits, 0, gHcal_, hre);
  } else {
    throw cms::Exception("BadConfiguration")
      << "HGCDigitizer is not producing EE, FH, or BH digis!";
  }
}

void HGCDigitizer::accumulate	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 280 of file HGCDigitizer.cc.

References accumulate(), PileUpEventPrincipal::bunchCrossing(), Exception, PileUpEventPrincipal::getByLabel(), gHcal_, gHGCal_, hitCollection_, hfClusterShapes_cfi::hits, and edm::HandleBase::isValid().

                                                                                                                       {

  //get inputs
  edm::Handle<edm::PCaloHitContainer> hits;
  e.getByLabel(edm::InputTag("g4SimHits",hitCollection_),hits); 
  if( !hits.isValid() ){
    edm::LogError("HGCDigitizer") << " @ accumulate : can't find " << hitCollection_ << " collection of g4SimHits";
    return;
  }
  
  //accumulate for the simulated bunch crossing  
  if( nullptr != gHGCal_ ) {
    accumulate(hits, e.bunchCrossing(), gHGCal_, hre);
  } else if ( nullptr != gHcal_ ) {
    accumulate(hits, e.bunchCrossing(), gHcal_, hre);
  } else {
    throw cms::Exception("BadConfiguration")
      << "HGCDigitizer is not producing EE, FH, or BH digis!";
  }
}

template<typename GEOM >

void HGCDigitizer::accumulate	(	edm::Handle< edm::PCaloHitContainer > const &	hits,
		int	bxCrossing,
		const GEOM *	geom,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 303 of file HGCDigitizer.cc.

References begin, bxTime_, cce_, ALCARECOTkAlJpsiMuMu_cff::charge, TauDecayModes::dec, relativeConstraints::empty, end, f, plotBeamSpotDB::first, HGCEE, HGCHEB, HGCHEF, hitRefs_bx0, mps_fire::i, triggerObjects_cff::id, createfilelist::int, hgcalDigitizer_cfi::keV2fC, mySubDet_, orderByDetIdThenTime(), producesEEDigis(), refSpeed_, edm::second(), simHitAccumulator_, findQualityFiles::size, theHGCEEDigitizer_, theHGCHEbackDigitizer_, theHGCHEfrontDigitizer_, tofDelay_, validIds_, and verbosity_.

                                                         {
  if( nullptr == geom ) return;
  
  
  
  //configuration to apply for the computation of time-of-flight
  bool weightToAbyEnergy(false);
  std::array<float, 3> tdcForToAOnset{ {0.f, 0.f, 0.f} };
  float keV2fC(0.f);
  switch( mySubDet_ ) {
  case ForwardSubdetector::HGCEE:
    weightToAbyEnergy = theHGCEEDigitizer_->toaModeByEnergy();
    tdcForToAOnset    = theHGCEEDigitizer_->tdcForToAOnset();
    keV2fC            = theHGCEEDigitizer_->keV2fC();
    break;
  case ForwardSubdetector::HGCHEF:
    weightToAbyEnergy = theHGCHEfrontDigitizer_->toaModeByEnergy();
    tdcForToAOnset    = theHGCHEfrontDigitizer_->tdcForToAOnset();
    keV2fC            = theHGCHEfrontDigitizer_->keV2fC();
    break;
  case ForwardSubdetector::HGCHEB:
    weightToAbyEnergy = theHGCHEbackDigitizer_->toaModeByEnergy();
    tdcForToAOnset    = theHGCHEbackDigitizer_->tdcForToAOnset();
    keV2fC            = theHGCHEbackDigitizer_->keV2fC();     
    break;
  default:
    break;
  }

  //create list of tuples (pos in container, RECO DetId, time) to be sorted first
  int nchits=(int)hits->size();  
  std::vector< HGCCaloHitTuple_t > hitRefs;
  hitRefs.reserve(nchits);
  for(int i=0; i<nchits; ++i) {
    const auto& the_hit = hits->at(i);    
    
    DetId id = simToReco(geom,the_hit.id());
    
    if (verbosity_>0) {
      if (producesEEDigis())
    edm::LogInfo("HGCDigitizer") << " i/p " << std::hex << the_hit.id() << " o/p " << id.rawId() << std::dec << std::endl;
      else
    edm::LogInfo("HGCDigitizer") << " i/p " << std::hex << the_hit.id() << " o/p " << id.rawId() << std::dec << std::endl;
    }

    if( 0 != id.rawId() ) {      
      hitRefs.emplace_back( i, id.rawId(), (float)the_hit.time() );
    }
  }
  std::sort(hitRefs.begin(),hitRefs.end(),this->orderByDetIdThenTime);
  
  //loop over sorted hits
  nchits = hitRefs.size();
  for(int i=0; i<nchits; ++i) {
    const int hitidx   = std::get<0>(hitRefs[i]);
    const uint32_t id  = std::get<1>(hitRefs[i]);

    //get the data for this cell, if not available then we skip it
   
    if( !validIds_.count(id) ) continue;
    HGCSimHitDataAccumulator::iterator simHitIt = simHitAccumulator_->emplace(id,HGCCellInfo()).first;

    if(id==0) continue; // to be ignored at RECO level

    const float toa    = std::get<2>(hitRefs[i]);
    const PCaloHit &hit=hits->at( hitidx );     
    const float charge = hit.energy()*1e6*keV2fC*getCCE(geom,id,cce_);
    
    //distance to the center of the detector
    const float dist2center( getPositionDistance(geom,id) );
      
    //hit time: [time()]=ns  [centerDist]=cm [refSpeed_]=cm/ns + delay by 1ns
    //accumulate in 15 buckets of 25ns (9 pre-samples, 1 in-time, 5 post-samples)
    const float tof = toa-dist2center/refSpeed_+tofDelay_ ;
    const int itime= std::floor( tof/bxTime_ ) + 9;

    //no need to add bx crossing - tof comes already corrected from the mixing module
    //itime += bxCrossing;
    //itime += 9;
      
    if(itime<0 || itime>14) continue;     
          
    //check if time index is ok and store energy
    if(itime >= (int)simHitIt->second.hit_info[0].size() ) continue;

    (simHitIt->second).hit_info[0][itime] += charge;


    //working version with pileup only for in-time hits
    int waferThickness = getCellThickness(geom,id);
    bool orderChanged = false;
    if(itime == 9){
      if(hitRefs_bx0[id].empty()){
    hitRefs_bx0[id].push_back(std::pair<float, float>(charge, tof));
      }
      else if(tof <= hitRefs_bx0[id].back().second){
    std::vector<std::pair<float, float> >::iterator findPos = 
      std::upper_bound(hitRefs_bx0[id].begin(), hitRefs_bx0[id].end(), std::pair<float, float>(0.f,tof), 
               [](const auto& i, const auto& j){return i.second < j.second;});

    std::vector<std::pair<float, float> >::iterator insertedPos = 
      hitRefs_bx0[id].insert(findPos, (findPos == hitRefs_bx0[id].begin()) ? 
                 std::pair<float, float>(charge,tof) : std::pair<float, float>((findPos-1)->first+charge,tof));

    for(std::vector<std::pair<float, float> >::iterator step = insertedPos+1; step != hitRefs_bx0[id].end(); ++step){
      step->first += charge;
      if(step->first > tdcForToAOnset[waferThickness-1] && step->second != hitRefs_bx0[id].back().second){
        hitRefs_bx0[id].resize(std::upper_bound(hitRefs_bx0[id].begin(), hitRefs_bx0[id].end(), std::pair<float, float>(0.f,step->second),
                            [](const auto& i, const auto& j){return i.second < j.second;}) - hitRefs_bx0[id].begin());
        for(auto stepEnd = step+1; stepEnd != hitRefs_bx0[id].end(); ++stepEnd) stepEnd->first += charge;
        break;
      }
    }
    orderChanged = true;
      }
      else{
        if(hitRefs_bx0[id].back().first <= tdcForToAOnset[waferThickness-1]){
          hitRefs_bx0[id].push_back(std::pair<float, float>(hitRefs_bx0[id].back().first+charge, tof));
        }
      }
    }

    float accChargeForToA = hitRefs_bx0[id].empty() ? 0.f : hitRefs_bx0[id].back().first;

    //time-of-arrival (check how to be used)
    if(weightToAbyEnergy) (simHitIt->second).hit_info[1][itime] += charge*tof;
    else if(accChargeForToA > tdcForToAOnset[waferThickness-1] &&
        ((simHitIt->second).hit_info[1][itime] == 0 || orderChanged == true) ){
      float fireTDC = hitRefs_bx0[id].back().second;
      if (hitRefs_bx0[id].size() > 1){
    float chargeBeforeThr = 0.f;
    float tofchargeBeforeThr = 0.f;
    for(const auto& step : hitRefs_bx0[id]){
      if(step.first + chargeBeforeThr <= tdcForToAOnset[waferThickness-1]){
        chargeBeforeThr += step.first;
        tofchargeBeforeThr = step.second;
      }
      else break;
    }
    float deltaQ = accChargeForToA - chargeBeforeThr;
    float deltaTOF = fireTDC - tofchargeBeforeThr;
    fireTDC = (tdcForToAOnset[waferThickness-1] - chargeBeforeThr) * deltaTOF / deltaQ + tofchargeBeforeThr;
      }
      (simHitIt->second).hit_info[1][itime] = fireTDC;                                                                  
    }
    
  }
  hitRefs.clear();
}

void HGCDigitizer::beginRun

(

const edm::EventSetup &

es

)

actions at the start/end of run

Definition at line 457 of file HGCDigitizer.cc.

References Exception, DetId::Forward, relativeConstraints::geom, edm::EventSetup::get(), CaloGeometry::getSubdetectorGeometry(), gHcal_, gHGCal_, DetId::Hcal, HcalEndcap, HGCEE, HGCHEF, hitCollection_, producesEEDigis(), producesHEbackDigis(), producesHEfrontDigis(), validIds_, and verbosity_.

Referenced by digiCollection().

{
  //get geometry
  edm::ESHandle<CaloGeometry> geom;
  es.get<CaloGeometryRecord>().get(geom);
  
  gHGCal_ = nullptr;
  gHcal_ = nullptr;

  if( producesEEDigis() )      gHGCal_ = dynamic_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::Forward, HGCEE));
  if( producesHEfrontDigis() ) gHGCal_ = dynamic_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(DetId::Forward, HGCHEF));
  if( producesHEbackDigis() )  gHcal_  = dynamic_cast<const HcalGeometry*>(geom->getSubdetectorGeometry(DetId::Hcal, HcalEndcap));
  
  int nadded(0);  
  //valid ID lists
  if( nullptr != gHGCal_ ) {
    getValidDetIds( gHGCal_, validIds_ );    
  } else if( nullptr != gHcal_ ) {
    getValidDetIds( gHcal_, validIds_ );    
  } else {
    throw cms::Exception("BadConfiguration")
      << "HGCDigitizer is not producing EE, FH, or BH digis!";
  }

  if (verbosity_ > 0) 
    edm::LogInfo("HGCDigitizer") 
      << "Added " << nadded << ":" << validIds_.size() 
      << " detIds without " << hitCollection_ 
      << " in first event processed" << std::endl;
}

std::string HGCDigitizer::digiCollection ( )

inline

Definition at line 70 of file HGCDigitizer.h.

References beginRun(), digiCollection_, and endRun().

Referenced by finalizeEvent().

{ return digiCollection_; }

void HGCDigitizer::endRun

(

)

Definition at line 489 of file HGCDigitizer.cc.

References edm::swap(), and validIds_.

Referenced by digiCollection().

{
  std::unordered_set<DetId>().swap(validIds_);
}

void HGCDigitizer::finalizeEvent	(	edm::Event &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 201 of file HGCDigitizer.cc.

References averageOccupancies_, digiCollection(), digitizationType_, gHcal_, gHGCal_, HGCEE, HGCHEB, HGCHEF, hitRefs_bx0, training_settings::idx, SiStripPI::max, eostools::move(), mySubDet_, nEvents_, producesEEDigis(), producesHEbackDigis(), producesHEfrontDigis(), edm::Event::put(), simHitAccumulator_, theHGCEEDigitizer_, theHGCHEbackDigitizer_, theHGCHEfrontDigitizer_, and validIds_.

Referenced by orderByDetIdThenTime().

{
  hitRefs_bx0.clear();
  
  const CaloSubdetectorGeometry* theGeom = ( nullptr == gHGCal_ ? 
                         static_cast<const CaloSubdetectorGeometry*>(gHcal_) : 
                         static_cast<const CaloSubdetectorGeometry*>(gHGCal_)  );
  
  ++nEvents_;
  unsigned idx = std::numeric_limits<unsigned>::max();
  switch(mySubDet_) {
  case ForwardSubdetector::HGCEE:
    idx = 0;
    break;
  case ForwardSubdetector::HGCHEF:
    idx = 1;
    break;
  case ForwardSubdetector::HGCHEB:
    idx = 2;
    break;
  default:
    break;
  }
  // release memory for unfilled parts of hash table
  if( validIds_.size()*averageOccupancies_[idx] > simHitAccumulator_->size() ) {
    simHitAccumulator_->reserve(simHitAccumulator_->size());
  }
  //update occupancy guess
  const double thisOcc = simHitAccumulator_->size()/((double)validIds_.size());
  averageOccupancies_[idx] = (averageOccupancies_[idx]*(nEvents_-1) + thisOcc)/nEvents_;
  
  if( producesEEDigis() ) 
    {
      std::unique_ptr<HGCEEDigiCollection> digiResult(new HGCEEDigiCollection() );
      theHGCEEDigitizer_->run(digiResult,*simHitAccumulator_,theGeom,validIds_,digitizationType_, hre);
      edm::LogInfo("HGCDigitizer") << " @ finalize event - produced " << digiResult->size() <<  " EE hits";      
      e.put(std::move(digiResult),digiCollection());
    }
  if( producesHEfrontDigis())
    {
      std::unique_ptr<HGCHEDigiCollection> digiResult(new HGCHEDigiCollection() );
      theHGCHEfrontDigitizer_->run(digiResult,*simHitAccumulator_,theGeom,validIds_,digitizationType_, hre);
      edm::LogInfo("HGCDigitizer") << " @ finalize event - produced " << digiResult->size() <<  " HE front hits";
      e.put(std::move(digiResult),digiCollection());
    }
  if( producesHEbackDigis() )
    {
      std::unique_ptr<HGCBHDigiCollection> digiResult(new HGCBHDigiCollection() );
      theHGCHEbackDigitizer_->run(digiResult,*simHitAccumulator_,theGeom,validIds_,digitizationType_, hre);
      edm::LogInfo("HGCDigitizer") << " @ finalize event - produced " << digiResult->size() <<  " HE back hits";
      e.put(std::move(digiResult),digiCollection());
    }
  
  hgc::HGCSimHitDataAccumulator().swap(*simHitAccumulator_);
}

void HGCDigitizer::initializeEvent	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

actions at the start/end of event

Definition at line 180 of file HGCDigitizer.cc.

References averageOccupancies_, HGCEE, HGCHEB, HGCHEF, training_settings::idx, SiStripPI::max, mySubDet_, simHitAccumulator_, and validIds_.

Referenced by orderByDetIdThenTime().

{
  // reserve memory for a full detector
  unsigned idx = std::numeric_limits<unsigned>::max();
  switch(mySubDet_) {
  case ForwardSubdetector::HGCEE:
    idx = 0;
    break;
  case ForwardSubdetector::HGCHEF:
    idx = 1;
    break;
  case ForwardSubdetector::HGCHEB:
    idx = 2;
    break;
  default:
    break;
  }
  simHitAccumulator_->reserve( averageOccupancies_[idx]*validIds_.size() );
}

static bool HGCDigitizer::orderByDetIdThenTime ( const HGCCaloHitTuple_t &  a, const HGCCaloHitTuple_t &  b  )

inlinestatic

Definition at line 37 of file HGCDigitizer.h.

References accumulate(), EnergyCorrector::c, MillePedeFileConverter_cfg::e, finalizeEvent(), relativeConstraints::geom, hfClusterShapes_cfi::hits, and initializeEvent().

Referenced by accumulate().

  {
    unsigned int detId_a(std::get<1>(a)), detId_b(std::get<1>(b));

    if(detId_a<detId_b) return true;
    if(detId_a>detId_b) return false;

    double time_a(std::get<2>(a)), time_b(std::get<2>(b));
    if(time_a<time_b) return true;

    return false;
  }

bool HGCDigitizer::producesEEDigis ( )

inline

Definition at line 67 of file HGCDigitizer.h.

References HGCEE, and mySubDet_.

Referenced by accumulate(), beginRun(), and finalizeEvent().

{ return (mySubDet_==ForwardSubdetector::HGCEE);  }

bool HGCDigitizer::producesHEbackDigis ( )

inline

Definition at line 69 of file HGCDigitizer.h.

References HGCHEB, and mySubDet_.

Referenced by beginRun(), and finalizeEvent().

{ return (mySubDet_==ForwardSubdetector::HGCHEB); }

bool HGCDigitizer::producesHEfrontDigis ( )

inline

Definition at line 68 of file HGCDigitizer.h.

References HGCHEF, and mySubDet_.

Referenced by beginRun(), and finalizeEvent().

{ return (mySubDet_==ForwardSubdetector::HGCHEF); }

void HGCDigitizer::resetSimHitDataAccumulator ( )

private

Definition at line 495 of file HGCDigitizer.cc.

References relativeConstraints::geom, hfClusterShapes_cfi::hits, and simHitAccumulator_.

{
  for( HGCSimHitDataAccumulator::iterator it = simHitAccumulator_->begin(); it!=simHitAccumulator_->end(); it++)
    {
      it->second.hit_info[0].fill(0.);
      it->second.hit_info[1].fill(0.);
    }
}

Member Data Documentation

std::array<double,3> HGCDigitizer::averageOccupancies_

private

Definition at line 115 of file HGCDigitizer.h.

Referenced by finalizeEvent(), and initializeEvent().

double HGCDigitizer::bxTime_

private

Definition at line 88 of file HGCDigitizer.h.

Referenced by accumulate(), and HGCDigitizer().

std::vector<float> HGCDigitizer::cce_

private

Definition at line 118 of file HGCDigitizer.h.

Referenced by accumulate(), and HGCDigitizer().

std::string HGCDigitizer::digiCollection_

private

Definition at line 81 of file HGCDigitizer.h.

Referenced by digiCollection(), and HGCDigitizer().

int HGCDigitizer::digitizationType_

private

Definition at line 84 of file HGCDigitizer.h.

Referenced by finalizeEvent(), and HGCDigitizer().

double HGCDigitizer::ev_per_eh_pair_

private

Definition at line 88 of file HGCDigitizer.h.

const HcalGeometry* HGCDigitizer::gHcal_

private

Definition at line 100 of file HGCDigitizer.h.

Referenced by accumulate(), beginRun(), and finalizeEvent().

const HGCalGeometry* HGCDigitizer::gHGCal_

private

Definition at line 99 of file HGCDigitizer.h.

Referenced by accumulate(), beginRun(), and finalizeEvent().

std::string HGCDigitizer::hitCollection_

private

Definition at line 81 of file HGCDigitizer.h.

Referenced by accumulate(), beginRun(), and HGCDigitizer().

std::map< uint32_t, std::vector< std::pair<float, float> > > HGCDigitizer::hitRefs_bx0

private

Definition at line 120 of file HGCDigitizer.h.

Referenced by accumulate(), and finalizeEvent().

int HGCDigitizer::maxSimHitsAccTime_

private

Definition at line 87 of file HGCDigitizer.h.

Referenced by HGCDigitizer().

ForwardSubdetector HGCDigitizer::mySubDet_

private

Definition at line 103 of file HGCDigitizer.h.

Referenced by accumulate(), finalizeEvent(), HGCDigitizer(), initializeEvent(), producesEEDigis(), producesHEbackDigis(), and producesHEfrontDigis().

uint32_t HGCDigitizer::nEvents_

private

Definition at line 116 of file HGCDigitizer.h.

Referenced by finalizeEvent().

float HGCDigitizer::refSpeed_

private

Definition at line 109 of file HGCDigitizer.h.

Referenced by accumulate().

std::unique_ptr<hgc::HGCSimHitDataAccumulator> HGCDigitizer::simHitAccumulator_

private

Definition at line 89 of file HGCDigitizer.h.

Referenced by accumulate(), finalizeEvent(), initializeEvent(), and resetSimHitDataAccumulator().

std::unique_ptr<HGCEEDigitizer> HGCDigitizer::theHGCEEDigitizer_

private

Definition at line 93 of file HGCDigitizer.h.

Referenced by accumulate(), finalizeEvent(), and HGCDigitizer().

std::unique_ptr<HGCHEbackDigitizer> HGCDigitizer::theHGCHEbackDigitizer_

private

Definition at line 94 of file HGCDigitizer.h.

Referenced by accumulate(), finalizeEvent(), and HGCDigitizer().

std::unique_ptr<HGCHEfrontDigitizer> HGCDigitizer::theHGCHEfrontDigitizer_

private

Definition at line 95 of file HGCDigitizer.h.

Referenced by accumulate(), finalizeEvent(), and HGCDigitizer().

float HGCDigitizer::tofDelay_

private

Definition at line 112 of file HGCDigitizer.h.

Referenced by accumulate(), and HGCDigitizer().

std::unordered_set<DetId> HGCDigitizer::validIds_

private

Definition at line 98 of file HGCDigitizer.h.

Referenced by accumulate(), beginRun(), endRun(), finalizeEvent(), HGCDigitizer(), and initializeEvent().

uint32_t HGCDigitizer::verbosity_

private

Definition at line 106 of file HGCDigitizer.h.

Referenced by accumulate(), beginRun(), and HGCDigitizer().