Performs basic ECal digitization. More...

#include <EcalDigiProducer.h>

Public Member Functions
	EcalDigiProducer (const std::string &name, framework::Process &process)
	Constructor.

virtual	~EcalDigiProducer ()=default
	Destructor.

virtual void	configure (framework::config::Parameters &) override
	Configure this producer from the python configuration.

virtual 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
	Set up random number / noise generation.

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	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.

bool	zero_suppression_
	When emulating noise in empty channels, do we zero suppress?

bool	noise_ {true}
	Put noise into empty channels, not configurable, only helpful in development.

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.

double	readoutThreshold_
	Read out threshold.

double	pedestal_
	Read out pedestal.

double	noiseRMS_
	Noise RMS.

std::unique_ptr< ldmx::NoiseGenerator >	noiseGenerator_
	Generates noise hits based off of number of cells that are not hit.

std::mt19937	rng_
	Generates random numbers for which channels to fill up with noise.

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 ECal digitization.

Definition at line 38 of file EcalDigiProducer.h.

Constructor & Destructor Documentation

◆ EcalDigiProducer()

ecal::EcalDigiProducer::EcalDigiProducer	(	const std::string &	name,
		framework::Process &	process )

inline

Constructor.

Definition at line 43 of file EcalDigiProducer.h.

44 : Producer(name, process) {}

framework::Producer::Producer

Producer(const std::string &name, Process &process)

Class constructor.

Definition EventProcessor.cxx:68

Member Function Documentation

◆ configure()

void ecal::EcalDigiProducer::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 16 of file EcalDigiProducer.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");
 
  // collection names
  inputCollName_ = ps.getParameter<std::string>("inputCollName");
  inputPassName_ = ps.getParameter<std::string>("inputPassName");
  digiCollName_ = ps.getParameter<std::string>("digiCollName");
 
  zero_suppression_ = ps.getParameter<bool>("zero_suppression");
 
  // physical constants
  //  used to calculate unit conversions
  MeV_ = ps.getParameter<double>("MeV");
 
  // Time -> clock counts conversion
  //  time [ns] * ( 2^10 / max time in ns ) = clock counts
  ns_ = 1024. / clockCycle_;
 
  readoutThreshold_ = ps.getParameter<double>("avgReadoutThreshold");
  pedestal_ = ps.getParameter<double>("avgPedestal");
  noiseRMS_ = ps.getParameter<double>("avgNoiseRMS");
}

References clockCycle_, digiCollName_, hgcroc_, inputCollName_, inputPassName_, iSOI_, MeV_, nADCs_, noise_, noiseRMS_, ns_, pedestal_, readoutThreshold_, and zero_suppression_.

◆ onNewRun()

void ecal::EcalDigiProducer::onNewRun ( const ldmx::RunHeader & runHeader )

overridevirtual

Set up random number / noise generation.

Reimplemented from framework::EventProcessor.

Definition at line 46 of file EcalDigiProducer.cxx.

                                                    {
  // 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>();
  // Configure generator that will produce noise hits in empty channels
  // rms noise in mV
  noiseGenerator_->setNoise(noiseRMS_);
  // mean noise amplitude (if using Gaussian Model for the noise) in mV
  noiseGenerator_->setPedestal(pedestal_);
  // threshold for readout in mV
  noiseGenerator_->setNoiseThreshold(readoutThreshold_);
  // Set up seeds
  const auto& rseed = getCondition<framework::RandomNumberSeedService>(
      framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME);
  noiseGenerator_->seedGenerator(
      rseed.getSeed("EcalDigiProducer::NoiseGenerator"));
  // Random number generator for layer / module / cell
  rng_.seed(rseed.getSeed("EcalDigiProducer"));
  // Setting up the read-out chip
  hgcroc_->seedGenerator(rseed.getSeed("EcalDigiProducer::HgcrocEmulator"));
  hgcroc_->condition(
      getCondition<conditions::DoubleTableCondition>("EcalHgcrocConditions"));
}

References framework::RandomNumberSeedService::CONDITIONS_OBJECT_NAME, framework::EventProcessor::getCondition(), hgcroc_, noiseGenerator_, noiseRMS_, pedestal_, readoutThreshold_, and rng_.

◆ produce()

void ecal::EcalDigiProducer::produce ( framework::Event & event )

overridevirtual

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

HACK ALERT The shifting of the time should not be done this sloppily. In reality, each chip has a set time phase that it samples at (relative to target), so the time shifting should be at the emulator level.

Implements framework::Producer.

