Performs basic HCal digitization. More...

#include <HcalDigiProducer.h>

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.

Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.

virtual void	beforeNewRun (ldmx::RunHeader &header)
	Handle allowing producers to modify run headers before the run begins.

Public Member Functions inherited from framework::EventProcessor
	EventProcessor (const std::string &name, Process &process)
	Class constructor.

virtual	~EventProcessor ()
	Class destructor.

virtual void	onNewRun (const ldmx::RunHeader &runHeader)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.

virtual void	onFileOpen (EventFile &eventFile)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.

virtual void	onFileClose (EventFile &eventFile)
	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	inputCollName_
	input hit collection name

std::string	inputPassName_
	input pass name

std::string	digiCollName_
	output hit collection name

double	clockCycle_
	Time interval for chip clock in ns.

int	nADCs_
	Depth of ADC buffer.

int	iSOI_
	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	zeroSuppression_ {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< ldmx::NoiseGenerator >	noiseGenerator_
	Generates noise hits based off of number of cells that are not hit.

std::unique_ptr< TRandom3 >	noiseInjector_
	Generates Gaussian noise on top of real hits.

Additional Inherited Members
Static Public Member Functions inherited from framework::EventProcessor
static void	declare (const std::string &classname, int classtype, EventProcessorMaker *)
	Internal function which is part of the PluginFactory machinery.

Static Public Attributes inherited from framework::Producer
static const int	CLASSTYPE {1}
	Constant used to track EventProcessor types by the PluginFactory.

Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Protected Attributes inherited from framework::EventProcessor
HistogramHelper	histograms_
	Interface class for making and filling histograms.

NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.

logging::logger	theLog_
	The logger for this EventProcessor.

Detailed Description

Performs basic HCal digitization.

Definition at line 29 of file HcalDigiProducer.h.

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 15 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)
   */
  noiseGenerator_ = std::make_unique<ldmx::NoiseGenerator>();
}

References noiseGenerator_.

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 28 of file HcalDigiProducer.cxx.

                                                              {
  // settings of readout chip
  //  used  in actual digitization
  auto hgcrocParams = ps.getParameter<framework::config::Parameters>("hgcroc");
  hgcroc_ = std::make_unique<ldmx::HgcrocEmulator>(hgcrocParams);
  clockCycle_ = hgcrocParams.getParameter<double>("clockCycle");
  nADCs_ = hgcrocParams.getParameter<int>("nADCs");
  iSOI_ = hgcrocParams.getParameter<int>("iSOI");
  noise_ = hgcrocParams.getParameter<bool>("noise");
 
  // If true, ignore readout threshold
  // and generate pedestal noise digis in every empty channel
  zeroSuppression_ = ps.getParameter<bool>("zeroSuppression");
 
  // collection names
  inputCollName_ = ps.getParameter<std::string>("inputCollName");
  inputPassName_ = ps.getParameter<std::string>("inputPassName");
  digiCollName_ = ps.getParameter<std::string>("digiCollName");
 
  // physical constants
  //  used to calculate unit conversions
  MeV_ = ps.getParameter<double>("MeV");
  attlength_ = ps.getParameter<double>("attenuationLength");
 
  // Time -> clock counts conversion
  //  time [ns] * ( 2^10 / max time in ns ) = clock counts
  ns_ = 1024. / clockCycle_;
 
  // Configure generator that will produce noise hits in empty channels
  double readoutThreshold = ps.getParameter<double>("avgReadoutThreshold");
  double gain = ps.getParameter<double>("avgGain");
  double pedestal = ps.getParameter<double>("avgPedestal");
  // rms noise in mV
  noiseGenerator_->setNoise(gain * ps.getParameter<double>("avgNoiseRMS"));
  // mean noise amplitude (if using Gaussian Model for the noise) in mV
  noiseGenerator_->setPedestal(gain * pedestal);
  // threshold for readout in mV
  noiseGenerator_->setNoiseThreshold(gain * readoutThreshold);
}

References attlength_, clockCycle_, digiCollName_, framework::config::Parameters::getParameter(), hgcroc_, inputCollName_, inputPassName_, iSOI_, MeV_, nADCs_, noise_, noiseGenerator_, ns_, and zeroSuppression_.

