hcal::HcalDigiProducer Class Reference

Performs basic HCal digitization. More...

#include <HcalDigiProducer.h>

Public Types
enum class	TimeSpreadType { GAUSSIAN = 0 , UNIFORM = 1 , CONSTANT = 2 }

Public Member Functions
	HcalDigiProducer (const std::string &name, framework::Process &process)
	Constructor Makes unique noise generator and injector for this class.
virtual	~HcalDigiProducer ()=default
	Default destructor.
void	configure (framework::config::Parameters &) override
	Configure this producer from the python configuration.
void	produce (framework::Event &event) override
	Simulates measurement of pulse and creates digi collection for input event.
virtual void	onNewRun (const ldmx::RunHeader &runHeader) override
	Random number generation.
double	makeTimeDelta (TimeSpreadType kind, std::vector< double > &parameters) const
	Create a randomized time delta based on the configured time spread type.
Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.
virtual void	process (Event &event) final
	Processing an event for a Producer is calling produce.
Public Member Functions inherited from framework::EventProcessor
	DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
	declare that we have a factory for this class
	EventProcessor (const std::string &name, Process &process)
	Class constructor.
virtual	~EventProcessor ()=default
	Class destructor.
virtual void	beforeNewRun (ldmx::RunHeader &run_header)
	Callback for Producers to add parameters to the run header before conditions are initialized.
