ESDigitizer Class Reference

#include <ESDigitizer.h>

Inheritance diagram for ESDigitizer:

Classes
class	Triplet

Public Types
typedef ESDigitizerTraits::ElectronicsSim	ElectronicsSim
Public Types inherited from EcalTDigitizer< ESDigitizerTraits >
typedef ESDigitizerTraits::Digi	Digi
typedef ESDigitizerTraits::DigiCollection	DigiCollection
typedef ESDigitizerTraits::EcalSamples	EcalSamples
typedef ESDigitizerTraits::ElectronicsSim	ElectronicsSim

Public Member Functions
	ESDigitizer (EcalHitResponse *hitResponse, ElectronicsSim *electronicsSim, bool addNoise)
void	run (ESDigiCollection &output, CLHEP::HepRandomEngine *) override
	turns hits into digis More...
void	setDetIds (const std::vector< DetId > &detIds)
	tell the digitizer which cells exist; cannot change during a run More...
void	setGain (const int gain)
	~ESDigitizer () override
Public Member Functions inherited from EcalTDigitizer< ESDigitizerTraits >
void	add (const std::vector< PCaloHit > &hits, int bunchCrossing, CLHEP::HepRandomEngine *)
void	addNoiseSignals ()
	EcalTDigitizer (EcalHitResponse *hitResponse, ElectronicsSim *electronicsSim, bool addNoise)
virtual void	initializeHits ()
virtual void	run (MixCollection< PCaloHit > &input, DigiCollection &output)
void	setNoiseSignalGenerator (EcalBaseSignalGenerator *noiseSignalGenerator)
virtual	~EcalTDigitizer ()

Private Member Functions
void	createNoisyList (std::vector< DetId > &abThreshCh, CLHEP::HepRandomEngine *)

Private Attributes
const std::vector< DetId > *	m_detIds
int	m_ESGain
double	m_histoBin
double	m_histoInf
double	m_histoWid
double	m_meanNoisy
CLHEP::RandGeneral *	m_ranGeneral
std::vector< Triplet >	m_trip

Additional Inherited Members
Protected Member Functions inherited from EcalTDigitizer< ESDigitizerTraits >
bool	addNoise () const
const ElectronicsSim *	elecSim () const
const EcalHitResponse *	hitResponse () const

Detailed Description

Definition at line 14 of file ESDigitizer.h.

Member Typedef Documentation

typedef ESDigitizerTraits::ElectronicsSim ESDigitizer::ElectronicsSim

Definition at line 16 of file ESDigitizer.h.

Constructor & Destructor Documentation

ESDigitizer::ESDigitizer	(	EcalHitResponse *	hitResponse,
		ElectronicsSim *	electronicsSim,
		bool	addNoise
	)

Definition at line 13 of file ESDigitizer.cc.

References m_trip.

    : EcalTDigitizer<ESDigitizerTraits>(hitResponse, electronicsSim, addNoise),
      m_detIds(nullptr),
      m_ranGeneral(nullptr),
      m_ESGain(0),
      m_histoBin(0),
      m_histoInf(0),
      m_histoWid(0),
      m_meanNoisy(0),
      m_trip() {
  m_trip.reserve(2500);
}

ESDigitizer::~ESDigitizer ( )

override

Definition at line 26 of file ESDigitizer.cc.

References m_ranGeneral.

{ delete m_ranGeneral; }

Member Function Documentation

void ESDigitizer::createNoisyList ( std::vector< DetId > &  abThreshCh, CLHEP::HepRandomEngine *  engine  )

private

Definition at line 164 of file ESDigitizer.cc.

References cms::cuda::assert(), spr::find(), mps_fire::i, gpuClustering::id, m_detIds, and m_meanNoisy.

Referenced by run().

                                                                                            {
  CLHEP::RandPoissonQ randPoissonQ(*engine, m_meanNoisy);
  const unsigned int nChan(randPoissonQ.fire());
  abThreshCh.reserve(nChan);

  for (unsigned int i(0); i != nChan; ++i) {
    std::vector<DetId>::const_iterator idItr(abThreshCh.end());
    uint32_t iChan(0);
    DetId id;
    do {
      iChan = (uint32_t)CLHEP::RandFlat::shoot(engine, m_detIds->size());
      if (iChan == m_detIds->size())
        --iChan;                         //protect against roundup at end
      assert(m_detIds->size() > iChan);  // sanity check
      id = (*m_detIds)[iChan];
      idItr = find(abThreshCh.begin(), abThreshCh.end(), id);
    } while (idItr != abThreshCh.end());

    abThreshCh.push_back(id);
  }
}