◆ 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 68 of file HcalDigiProducer.cxx.

                                                    {
  // Handle seeding on the first event
  if (!noiseGenerator_->hasSeed()) {
    const auto& rseed = getCondition<framework::RandomNumberSeedService>(
        framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
    noiseGenerator_->seedGenerator(
        rseed.getSeed("HcalDigiProducer::NoiseGenerator"));
  }
  if (noiseInjector_.get() == nullptr) {
    const auto& rseed = getCondition<framework::RandomNumberSeedService>(
        framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
    noiseInjector_ = std::make_unique<TRandom3>(
        rseed.getSeed("HcalDigiProducer::NoiseInjector"));
  }
  if (!hgcroc_->hasSeed()) {
    const auto& rseed = getCondition<framework::RandomNumberSeedService>(
        framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
    hgcroc_->seedGenerator(rseed.getSeed("HcalDigiProducer::HgcrocEmulator"));
  }
 
  // Get the Hgcroc Conditions
  hgcroc_->condition(
      getCondition<conditions::DoubleTableCondition>("HcalHgcrocConditions"));
 
  // Get the Hcal Geometry
  const auto& hcalGeometry = getCondition<ldmx::HcalGeometry>(
      ldmx::HcalGeometry::CONDITIONS_OBJECT_NAME);
 
  // Empty collection to be filled
  ldmx::HgcrocDigiCollection hcalDigis;
  hcalDigis.setNumSamplesPerDigi(nADCs_);
  hcalDigis.setSampleOfInterestIndex(iSOI_);
 
  std::map<unsigned int, std::vector<const ldmx::SimCalorimeterHit*>> hitsByID;
 
  // get simulated hcal hits from Geant4 and group them by id
  auto hcalSimHits{event.getCollection<ldmx::SimCalorimeterHit>(
      inputCollName_, inputPassName_)};
 
  for (auto const& simHit : hcalSimHits) {
    // get ID
    unsigned int hitID = simHit.getID();
 
    auto idh = hitsByID.find(hitID);
    if (idh == hitsByID.end()) {
      hitsByID[hitID] = std::vector<const ldmx::SimCalorimeterHit*>(1, &simHit);
    } else {
      idh->second.push_back(&simHit);
    }
  }
 
  /******************************************************************************************
   * HGCROC Emulation on Simulated Hits (grouped by HcalID)
   ******************************************************************************************/
  for (auto const& simBar : hitsByID) {
    ldmx::HcalID detID(simBar.first);
    int section = detID.section();
    int layer = detID.layer();
    int strip = detID.strip();
 
    // get position
    double half_total_width = hcalGeometry.getHalfTotalWidth(section, layer);
    double ecal_dx = hcalGeometry.getEcalDx();
    double ecal_dy = hcalGeometry.getEcalDy();
 
    // contributions
    std::vector<std::pair<double, double>> pulses_posend;
    std::vector<std::pair<double, double>> pulses_negend;
 
    for (auto psimHit : simBar.second) {
      const ldmx::SimCalorimeterHit& simHit = *psimHit;
 
      std::vector<float> position = simHit.getPosition();
 
      float distance_along_bar, distance_ecal;
      float distance_close, distance_far;
      int end_close;
      const auto orientation{hcalGeometry.getScintillatorOrientation(detID)};
      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.
      float v = 299.792 /
                1.6;  // velocity of light in Polystyrene, n = 1.6 = c/v mm/ns
      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 iContrib = 0; iContrib < simHit.getNumberOfContribs();
           iContrib++) {
        double voltage = simHit.getContrib(iContrib).edep * MeV_;
        double time =
            simHit.getContrib(iContrib).time;  // global time (t=0ns at target)
        time -= position.at(2) /
                299.702547;  // shift light-speed particle traveling along z
 
        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> digiToAddPosend,
          digiToAddNegend;
      ldmx::HcalDigiID posendID(section, layer, strip, 0);
      ldmx::HcalDigiID negendID(section, layer, strip, 1);
 
      bool posEndActivity =
          hgcroc_->digitize(posendID.raw(), pulses_posend, digiToAddPosend);
      bool negEndActivity =
          hgcroc_->digitize(negendID.raw(), pulses_negend, digiToAddNegend);
 
      if (posEndActivity && negEndActivity && zeroSuppression_) {
        hcalDigis.addDigi(posendID.raw(), digiToAddPosend);
        hcalDigis.addDigi(negendID.raw(), digiToAddNegend);
      }  // If zeroSuppression == true, Back Hcal needs to digitize both
         // pulses or none
 
      if (!zeroSuppression_) {
        if (posEndActivity) {
          hcalDigis.addDigi(posendID.raw(), digiToAddPosend);
        } else {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(posendID.raw(), 0.0);
          hcalDigis.addDigi(posendID.raw(), digi);
        }
        if (negEndActivity) {
          hcalDigis.addDigi(posendID.raw(), digiToAddPosend);
        } else {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(negendID.raw(), 0.0);
          hcalDigis.addDigi(negendID.raw(), digi);
        }
      }
 
    } else {
      bool is_posend = false;
      std::vector<ldmx::HgcrocDigiCollection::Sample> digiToAdd;
      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 digiID(section, layer, strip, 0);
        if (hgcroc_->digitize(digiID.raw(), pulses_posend, digiToAdd)) {
          hcalDigis.addDigi(digiID.raw(), digiToAdd);
        } else if (!zeroSuppression_) {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(digiID.raw(), 0.0);
          hcalDigis.addDigi(digiID.raw(), digi);
        }
      } else {
        ldmx::HcalDigiID digiID(section, layer, strip, 1);
        if (hgcroc_->digitize(digiID.raw(), pulses_negend, digiToAdd)) {
          hcalDigis.addDigi(digiID.raw(), digiToAdd);
        } else if (!zeroSuppression_) {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(digiID.raw(), 0.0);
          hcalDigis.addDigi(digiID.raw(), digi);
        }
      }
    }
  }
 
  /******************************************************************************************
   * Noise Simulation on Empty Channels
   *****************************************************************************************/
  if (noise_) {
    std::vector<ldmx::HcalDigiID> channelMap;
    int numChannels = 0;
    for (int section = 0; section < hcalGeometry.getNumSections(); section++) {
      int numChannelsInSection = 0;
      for (int layer = 1; layer <= hcalGeometry.getNumLayers(section);
           layer++) {
        numChannelsInSection += hcalGeometry.getNumStrips(section, layer);
        // Note zero-indexed strip numbering...
        for (int strip = 0; strip < hcalGeometry.getNumStrips(section, layer);
             strip++) {
          if (section == ldmx::HcalID::HcalSection::BACK) {
            auto digiIDend0 = ldmx::HcalDigiID(section, layer, strip, 0);
            auto digiIDend1 = ldmx::HcalDigiID(section, layer, strip, 1);
            channelMap.push_back(digiIDend0);
            channelMap.push_back(digiIDend1);
            numChannels += 2;
          } else {
            auto digiID = ldmx::HcalDigiID(section, layer, strip, 0);
            channelMap.push_back(digiID);
            numChannels++;
          }
        }
      }
    }
 
    if (zeroSuppression_) {  // Fast noise sim
      int numEmptyChannels = numChannels - hcalDigis.getNumDigis();
      // noise generator gives us a list of noise amplitudes [mV] that randomly
      // populate the empty channels and are above the readout threshold
      auto noiseHitAmplitudes{
          noiseGenerator_->generateNoiseHits(numEmptyChannels)};
      std::vector<std::pair<double, double>> fake_pulse(1, {0., 0.});
      for (double noiseHit : noiseHitAmplitudes) {
        // generate detector ID for noise hit
        // making sure that it is in an empty channel
        unsigned int noiseID;
        int sectionID, layerID, stripID, endID;
        do {
          sectionID = noiseInjector_->Integer(hcalGeometry.getNumSections());
          layerID =
              noiseInjector_->Integer(hcalGeometry.getNumLayers(sectionID));
          // set layer to 1 if the generator says it is 0 (geometry map starts
          // from 1)
          if (layerID == 0) layerID = 1;
          stripID = noiseInjector_->Integer(
              hcalGeometry.getNumStrips(sectionID, layerID));
          endID = noiseInjector_->Integer(2);
          if ((sectionID == ldmx::HcalID::HcalSection::TOP) ||
              (sectionID == ldmx::HcalID::HcalSection::LEFT)) {
            endID = 0;
          } else if ((sectionID == ldmx::HcalID::HcalSection::BOTTOM) ||
                     (sectionID == ldmx::HcalID::HcalSection::RIGHT)) {
            endID = 1;
          }
          auto detID = ldmx::HcalDigiID(sectionID, layerID, stripID, endID);
          noiseID = detID.raw();
        } while (hitsByID.find(noiseID) != hitsByID.end());
        hitsByID[noiseID] =
            std::vector<const ldmx::SimCalorimeterHit*>();  // mark this as used
 
        // get a time for this noise hit
        fake_pulse[0].second = noiseInjector_->Uniform(clockCycle_);
 
        // noise generator gives the amplitude above the readout threshold
        // we need to convert it to the amplitude above the pedestal
        double gain = hgcroc_->gain(noiseID);
        fake_pulse[0].first = noiseHit +
                              gain * hgcroc_->readoutThreshold(noiseID) -
                              gain * hgcroc_->pedestal(noiseID);
 
        if (sectionID == ldmx::HcalID::HcalSection::BACK) {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digiToAddPosend,
              digiToAddNegend;
          ldmx::HcalDigiID posendID(sectionID, layerID, stripID, 0);
          ldmx::HcalDigiID negendID(sectionID, layerID, stripID, 1);
          if (hgcroc_->digitize(posendID.raw(), fake_pulse, digiToAddPosend) &&
              hgcroc_->digitize(negendID.raw(), fake_pulse, digiToAddNegend)) {
            hcalDigis.addDigi(posendID.raw(), digiToAddPosend);
            hcalDigis.addDigi(negendID.raw(), digiToAddNegend);
          }
        } else {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digiToAdd;
          if (hgcroc_->digitize(noiseID, fake_pulse, digiToAdd)) {
            hcalDigis.addDigi(noiseID, digiToAdd);
          }
        }
      }       // loop over noise amplitudes
    } else {  // If zeroSuppression_ == false, add noise digis for all bars
              // without simhits
      for (auto digiID : channelMap) {
        // Convert from digi ID to det ID (since simhits don't know about
        // different ends of the bar)
        ldmx::HcalID detid(digiID.section(), digiID.layer(), digiID.strip());
        unsigned int rawdetID = detid.raw();
        if (hitsByID.find(rawdetID) == hitsByID.end()) {
          std::vector<ldmx::HgcrocDigiCollection::Sample> digi =
              hgcroc_->noiseDigi(digiID.raw(), 0.0);
          hcalDigis.addDigi(digiID.raw(), digi);
        }
      }
    }
  }  // if we should add noise
 
  event.add(digiCollName_, hcalDigis);
 
  return;
}  // produce

References ldmx::HgcrocDigiCollection::addDigi(), attlength_, clockCycle_, ldmx::HcalGeometry::CONDITIONS_OBJECT_NAME, framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME, digiCollName_, ldmx::SimCalorimeterHit::Contrib::edep, ldmx::SimCalorimeterHit::getContrib(), ldmx::SimCalorimeterHit::getID(), ldmx::SimCalorimeterHit::getNumberOfContribs(), ldmx::HgcrocDigiCollection::getNumDigis(), ldmx::SimCalorimeterHit::getPosition(), hgcroc_, inputCollName_, inputPassName_, iSOI_, ldmx::HcalID::layer(), MeV_, nADCs_, noise_, noiseGenerator_, noiseInjector_, ldmx::DetectorID::raw(), ldmx::HgcrocDigiCollection::setNumSamplesPerDigi(), ldmx::HgcrocDigiCollection::setSampleOfInterestIndex(), ldmx::HcalID::strip(), ldmx::SimCalorimeterHit::Contrib::time, and zeroSuppression_.

Member Data Documentation

◆ attlength_

double hcal::HcalDigiProducer::attlength_

private

Strip attenuation length [m].

Definition at line 78 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

◆ clockCycle_

double hcal::HcalDigiProducer::clockCycle_

private

Time interval for chip clock in ns.

Definition at line 66 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

◆ digiCollName_

std::string hcal::HcalDigiProducer::digiCollName_

private

output hit collection name

Definition at line 63 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

◆ hgcroc_

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

private

Hgcroc Emulator to digitize analog voltage signals.

Definition at line 92 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

◆ inputCollName_

std::string hcal::HcalDigiProducer::inputCollName_

private

input hit collection name

Definition at line 57 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

◆ inputPassName_

std::string hcal::HcalDigiProducer::inputPassName_

private

input pass name

Definition at line 60 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

◆ iSOI_

int hcal::HcalDigiProducer::iSOI_

private

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

Definition at line 72 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 75 of file HcalDigiProducer.h.

Referenced by configure(), and produce().

◆ nADCs_

int hcal::HcalDigiProducer::nADCs_

private

Depth of ADC buffer.

Definition at line 69 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 85 of file HcalDigiProducer.h.

85{true};

Referenced by configure(), and produce().

◆ noiseGenerator_

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

private

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

Definition at line 98 of file HcalDigiProducer.h.

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

◆ noiseInjector_

std::unique_ptr<TRandom3> hcal::HcalDigiProducer::noiseInjector_

private

Generates Gaussian noise on top of real hits.

Definition at line 101 of file HcalDigiProducer.h.

Referenced by produce().

◆ ns_

double hcal::HcalDigiProducer::ns_

private

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

Definition at line 95 of file HcalDigiProducer.h.

Referenced by configure().

◆ zeroSuppression_

bool hcal::HcalDigiProducer::zeroSuppression_ {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 89 of file HcalDigiProducer.h.

89{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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HcalDigiProducer()

Member Function Documentation

◆ configure()

◆ produce()

Member Data Documentation

◆ attlength_

◆ clockCycle_

◆ digiCollName_

◆ hgcroc_

◆ inputCollName_

◆ inputPassName_

◆ iSOI_

◆ MeV_

◆ nADCs_

◆ noise_

◆ noiseGenerator_

◆ noiseInjector_

◆ ns_

◆ zeroSuppression_