virtual void	onFileOpen (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
virtual void	onFileClose (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.
virtual void	onProcessStart ()
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.
virtual void	onProcessEnd ()
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.
template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.
TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.
void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module_.
void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.
int	getLogFrequency () const
	Get the current logging frequency from the process.
int	getRunNumber () const
	Get the run number from the process.
std::string	getName () const
	Get the processor name.
void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Attributes
std::string	input_coll_name_
	input hit collection name
std::string	input_pass_name_
	input pass name
std::string	digi_coll_name_
	output hit collection name
std::string	pulse_truth_coll_name_
	output pulse truth collection name
double	clock_cycle_
	Time interval for chip clock in ns.
int	n_adcs_
	Depth of ADC buffer.
int	i_soi_
	Index for the Sample Of Interest in the list of digi samples.
double	mev_
	Conversion from energy in MeV to voltage in mV.
double	attlength_
	Strip attenuation length [m].
bool	noise_ {true}
	Put noise into empty channels, not configurable, only helpful in development.
bool	save_pulse_truth_info_ {false}
	If true, save the "analog" composite pulse shape in the HGCROC emulator before it gets digitized.
bool	zero_suppression_ {true}
	If false, save digis from all channels, even pure noise in empty bars Helpful when comparing with test beam data.
std::unique_ptr< ldmx::HgcrocEmulator >	hgcroc_
	Hgcroc Emulator to digitize analog voltage signals.
double	ns_
	Conversion from time in ns to ticks of the internal clock.
std::unique_ptr< TRandom2 >	random_time_
bool	do_time_spread_per_spill_ {false}
TimeSpreadType	time_spread_per_spill_type_ {TimeSpreadType::UNIFORM}
std::vector< double >	time_spread_per_spill_parameters_ {}
bool	do_time_spread_per_hit_ {false}
TimeSpreadType	time_spread_per_hit_type_ {TimeSpreadType::GAUSSIAN}
std::vector< double >	time_spread_per_hit_parameters_ {}
double	flat_time_shift_ {0.}
double	readout_threshold_
	Read out threshold.
double	pedestal_
	Read out pedestal.
double	gain_
	Read out gain.
double	noise_rms_
	Noise RMS.
std::unique_ptr< ldmx::NoiseGenerator >	noise_generator_
	Generates noise hits based off of number of cells that are not hit.
std::mt19937	rng_
	Generates Gaussian noise on top of real hits_.

Additional Inherited Members
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.
Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms
NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.
logging::logger	the_log_
	The logger for this EventProcessor.

Detailed Description

Performs basic HCal digitization.

Definition at line 25 of file HcalDigiProducer.h.

Member Enumeration Documentation

TimeSpreadType

enum class hcal::HcalDigiProducer::TimeSpreadType

strong

Definition at line 53 of file HcalDigiProducer.h.

                            {
    GAUSSIAN = 0,
    UNIFORM = 1,
    CONSTANT = 2,
  };

Constructor & Destructor Documentation

HcalDigiProducer()

hcal::HcalDigiProducer::HcalDigiProducer	(	const std::string &	name,
		framework::Process &	process )

Constructor Makes unique noise generator and injector for this class.

Definition at line 22 of file HcalDigiProducer.cxx.

    : Producer(name, process) {
  /*
   * Noise generator by default uses a Gausian model for noise
   * i.e. it assumes the noise is distributed around a mean (setPedestal)
   * with a certain RMS (setNoise) and then calculates
   * how many hits should be generated for a given number of empty
   * channels and a minimum readout value (setNoiseThreshold)
   */
  noise_generator_ = std::make_unique<ldmx::NoiseGenerator>();
}

References noise_generator_.

Member Function Documentation

configure()

void hcal::HcalDigiProducer::configure ( framework::config::Parameters & ps )

overridevirtual

Configure this producer from the python configuration.

Sets event constants and configures the noise generator, noise injector, and pulse function. Creates digi collection

Reimplemented from framework::EventProcessor.

Definition at line 48 of file HcalDigiProducer.cxx.

                                                              {
  // settings of readout chip
  //  used  in actual digitization
  auto hgcroc_params = ps.get<framework::config::Parameters>("hgcroc");
  hgcroc_ = std::make_unique<ldmx::HgcrocEmulator>(hgcroc_params);
  clock_cycle_ = hgcroc_params.get<double>("clock_cycle");
  n_adcs_ = hgcroc_params.get<int>("n_adcs");
  i_soi_ = hgcroc_params.get<int>("i_soi");
  noise_ = hgcroc_params.get<bool>("noise");
 
  // If true, ignore readout threshold
  // and generate pedestal noise digis in every empty channel
  zero_suppression_ = ps.get<bool>("zero_suppression");
 
  // Save full analog pulse shapes from the HGCROC emulation
  save_pulse_truth_info_ = ps.get<bool>("save_pulse_truth_info");
 
  // collection names
  input_coll_name_ = ps.get<std::string>("input_coll_name");
  input_pass_name_ = ps.get<std::string>("input_pass_name");
  digi_coll_name_ = ps.get<std::string>("digi_coll_name");
  pulse_truth_coll_name_ = ps.get<std::string>("pulse_truth_coll_name");
 
  // physical constants
  //  used to calculate unit conversions
  mev_ = ps.get<double>("mev");
  attlength_ = ps.get<double>("attenuation_length");
 
  // Time -> clock counts conversion
  //  time [ns] * ( 2^10 / max time in ns ) = clock counts
  ns_ = 1024. / clock_cycle_;
 
  // Configure generator that will produce noise hits in empty channels
  gain_ = ps.get<double>("avg_gain");
  readout_threshold_ = ps.get<double>("avg_readout_threshold");
  pedestal_ = ps.get<double>("avg_pedestal");
  noise_rms_ = ps.get<double>("avg_noise_rms");
 
  flat_time_shift_ = ps.get<double>("flat_time_shift");
  // Time spread parameters
  // Per hit
  const auto& time_spread_per_hit{
      ps.get<framework::config::Parameters>("time_spread_per_hit")};
  int kind = time_spread_per_hit.get<int>("kind");
  time_spread_per_hit_parameters_ =
      time_spread_per_hit.get<std::vector<double>>("parameters");
  do_time_spread_per_hit_ = kind != -1;
  time_spread_per_hit_type_ = static_cast<TimeSpreadType>(kind);
  // Per spill / event
  const auto& time_spread_per_spill{
      ps.get<framework::config::Parameters>("time_spread_per_spill")};
  kind = time_spread_per_spill.get<int>("kind");
  time_spread_per_spill_parameters_ =
      time_spread_per_spill.get<std::vector<double>>("parameters");
  do_time_spread_per_spill_ = kind != -1;
  time_spread_per_spill_type_ = static_cast<TimeSpreadType>(kind);
}

References attlength_, clock_cycle_, digi_coll_name_, gain_, framework::config::Parameters::get(), hgcroc_, i_soi_, input_coll_name_, input_pass_name_, mev_, n_adcs_, noise_, noise_rms_, ns_, pedestal_, pulse_truth_coll_name_, readout_threshold_, save_pulse_truth_info_, and zero_suppression_.

makeTimeDelta()

double hcal::HcalDigiProducer::makeTimeDelta	(	TimeSpreadType	kind,
		std::vector< double > &	parameters ) const

Create a randomized time delta based on the configured time spread type.

Currently defined options are: 0: Gaussian -> parameters[0] = mean, parameters[1] = sigma 1: Uniform -> parameters[0] = min, parameters[1] = max 2: Constant -> parameters[0] = value

Definition at line 35 of file HcalDigiProducer.cxx.

                                                                            {
  switch (kind) {
    case TimeSpreadType::UNIFORM:
      return random_time_->Uniform(parameters[0], parameters[1]);
    case TimeSpreadType::CONSTANT:
      return parameters[0];
    case TimeSpreadType::GAUSSIAN:
      return random_time_->Gaus(parameters[0], parameters[1]);
  }
  return 0;
}

Referenced by produce().

onNewRun()

void hcal::HcalDigiProducer::onNewRun ( const ldmx::RunHeader & runHeader )

overridevirtual

Random number generation.

Reimplemented from framework::EventProcessor.

Definition at line 106 of file HcalDigiProducer.cxx.

                                                    {
  // rms noise in mV
  noise_generator_->setNoise(gain_ * noise_rms_);
  // mean noise amplitude (if using Gaussian Model for the noise) in mV
  noise_generator_->setPedestal(gain_ * pedestal_);
  // threshold for readout in mV
  noise_generator_->setNoiseThreshold(gain_ * readout_threshold_);
 
  // Set up seeds
  const auto& rseed = getCondition<framework::RandomNumberSeedService>(
      framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
  noise_generator_->seedGenerator(
      rseed.getSeed("HcalDigiProducer::NoiseGenerator"));
 
  // Random number generator for layer_ / module_ / cell
  rng_.seed(rseed.getSeed("HcalDigiProducer"));
  // Setting up the read-out chip
  hgcroc_->seedGenerator(rseed.getSeed("HcalDigiProducer::HgcrocEmulator"));
 
  // Random number generator for time shifts
  random_time_ =
      std::make_unique<TRandom2>(rseed.getSeed("HcalDigiProducer::randomTime"));
}

References framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME, gain_, framework::EventProcessor::getCondition(), hgcroc_, noise_generator_, noise_rms_, pedestal_, readout_threshold_, and rng_.

produce()

void hcal::HcalDigiProducer::produce ( framework::Event & event )

overridevirtual

Simulates measurement of pulse and creates digi collection for input event.

Define two pulses: with positive and negative ends. For this we need to: (1) Find the position along the bar: For back Hcal: x (y) for horizontal (vertical) layers. For side Hcal: x (top,bottom) and y (left,right).

(2) Define the end of the bar: The end of an HcalDigiID is based on its distance (x,y) along the bar.

• A positive end (endID=0), corresponds to top,left.
• A negative end (endID=1), corresponds to bottom,right. For back Hcal:
• if the position along the bar > 0, the close pulse's end is 0, else 1. For side Hcal:
• if the position along the bar > half_width point of the bar, the close pulse's end is 0, else 1. The far pulse's end will be opposite to the close pulse's end.

(3) Find the distance to each end (positive and negative) from the origin. For the back Hcal, the half point of the bar coincides with the coordinates of the origin. For the side Hcal, the length of the bar from the origin is:

• 2 *(half_width) - Ecal_dx(y_)/2 away from the positive end, and,
• Ecal_dx(y_) away from the negative end.

Now we have all the sub-hits from all the simhits Digitize: For back Hcal return two digis. For side Hcal we choose which pulse to readout based on the position of the hit and the sub-section. For Top and Left we read the positive end digi. For Bottom and Right we read the negative end digi.

Implements framework::Producer.

Definition at line 130 of file HcalDigiProducer.cxx.

                                                    {
  // Get the Hgcroc Conditions
  hgcroc_->condition(
      getCondition<conditions::DoubleTableCondition>("HcalHgcrocConditions"));
 
  // Get the Hcal Geometry
  const auto& hcal_geometry = getCondition<ldmx::HcalGeometry>(
      ldmx::HcalGeometry::CONDITIONS_OBJECT_NAME);
 
  // Empty collection to be filled
  ldmx::HgcrocDigiCollection hcal_digis;
  hcal_digis.setNumSamplesPerDigi(n_adcs_);
  hcal_digis.setSampleOfInterestIndex(i_soi_);
 
  std::map<unsigned int, std::vector<const ldmx::SimCalorimeterHit*>>
      hits_by_id;
 
  // get simulated hcal hits from Geant4 and group them by id
  auto hcal_sim_hits{event.getCollection<ldmx::SimCalorimeterHit>(
      input_coll_name_, input_pass_name_)};
 
  for (auto const& sim_hit : hcal_sim_hits) {
    // get ID
    unsigned int hit_id = sim_hit.getID();
 
    auto idh = hits_by_id.find(hit_id);
    if (idh == hits_by_id.end()) {
      hits_by_id[hit_id] =
          std::vector<const ldmx::SimCalorimeterHit*>(1, &sim_hit);
    } else {
      idh->second.push_back(&sim_hit);
    }
  }
 
  ldmx::HgcrocPulseTruthCollection hcal_pulse_truth_coll;
  if (save_pulse_truth_info_) {
    hgcroc_->pulse_truth_coll_ = &hcal_pulse_truth_coll;
    hgcroc_->save_pulse_truth_info_ = true;
  }
 
  /******************************************************************************************
   * HGCROC Emulation on Simulated Hits (grouped by HcalID)
   ******************************************************************************************/
  double time_delta{flat_time_shift_};
  if (do_time_spread_per_spill_) {
    time_delta += makeTimeDelta(time_spread_per_spill_type_,
                                time_spread_per_spill_parameters_);
  }
  for (auto const& sim_bar : hits_by_id) {
    ldmx::HcalID det_id(sim_bar.first);
    int section = det_id.section();
    int layer = det_id.layer();
    int strip = det_id.strip();
 
    // get position
    double half_total_width = hcal_geometry.getHalfTotalWidth(section, layer);
    double ecal_dx = hcal_geometry.getEcalDx();
    double ecal_dy = hcal_geometry.getEcalDy();
 
    // contributions
    std::vector<std::pair<double, double>> pulses_posend;
    std::vector<std::pair<double, double>> pulses_negend;
 
    for (auto psim_hit : sim_bar.second) {
      const ldmx::SimCalorimeterHit& sim_hit = *psim_hit;
 
      std::vector<float> position = sim_hit.getPosition();
 
      float distance_along_bar, distance_ecal;
      float distance_close, distance_far;
      int end_close;
      const auto orientation{hcal_geometry.getScintillatorOrientation(det_id)};
      if (section == ldmx::HcalID::HcalSection::BACK) {
        distance_along_bar =
            (orientation ==
             ldmx::HcalGeometry::ScintillatorOrientation::horizontal)
                ? position[0]
                : position[1];
        end_close = (distance_along_bar > 0) ? 0 : 1;
        distance_close = half_total_width;
        distance_far = half_total_width;
      } else {
        if ((section == ldmx::HcalID::HcalSection::TOP) ||
            ((section == ldmx::HcalID::HcalSection::BOTTOM))) {
          distance_along_bar = position[0];
          distance_ecal = ecal_dx;
        } else if ((section == ldmx::HcalID::HcalSection::LEFT) ||
                   (section == ldmx::HcalID::HcalSection::RIGHT)) {
          distance_along_bar = position[1];
          distance_ecal = ecal_dy;
        } else {
          distance_along_bar = -9999.;
          EXCEPTION_RAISE(
              "BadCode",
              "We should never end up here "
              "All cases of HCAL considered, end_close is meaningless");
        }
        end_close = (distance_along_bar > half_total_width) ? 0 : 1;
        distance_close = (end_close == 0)
                             ? 2 * half_total_width - distance_ecal / 2
                             : distance_ecal / 2;
        distance_far = (end_close == 0)
                           ? distance_ecal / 2
                           : 2 * half_total_width - distance_ecal / 2;
      }
 
      // Calculate voltage attenuation and time shift for the close and far
      // pulse.
      // velocity of light in Polystyrene, n = 1.6 = c/v mm/ns
      float v = 299.792 / 1.6;
      double att_close =
          exp(-1. * ((distance_close - fabs(distance_along_bar)) / 1000.) /
              attlength_);
      double att_far =
          exp(-1. * ((distance_far + fabs(distance_along_bar)) / 1000.) /
              attlength_);
      double shift_close =
          fabs((distance_close - fabs(distance_along_bar)) / v);
      double shift_far = fabs((distance_far + fabs(distance_along_bar)) / v);
 
      // Get voltages and times.
      for (int i_contrib = 0; i_contrib < sim_hit.getNumberOfContribs();
           i_contrib++) {
        double voltage = sim_hit.getContrib(i_contrib).edep_ * mev_;
        // global time (t=0ns at target)
        double time = sim_hit.getContrib(i_contrib).time_;
        // shift light-speed particle traveling along z_
        time -= position.at(2) / 299.702547;
        if (do_time_spread_per_hit_) {
          time += makeTimeDelta(time_spread_per_hit_type_,
                                time_spread_per_hit_parameters_);
        }
        time += time_delta;
 
        if (end_close == 0) {
          pulses_posend.emplace_back(voltage * att_close, time + shift_close);
          pulses_negend.emplace_back(voltage * att_far, time + shift_far);
        } else {
          pulses_posend.emplace_back(voltage * att_far, time + shift_far);
          pulses_negend.emplace_back(voltage * att_close, time + shift_close);
        }
      }
    }
 
    if (section == ldmx::HcalID::HcalSection::BACK) {
      std::vector<ldmx::HgcrocDigiCollection::Sample> digi_to_add_posend,
          digi_to_add_negend;
      ldmx::HcalDigiID posend_id(section, layer, strip, 0);
      ldmx::HcalDigiID negend_id(section, layer, strip, 1);
 
      bool pos_end_activity =
          hgcroc_->digitize(posend_id.raw(), pulses_posend, digi_to_add_posend);
      bool neg_end_activity =
          hgcroc_->digitize(negend_id.raw(), pulses_negend, digi_to_add_negend);
 
      if (pos_end_activity && neg_end_activity && zero_suppression_) {
        hcal_digis.addDigi(posend_id.raw(), digi_to_add_posend);
        hcal_digis.addDigi(negend_id.raw(), digi_to_add_negend);
      }  // If zeroSuppression == true, Back Hcal needs to digitize both
         // pulses or none
 
      if (!zero_suppression_) {
        if (pos_end_activity) {
          hcal_digis.addDigi(posend_id.raw(), digi_to_add_posend);
        } else {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(posend_id.raw(), 0.0);
          hcal_digis.addDigi(posend_id.raw(), digi);
        }
        if (neg_end_activity) {
          hcal_digis.addDigi(negend_id.raw(), digi_to_add_negend);
        } else {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(negend_id.raw(), 0.0);
          hcal_digis.addDigi(negend_id.raw(), digi);
        }
      }
 
    } else {
      bool is_posend = false;
      std::vector<ldmx::HgcrocDigiCollection::Sample> digi_to_add;
      if ((section == ldmx::HcalID::HcalSection::TOP) ||
          (section == ldmx::HcalID::HcalSection::LEFT)) {
        is_posend = true;
      } else if ((section == ldmx::HcalID::HcalSection::BOTTOM) ||
                 (section == ldmx::HcalID::HcalSection::RIGHT)) {
        is_posend = false;
      }
      if (is_posend) {
        ldmx::HcalDigiID digi_id(section, layer, strip, 0);
        if (hgcroc_->digitize(digi_id.raw(), pulses_posend, digi_to_add)) {
          hcal_digis.addDigi(digi_id.raw(), digi_to_add);
        } else if (!zero_suppression_) {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(digi_id.raw(), 0.0);
          hcal_digis.addDigi(digi_id.raw(), digi);
        }
      } else {
        ldmx::HcalDigiID digi_id(section, layer, strip, 1);
        if (hgcroc_->digitize(digi_id.raw(), pulses_negend, digi_to_add)) {
          hcal_digis.addDigi(digi_id.raw(), digi_to_add);
        } else if (!zero_suppression_) {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(digi_id.raw(), 0.0);
          hcal_digis.addDigi(digi_id.raw(), digi);
        }
      }
    }
  }
 
  /******************************************************************************************
   * Noise Simulation on Empty Channels
   *****************************************************************************************/
  if (noise_) {
    std::vector<ldmx::HcalDigiID> channel_map;
    int num_channels = 0;
    for (int section = 0; section < hcal_geometry.getNumSections(); section++) {
      for (int layer = 1; layer <= hcal_geometry.getNumLayers(section);
           layer++) {
        // Note zero-indexed strip numbering...
        for (int strip = 0; strip < hcal_geometry.getNumStrips(section, layer);
             strip++) {
          if (section == ldmx::HcalID::HcalSection::BACK) {
            auto digi_i_dend0 = ldmx::HcalDigiID(section, layer, strip, 0);
            auto digi_i_dend1 = ldmx::HcalDigiID(section, layer, strip, 1);
            channel_map.push_back(digi_i_dend0);
            channel_map.push_back(digi_i_dend1);
            num_channels += 2;
          } else {
            auto digi_id = ldmx::HcalDigiID(section, layer, strip, 0);
            channel_map.push_back(digi_id);
            num_channels++;
          }
        }
      }
    }
 
    // Uniform distributions for integer generation
    std::uniform_int_distribution<int> section_dist(
        0, hcal_geometry.getNumSections() - 1);
    std::uniform_int_distribution<int> end_dist(0, 1);
    std::uniform_int_distribution<int> clock_dist(0, clock_cycle_);
 
    // Fast noise sim
    if (zero_suppression_) {
      int num_empty_channels = num_channels - hcal_digis.getNumDigis();
      // noise generator gives us a list of noise amplitudes [mV] that randomly
      // populate the empty channels and are above the readout threshold
      auto noise_hit_amplitudes{
          noise_generator_->generateNoiseHits(num_empty_channels)};
      std::vector<std::pair<double, double>> fake_pulse(1, {0., 0.});
 
      for (double noise_hit : noise_hit_amplitudes) {
        // generate detector ID for noise hit
        // making sure that it is in an empty channel
        unsigned int noise_id;
        int section_id, layer_id, strip_id, end_id;
        do {
          // Get a random section value
          section_id = section_dist(rng_);
 
          // Get a random value for the layer_
          std::uniform_int_distribution<int> layer_dist(
              0, hcal_geometry.getNumLayers(section_id) - 1);
          layer_id = layer_dist(rng_);
          // set layer_ to 1 if the generator says it is 0 (geometry map starts
          // from 1)
          if (layer_id == 0) layer_id = 1;
 
          // Get a random value for the  strip
          std::uniform_int_distribution<int> strips_dist(
              0, hcal_geometry.getNumStrips(section_id, layer_id) - 1);
          strip_id = strips_dist(rng_);
 
          //  Get a random value for the  end
          if ((section_id == ldmx::HcalID::HcalSection::TOP) ||
              (section_id == ldmx::HcalID::HcalSection::LEFT)) {
            end_id = 0;
          } else if ((section_id == ldmx::HcalID::HcalSection::BOTTOM) ||
                     (section_id == ldmx::HcalID::HcalSection::RIGHT)) {
            end_id = 1;
          } else {
            end_id = end_dist(rng_);
          }
          auto det_id =
              ldmx::HcalDigiID(section_id, layer_id, strip_id, end_id);
          noise_id = det_id.raw();
        } while (hits_by_id.find(noise_id) != hits_by_id.end());
        hits_by_id[noise_id] =
            std::vector<const ldmx::SimCalorimeterHit*>();  // mark this as used
 
        // get a time for this noise hit
        fake_pulse[0].second = clock_dist(rng_);
 
        // noise generator gives the amplitude above the readout threshold
        // we need to convert it to the amplitude above the pedestal
        double gain = hgcroc_->gain(noise_id);
        fake_pulse[0].first = noise_hit +
                              gain * hgcroc_->readoutThreshold(noise_id) -
                              gain * hgcroc_->pedestal(noise_id);
 
        if (section_id == ldmx::HcalID::HcalSection::BACK) {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi_to_add_posend,
              digi_to_add_negend;
          ldmx::HcalDigiID posend_id(section_id, layer_id, strip_id, 0);
          ldmx::HcalDigiID negend_id(section_id, layer_id, strip_id, 1);
          if (hgcroc_->digitize(posend_id.raw(), fake_pulse,
                                digi_to_add_posend) &&
              hgcroc_->digitize(negend_id.raw(), fake_pulse,
                                digi_to_add_negend)) {
            hcal_digis.addDigi(posend_id.raw(), digi_to_add_posend);
            hcal_digis.addDigi(negend_id.raw(), digi_to_add_negend);
          }
        } else {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi_to_add;
          if (hgcroc_->digitize(noise_id, fake_pulse, digi_to_add)) {
            hcal_digis.addDigi(noise_id, digi_to_add);
          }
        }
      }  // loop over noise amplitudes
    } else {  // If zero_suppression_ == false, add noise digis for all bars
              // without simhits
      for (auto digi_id : channel_map) {
        // Convert from digi ID to det ID (since simhits don't know about
        // different ends of the bar)
        ldmx::HcalID detid(digi_id.section(), digi_id.layer(), digi_id.strip());
        unsigned int rawdet_id = detid.raw();
        if (hits_by_id.find(rawdet_id) == hits_by_id.end()) {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(digi_id.raw(), 0.0);
          hcal_digis.addDigi(digi_id.raw(), digi);
        }
      }
    }
  }  // if we should add noise
 
  event.add(digi_coll_name_, hcal_digis);
  if (save_pulse_truth_info_)
    event.add(pulse_truth_coll_name_, hcal_pulse_truth_coll);
 
  return;
}  // produce

References ldmx::HgcrocDigiCollection::addDigi(), attlength_, clock_cycle_, ldmx::HcalGeometry::CONDITIONS_OBJECT_NAME, digi_coll_name_, ldmx::SimCalorimeterHit::Contrib::edep_, framework::EventProcessor::getCondition(), ldmx::SimCalorimeterHit::getContrib(), ldmx::SimCalorimeterHit::getNumberOfContribs(), ldmx::HgcrocDigiCollection::getNumDigis(), ldmx::SimCalorimeterHit::getPosition(), hgcroc_, i_soi_, input_coll_name_, input_pass_name_, ldmx::HcalID::layer(), makeTimeDelta(), mev_, n_adcs_, noise_, noise_generator_, pulse_truth_coll_name_, ldmx::DetectorID::raw(), rng_, save_pulse_truth_info_, ldmx::HgcrocDigiCollection::setNumSamplesPerDigi(), ldmx::HgcrocDigiCollection::setSampleOfInterestIndex(), ldmx::HcalID::strip(), ldmx::SimCalorimeterHit::Contrib::time_, and zero_suppression_.

Member Data Documentation

attlength_

double hcal::HcalDigiProducer::attlength_

private

Strip attenuation length [m].

Definition at line 97 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

clock_cycle_

double hcal::HcalDigiProducer::clock_cycle_

private

Time interval for chip clock in ns.

Definition at line 85 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

digi_coll_name_

std::string hcal::HcalDigiProducer::digi_coll_name_

private

output hit collection name

Definition at line 79 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

do_time_spread_per_hit_

bool hcal::HcalDigiProducer::do_time_spread_per_hit_ {false}

private

Definition at line 125 of file HcalDigiProducer.h.

{false};

do_time_spread_per_spill_

bool hcal::HcalDigiProducer::do_time_spread_per_spill_ {false}

private

Definition at line 121 of file HcalDigiProducer.h.

{false};

flat_time_shift_

double hcal::HcalDigiProducer::flat_time_shift_ {0.}

private

Definition at line 129 of file HcalDigiProducer.h.

{0.};

gain_

double hcal::HcalDigiProducer::gain_

private

Read out gain.

Definition at line 136 of file HcalDigiProducer.h.

Referenced by configure(), and onNewRun().

hgcroc_

std::unique_ptr<ldmx::HgcrocEmulator> hcal::HcalDigiProducer::hgcroc_

private

Hgcroc Emulator to digitize analog voltage signals.

Definition at line 115 of file HcalDigiProducer.h.

Referenced by configure(), onNewRun(), and produce().

i_soi_

int hcal::HcalDigiProducer::i_soi_

private

Index for the Sample Of Interest in the list of digi samples.

Definition at line 91 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

input_coll_name_

std::string hcal::HcalDigiProducer::input_coll_name_

private

input hit collection name

Definition at line 73 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

input_pass_name_

std::string hcal::HcalDigiProducer::input_pass_name_

private

input pass name

Definition at line 76 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

mev_

double hcal::HcalDigiProducer::mev_

private

Conversion from energy in MeV to voltage in mV.

Definition at line 94 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

n_adcs_

int hcal::HcalDigiProducer::n_adcs_

private

Depth of ADC buffer.

Definition at line 88 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

noise_

bool hcal::HcalDigiProducer::noise_ {true}

private

Put noise into empty channels, not configurable, only helpful in development.

Definition at line 104 of file HcalDigiProducer.h.

{true};

Referenced by configure(), and produce().

noise_generator_

std::unique_ptr<ldmx::NoiseGenerator> hcal::HcalDigiProducer::noise_generator_

private

Generates noise hits based off of number of cells that are not hit.

Definition at line 141 of file HcalDigiProducer.h.

Referenced by HcalDigiProducer(), onNewRun(), and produce().

noise_rms_

double hcal::HcalDigiProducer::noise_rms_

private

Noise RMS.

Definition at line 138 of file HcalDigiProducer.h.

Referenced by configure(), and onNewRun().

ns_

double hcal::HcalDigiProducer::ns_

private

Conversion from time in ns to ticks of the internal clock.

Definition at line 118 of file HcalDigiProducer.h.

Referenced by configure().

pedestal_

double hcal::HcalDigiProducer::pedestal_

private

Read out pedestal.

Definition at line 134 of file HcalDigiProducer.h.

Referenced by configure(), and onNewRun().

pulse_truth_coll_name_

std::string hcal::HcalDigiProducer::pulse_truth_coll_name_

private

output pulse truth collection name

Definition at line 82 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

random_time_

std::unique_ptr<TRandom2> hcal::HcalDigiProducer::random_time_

private

Definition at line 120 of file HcalDigiProducer.h.

readout_threshold_

double hcal::HcalDigiProducer::readout_threshold_

private

Read out threshold.

Definition at line 132 of file HcalDigiProducer.h.

Referenced by configure(), and onNewRun().

rng_

std::mt19937 hcal::HcalDigiProducer::rng_

private

Generates Gaussian noise on top of real hits_.

Definition at line 144 of file HcalDigiProducer.h.

Referenced by onNewRun(), and produce().

save_pulse_truth_info_

bool hcal::HcalDigiProducer::save_pulse_truth_info_ {false}

private

If true, save the "analog" composite pulse shape in the HGCROC emulator before it gets digitized.

Definition at line 108 of file HcalDigiProducer.h.

{false};

Referenced by configure(), and produce().

time_spread_per_hit_parameters_

std::vector<double> hcal::HcalDigiProducer::time_spread_per_hit_parameters_ {}

private

Definition at line 127 of file HcalDigiProducer.h.

{};

time_spread_per_hit_type_

TimeSpreadType hcal::HcalDigiProducer::time_spread_per_hit_type_ {TimeSpreadType::GAUSSIAN}

private

Definition at line 126 of file HcalDigiProducer.h.

{TimeSpreadType::GAUSSIAN};

time_spread_per_spill_parameters_

std::vector<double> hcal::HcalDigiProducer::time_spread_per_spill_parameters_ {}

private

Definition at line 123 of file HcalDigiProducer.h.

{};

time_spread_per_spill_type_

TimeSpreadType hcal::HcalDigiProducer::time_spread_per_spill_type_ {TimeSpreadType::UNIFORM}

private

Definition at line 122 of file HcalDigiProducer.h.

{TimeSpreadType::UNIFORM};

zero_suppression_

bool hcal::HcalDigiProducer::zero_suppression_ {true}

private

If false, save digis from all channels, even pure noise in empty bars Helpful when comparing with test beam data.

Definition at line 112 of file HcalDigiProducer.h.

{true};

Referenced by configure(), and produce().

---

The documentation for this class was generated from the following files:

• Hcal/include/Hcal/HcalDigiProducer.h
• Hcal/src/Hcal/HcalDigiProducer.cxx