void ESDigitizer::run ( ESDigiCollection &  output, CLHEP::HepRandomEngine *  engine  )

overridevirtual

turns hits into digis

Reimplemented from EcalTDigitizer< ESDigitizerTraits >.

Definition at line 130 of file ESDigitizer.cc.

References EcalTDigitizer< ESDigitizerTraits >::addNoise(), cms::cuda::assert(), createNoisyList(), EcalTDigitizer< ESDigitizerTraits >::elecSim(), EcalHitResponse::findDetId(), EcalTDigitizer< ESDigitizerTraits >::hitResponse(), m_detIds, m_histoInf, m_histoWid, m_meanNoisy, m_ranGeneral, m_trip, ESDigiCollection::push_back(), edm::DataFrameContainer::reserve(), EcalTDigitizer< Traits >::run(), and CaloTSamplesBase< Ttype >::zero().

                                                                            {
  assert(nullptr != m_detIds && !m_detIds->empty() && (!addNoise() || nullptr != m_ranGeneral));  // sanity check

  // reserve space for how many digis we expect, with some cushion
  output.reserve(2 * ((int)m_meanNoisy) + hitResponse()->samplesSize());

  EcalTDigitizer<ESDigitizerTraits>::run(output, engine);

  // random generation of channel above threshold
  std::vector<DetId> abThreshCh;
  if (addNoise())
    createNoisyList(abThreshCh, engine);

  // first make a raw digi for every cell where we have noise
  for (std::vector<DetId>::const_iterator idItr(abThreshCh.begin()); idItr != abThreshCh.end(); ++idItr) {
    if (hitResponse()->findDetId(*idItr)->zero())  // only if no true hit!
    {
      ESHitResponse::ESSamples analogSignal(*idItr, 3);  // space for the noise hit
      uint32_t myBin((uint32_t)m_trip.size() * m_ranGeneral->shoot(engine));
      if (myBin == m_trip.size())
        --myBin;  // guard against roundup
      assert(myBin < m_trip.size());
      const Triplet& trip(m_trip[myBin]);
      analogSignal[0] = m_histoInf + m_histoWid * trip.first;
      analogSignal[1] = m_histoInf + m_histoWid * trip.second;
      analogSignal[2] = m_histoInf + m_histoWid * trip.third;
      ESDataFrame digi(*idItr);
      const_cast<ESElectronicsSimFast*>(elecSim())->analogToDigital(engine, analogSignal, digi, true);
      output.push_back(digi);
    }
  }
}

void ESDigitizer::setDetIds

(

const std::vector< DetId > &

detIds

)

tell the digitizer which cells exist; cannot change during a run

Definition at line 29 of file ESDigitizer.cc.

References cms::cuda::assert(), and m_detIds.

                                                          {
  assert(nullptr == m_detIds || &detIds == m_detIds);  // sanity check; don't allow to change midstream
  m_detIds = &detIds;
}

void ESDigitizer::setGain

(

const int

gain

)

Definition at line 34 of file ESDigitizer.cc.