Definition at line 73 of file EcalDigiProducer.cxx.

                                                    {
  // Empty collection to be filled
  ldmx::HgcrocDigiCollection ecalDigis;
  ecalDigis.setNumSamplesPerDigi(nADCs_);
  ecalDigis.setSampleOfInterestIndex(iSOI_);
 
  // detector IDs that already have a hit in them
  std::set<unsigned int> filledDetIDs;
 
  /******************************************************************************************
   * HGCROC Emulation on Simulated Hits
   *****************************************************************************************/
  // std::cout << "Sim Hits" << std::endl;
  // get simulated ecal hits from Geant4
  //  the class EcalHitIO in the SimApplication module handles the translation
  //  from G4CalorimeterHits to SimCalorimeterHits this class ensures that only
  //  one SimCalorimeterHit is generated per cell, but multiple "contributions"
  //  are still handled within SimCalorimeterHit
  auto ecalSimHits{event.getCollection<ldmx::SimCalorimeterHit>(
      inputCollName_, inputPassName_)};
 
  /* debug printout
  std::cout << "Energy to Voltage Conversion: " << MeV_ << " mV/MeV" <<
  std::endl;
   */
 
  for (auto const& simHit : ecalSimHits) {
    std::vector<std::pair<double, double>> pulses_at_chip;
    for (int iContrib = 0; iContrib < simHit.getNumberOfContribs();
         iContrib++) {
      /* debug printout
      std::cout << simHit.getContrib(iContrib).edep << " MeV" << std::endl;
       */
      pulses_at_chip.emplace_back(
          simHit.getContrib(iContrib).edep * MeV_,
          simHit.getContrib(iContrib).time  // global time (t=0ns at target)
              - simHit.getPosition().at(2) /
                    299.702547  // shift light-speed particle traveling along z
      );
    }
 
    unsigned int hitID = simHit.getID();
    filledDetIDs.insert(hitID);
 
    ldmx_log(debug) << " Emulation of hitID = " << hitID
                    << " with energy = " << simHit.getEdep()
                    << " MeV at time = "
                    << simHit.getTime() -
                           simHit.getPosition().at(2) / 299.702547;
 
    // container emulator uses to write out samples and
    // transfer samples into the digi collection
    std::vector<ldmx::HgcrocDigiCollection::Sample> digiToAdd;
    if (hgcroc_->digitize(hitID, pulses_at_chip, digiToAdd)) {
      ldmx_log(debug) << "  --> The HGCROC will read-out this hit!";
      ecalDigis.addDigi(hitID, digiToAdd);
    }
  }
 
  /******************************************************************************************
   * Noise Simulation on Empty Channels
   *****************************************************************************************/
  if (noise_) {
    // put noise into some empty channels
 
    // geometry constants
    //  These are used in the noise generation so that we can randomly
    //  distribute the noise uniformly throughout the ECal channels.
    const auto& geom = getCondition<ldmx::EcalGeometry>(
        ldmx::EcalGeometry::CONDITIONS_OBJECT_NAME);
    int nEcalLayers = geom.getNumLayers();
    int nModulesPerLayer = geom.getNumModulesPerLayer();
    int nCellsPerModule = geom.getNumCellsPerModule();
    int numEmptyChannels = nEcalLayers * nModulesPerLayer * nCellsPerModule -
                           ecalDigis.getNumDigis();
 
    // Uniform distributions for integer generation
    std::uniform_int_distribution<int> layer_dist(0, nEcalLayers - 1);
    std::uniform_int_distribution<int> module_dist(0, nModulesPerLayer - 1);
    std::uniform_int_distribution<int> cell_dist(0, nCellsPerModule - 1);
 
    if (zero_suppression_) {
      // 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;
        do {
          int layerID = layer_dist(rng_);
          int moduleID = module_dist(rng_);
          int cellID = cell_dist(rng_);
          auto detID = ldmx::EcalID(layerID, moduleID, cellID);
          noiseID = detID.raw();
        } while (filledDetIDs.find(noiseID) != filledDetIDs.end());
        filledDetIDs.insert(noiseID);
 
        // noise generator gives the amplitude above the readout threshold
        //  we need to convert it to the amplitude above the pedestal
        noiseHit +=
            hgcroc_->gain(noiseID) *
            (hgcroc_->readoutThreshold(noiseID) - hgcroc_->pedestal(noiseID));
 
        // create a digi as put it into the collection
        ecalDigis.addDigi(noiseID, hgcroc_->noiseDigi(noiseID, noiseHit));
      }  // loop over noise amplitudes
    } else {
      // no zero suppression, put some noise emulation in **all** empty channels
      // loop through all channels
      for (int layer{0}; layer < nEcalLayers; layer++) {
        for (int module{0}; module < nModulesPerLayer; module++) {
          for (int cell{0}; cell < nCellsPerModule; cell++) {
            unsigned int channel{ldmx::EcalID(layer, module, cell).raw()};
            // check if channel already has a (real) hit in it
            if (filledDetIDs.find(channel) != filledDetIDs.end()) continue;
            // create a digi as put it into the collection
            ecalDigis.addDigi(channel, hgcroc_->noiseDigi(channel));
          }  // cells in each module
        }    // modules in each layer
      }      // layers in ECal
    }        // yes or no zero suppression
  }          // if we should do the noise
 
  event.add(digiCollName_, ecalDigis);
 
  return;
}  // produce