References EcalTDigitizer< ESDigitizerTraits >::addNoise(), cms::cuda::assert(), edmScanValgrind::buffer, EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, Exception, contentValuesFiles::fullPath, jetmet_cfg::histofile, edm::errors::InvalidReference, m_detIds, m_ESGain, m_histoBin, m_histoInf, m_histoWid, m_meanNoisy, m_ranGeneral, m_trip, mps_fire::result, mps_update::status, and AlCaHLTBitMon_QueryRunRegistry::string.

                                        {
  if (0 != m_ESGain) {
    assert(gain == m_ESGain);  // only allow one value
  } else {
    assert(nullptr != m_detIds && !m_detIds->empty());  // detIds must already be set as we need size

    assert(1 == gain || 2 == gain);  // legal values

    m_ESGain = gain;

    if (addNoise()) {
      double zsThresh(0.);
      std::string refFile;

      if (1 == m_ESGain) {
        zsThresh = 3;
        refFile = "SimCalorimetry/EcalSimProducers/data/esRefHistosFile_LG.txt";
      } else {
        zsThresh = 4;
        refFile = "SimCalorimetry/EcalSimProducers/data/esRefHistosFile_HG.txt";
      }

      gsl_sf_result result;
      int status = gsl_sf_erf_Q_e(zsThresh, &result);
      if (status != 0)
        std::cerr << "ESDigitizer::could not compute gaussian tail probability for the threshold chosen" << std::endl;

      const double probabilityLeft(result.val);
      m_meanNoisy = probabilityLeft * m_detIds->size();

      std::ifstream histofile(edm::FileInPath(refFile).fullPath().c_str());
      if (!histofile.good()) {
        throw edm::Exception(edm::errors::InvalidReference, "NullPointer") << "Reference histos file not opened";
      } else {
        // number of bins
        char buffer[200];
        int thisLine = 0;
        while (0 == thisLine) {
          histofile.getline(buffer, 200);
          if (!strstr(buffer, "#") && !(strspn(buffer, " ") == strlen(buffer))) {
            float histoBin;
            sscanf(buffer, "%f", &histoBin);
            m_histoBin = (double)histoBin;
            ++thisLine;
          }
        }
        const uint32_t histoBin1((int)m_histoBin);
        const uint32_t histoBin2(histoBin1 * histoBin1);

        double t_histoSup(0);

        std::vector<double> t_refHistos;
        t_refHistos.reserve(2500);

        int thisBin = -2;
        while (!(histofile.eof())) {
          histofile.getline(buffer, 200);
          if (!strstr(buffer, "#") && !(strspn(buffer, " ") == strlen(buffer))) {
            if (-2 == thisBin) {
              float histoInf;
              sscanf(buffer, "%f", &histoInf);
              m_histoInf = (double)histoInf;
            }
            if (-1 == thisBin) {
              float histoSup;
              sscanf(buffer, "%f", &histoSup);
              t_histoSup = (double)histoSup;
            }
            if (0 <= thisBin) {
              float refBin;
              sscanf(buffer, "%f", &refBin);
              if (0.5 < refBin) {
                t_refHistos.push_back((double)refBin);
                const uint32_t i2(thisBin / histoBin2);
                const uint32_t off(i2 * histoBin2);
                const uint32_t i1((thisBin - off) / histoBin1);
                const uint32_t i0(thisBin - off - i1 * histoBin1);
                m_trip.emplace_back(i0, i1, i2);
              }
            }
            ++thisBin;
          }
        }
        m_histoWid = (t_histoSup - m_histoInf) / m_histoBin;

        m_histoInf -= 1000.;

        // creating the reference distribution to extract random numbers
        m_ranGeneral = new CLHEP::RandGeneral(nullptr, &t_refHistos.front(), t_refHistos.size(), 0);
        histofile.close();
      }
    }
  }
}

Member Data Documentation

const std::vector<DetId>* ESDigitizer::m_detIds

private

Definition at line 31 of file ESDigitizer.h.

Referenced by createNoisyList(), run(), setDetIds(), and setGain().

int ESDigitizer::m_ESGain

private

Definition at line 33 of file ESDigitizer.h.

Referenced by setGain().

double ESDigitizer::m_histoBin

private

Definition at line 34 of file ESDigitizer.h.

Referenced by setGain().

double ESDigitizer::m_histoInf

private

Definition at line 35 of file ESDigitizer.h.

Referenced by run(), and setGain().

double ESDigitizer::m_histoWid

private

Definition at line 36 of file ESDigitizer.h.

Referenced by run(), and setGain().

double ESDigitizer::m_meanNoisy

private

Definition at line 37 of file ESDigitizer.h.

Referenced by createNoisyList(), run(), and setGain().

CLHEP::RandGeneral* ESDigitizer::m_ranGeneral

private

Definition at line 32 of file ESDigitizer.h.

Referenced by run(), setGain(), and ~ESDigitizer().

std::vector<Triplet> ESDigitizer::m_trip

private

Definition at line 49 of file ESDigitizer.h.

Referenced by ESDigitizer(), run(), and setGain().