References ldmx::HgcrocDigiCollection::addDigi(), framework::EventProcessor::getCondition(), ldmx::HgcrocDigiCollection::getNumDigis(), hgcroc_, inputCollName_, inputPassName_, iSOI_, MeV_, nADCs_, noise_, noiseGenerator_, ldmx::DetectorID::raw(), rng_, ldmx::HgcrocDigiCollection::setNumSamplesPerDigi(), ldmx::HgcrocDigiCollection::setSampleOfInterestIndex(), and zero_suppression_.

Member Data Documentation

◆ clockCycle_

double ecal::EcalDigiProducer::clockCycle_

private

Time interval for chip clock in ns.

Definition at line 82 of file EcalDigiProducer.h.

Referenced by configure().

◆ digiCollName_

std::string ecal::EcalDigiProducer::digiCollName_

private

output hit collection name

Definition at line 79 of file EcalDigiProducer.h.

Referenced by configure().

◆ hgcroc_

std::unique_ptr<ldmx::HgcrocEmulator> ecal::EcalDigiProducer::hgcroc_

private

Hgcroc Emulator to digitize analog voltage signals.

Definition at line 115 of file EcalDigiProducer.h.

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

◆ inputCollName_

std::string ecal::EcalDigiProducer::inputCollName_

private

input hit collection name

Definition at line 73 of file EcalDigiProducer.h.

Referenced by configure(), and produce().

◆ inputPassName_

std::string ecal::EcalDigiProducer::inputPassName_

private

input pass name

Definition at line 76 of file EcalDigiProducer.h.

Referenced by configure(), and produce().

◆ iSOI_

int ecal::EcalDigiProducer::iSOI_

private

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

Definition at line 88 of file EcalDigiProducer.h.

Referenced by configure(), and produce().

◆ MeV_

double ecal::EcalDigiProducer::MeV_

private

Conversion from energy in MeV to voltage in mV.

Definition at line 91 of file EcalDigiProducer.h.

Referenced by configure(), and produce().

◆ nADCs_

int ecal::EcalDigiProducer::nADCs_

private

Depth of ADC buffer.

Definition at line 85 of file EcalDigiProducer.h.

Referenced by configure(), and produce().

◆ noise_

bool ecal::EcalDigiProducer::noise_ {true}

private

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

Definition at line 112 of file EcalDigiProducer.h.

112{true};

Referenced by configure(), and produce().

◆ noiseGenerator_

std::unique_ptr<ldmx::NoiseGenerator> ecal::EcalDigiProducer::noiseGenerator_

private

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

Definition at line 128 of file EcalDigiProducer.h.

Referenced by onNewRun(), and produce().

◆ noiseRMS_

double ecal::EcalDigiProducer::noiseRMS_

private

Noise RMS.

Definition at line 125 of file EcalDigiProducer.h.

Referenced by configure(), and onNewRun().

◆ ns_

double ecal::EcalDigiProducer::ns_

private

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

Definition at line 118 of file EcalDigiProducer.h.

Referenced by configure().

◆ pedestal_

double ecal::EcalDigiProducer::pedestal_

private

Read out pedestal.

Definition at line 123 of file EcalDigiProducer.h.

Referenced by configure(), and onNewRun().

◆ readoutThreshold_

double ecal::EcalDigiProducer::readoutThreshold_

private

Read out threshold.

Definition at line 121 of file EcalDigiProducer.h.

Referenced by configure(), and onNewRun().

◆ rng_

std::mt19937 ecal::EcalDigiProducer::rng_

private

Generates random numbers for which channels to fill up with noise.

Definition at line 131 of file EcalDigiProducer.h.

Referenced by onNewRun(), and produce().

◆ zero_suppression_

bool ecal::EcalDigiProducer::zero_suppression_

private

When emulating noise in empty channels, do we zero suppress?

There are two ways to emulate the noise in the chip: 1) (with zero suppression) Use the NoiseGenerator to get a list of amplitudes (about 3-5 on avg) and put those noise hits which are above the readout threshold in random empty channels. 2) (without zero suppresion) Go through all channels and put noise in each channel that doesn't have a real hit in it. This will mean many channels with have a DIGI below readout threshold.

Definition at line 105 of file EcalDigiProducer.h.

Referenced by configure(), and produce().

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

Ecal/include/Ecal/EcalDigiProducer.h
Ecal/src/Ecal/EcalDigiProducer.cxx

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ EcalDigiProducer()

Member Function Documentation

◆ configure()

◆ onNewRun()

◆ produce()

Member Data Documentation

◆ clockCycle_

◆ digiCollName_

◆ hgcroc_

◆ inputCollName_

◆ inputPassName_

◆ iSOI_

◆ MeV_

◆ nADCs_

◆ noise_

◆ noiseGenerator_

◆ noiseRMS_

◆ ns_

◆ pedestal_

◆ readoutThreshold_

◆ rng_

◆ zero_suppression_