TimeDigitizer Class Reference

Time digitization of simulated hits in a single electronic channel. More...

#include <TimeDigitizer.h>

Classes
struct	Hit
	hit data other than time More...

Public Types
enum	EType {   c_Hit = 0 ,   c_ChargeShare = 1 ,   c_CrossTalk = 2 ,   c_CalPulse = 3 }
	hit type enumerators More...

Public Member Functions
	TimeDigitizer (int moduleID, int pixelID, double timeOffset, double calErrorsSq, int shift, double rmsNoise, const TOPSampleTimes &sampleTimes)
	Constructor.
void	setSampleTimes (const TOPSampleTimes *sampleTimes)
	Sets sample times.
void	setNoise (double rmsNoise)
	Sets noise level.
void	addTimeOfHit (double t, double pulseHeight, EType type, const TOPSimHit *simHit=0)
	Add time of simulated hit.
int	getModuleID () const
	Return bar ID.
int	getPixelID () const
	Return pixel ID.
unsigned	getUniqueID () const
	Return unique pixel ID.
unsigned	getASICWindow () const
	Returns ASIC storage window number.
unsigned int	getChannel () const
	Returns hardware channel number.
unsigned	getScrodID () const
	Returns SCROD ID.
unsigned	getCarrierNumber () const
	Returns carrier board number.
unsigned	getASICNumber () const
	Returns ASIC number.
unsigned	getASICChannel () const
	Returns ASIC channel number.
bool	isValid () const
	Check if digitizer instance is valid (e.g.
void	digitize (StoreArray< TOPRawDigit > &rawDigits, StoreArray< TOPDigit > &digits, int threshold=0, int thresholdCount=0, double timeJitter=0) const
	Do time digitization using simplified pile-up and double-hit-resolution model.
void	digitize (StoreArray< TOPRawWaveform > &waveforms, StoreArray< TOPRawDigit > &rawDigits, StoreArray< TOPDigit > &digits, int threshold, int hysteresis=0, int thresholdCount=0) const
	Do full waveform time digitization.

Static Public Member Functions
static void	setStorageDepth (unsigned storageDepth)
	Sets storage depth.
static void	setReadoutWindows (unsigned numWin)
	Sets the number of readout windows.
static void	setOffsetWindows (int offsetWin)
	Sets the number of windows before the first ASIC window.
static void	setFirstWindow (unsigned window)
	Sets first ASIC window.
static void	maskSamples (bool maskThem)
	Mask samples at the end of a window to emulate phase-2 data.
static void	setTimeWalk (DBObjPtr< TOPCalTimeWalk > *timeWalk)
	Stores pointer to time walk DB object defined in TOPDigitizerModule.

Private Member Functions
double	gauss (double x, double mean, double sigma) const
	Gauss function (pulse shape approximation)
std::vector< short >	generateWaveform (int startSample, const std::vector< double > &baselines, const std::vector< double > &rmsNoises, const std::vector< double > &pedestals, int ADCRange) const
	Generate waveform.
double	generateTimeWalk (double hitTime, double peakTime) const
	Generate time walk by taking into account pile-up of hits.

Private Attributes
int	m_moduleID = 0
	module ID (1-based)
int	m_pixelID = 0
	pixel (e.g.
double	m_timeOffset = 0
	time offset [ns]
double	m_calErrorsSq = 0
	calibration uncertainties squared
double	m_rmsNoise = 0
	r.m.s of noise [ADC counts]
const TOPSampleTimes *	m_sampleTimes = 0
	sample times
int	m_windowShift = 0
	additional wf window shift due to asic mis-alignment
unsigned	m_channel = 0
	hardware channel number (0-based)
unsigned	m_scrodID = 0
	SCROD ID.
unsigned	m_carrier = 0
	carrier board number
unsigned	m_asic = 0
	ASIC number.
unsigned	m_chan = 0
	ASIC channel number.
bool	m_valid = false
	true, if module/pixel is mapped to hardware
std::multimap< double, const Hit >	m_times
	hits sorted by time

Static Private Attributes
static unsigned	s_storageDepth = 0
	ASIC analog storage depth.
static unsigned	s_readoutWindows = 0
	number of readout windows
static int	s_offsetWindows = 0
	number of windows before first wf window
static unsigned	s_window = 0
	first window number
static bool	s_maskSamples = false
	mask samples at window boundary (phase-2)
static DBObjPtr< TOPCalTimeWalk > *	s_timeWalk = 0
	pointer to DB object

Detailed Description

Time digitization of simulated hits in a single electronic channel.

Definition at line 33 of file TimeDigitizer.h.

Member Enumeration Documentation

EType

enum EType

hit type enumerators

Definition at line 40 of file TimeDigitizer.h.

                 {
        c_Hit = 0,
        c_ChargeShare = 1,
        c_CrossTalk = 2,
        c_CalPulse = 3
      };

Constructor & Destructor Documentation

TimeDigitizer()

TimeDigitizer	(	int	moduleID,
		int	pixelID,
		double	timeOffset,
		double	calErrorsSq,
		int	shift,
		double	rmsNoise,
		const TOPSampleTimes &	sampleTimes
	)

Constructor.

Parameters

moduleID	TOP module ID
pixelID	pixel ID
timeOffset	time offset [ns]
calErrorsSq	calibration uncertainies squared
shift	shift of waveform window due to asic mis-alignment [num of windows]
rmsNoise	r.m.s of noise [ADC counts]
sampleTimes	sample times

Definition at line 31 of file TimeDigitizer.cc.

                                                                   :
      m_moduleID(moduleID), m_pixelID(pixelID), m_timeOffset(timeOffset),
      m_calErrorsSq(calErrorsSq), m_rmsNoise(rmsNoise), m_sampleTimes(&sampleTimes),
      m_windowShift(shift)
    {
      const auto& channelMapper = TOPGeometryPar::Instance()->getChannelMapper();
      m_channel = channelMapper.getChannel(pixelID);
      if (!channelMapper.isChannelValid(m_channel)) {
        B2ERROR("TimeDigitizer::TimeDigitizer: invalid channel");
        return;
      }
 
      unsigned bs = 0;
      channelMapper.splitChannelNumber(m_channel, bs, m_carrier, m_asic, m_chan);
 
      const auto& frontEndMapper = TOPGeometryPar::Instance()->getFrontEndMapper();
      const auto* map = frontEndMapper.getMap(m_moduleID, bs);
      if (!map) {
        B2ERROR("TimeDigitizer::TimeDigitizer: no valid frontend map found");
        return;
      }
 
      m_scrodID = map->getScrodID();
      m_valid = true;
 
    }

Member Function Documentation

addTimeOfHit()

void addTimeOfHit	(	double	t,
		double	pulseHeight,
		EType	type,
		const TOPSimHit *	simHit = 0
	)

Add time of simulated hit.

Parameters

t	time of simulated hit
pulseHeight	simulated pulse height
type	hit type
simHit	pointer to simulated hit

Definition at line 60 of file TimeDigitizer.cc.

    {
      Hit hit;
      hit.pulseHeight = pulseHeight;
      hit.type = type;
      hit.simHit = simHit;
      switch (type) {
        case static_cast<int>(c_Hit):
          hit.shape = &(TOPGeometryPar::Instance()->getGeometry()->getSignalShape());
          break;
        case static_cast<int>(c_ChargeShare):
          hit.shape = &(TOPGeometryPar::Instance()->getGeometry()->getSignalShape());
          break;
        case static_cast<int>(c_CrossTalk):
          hit.shape = 0;
          B2ERROR("TOP::TimeDigitizer: waveform shape of cross-talk not yet available");
          break;
        case static_cast<int>(c_CalPulse):
          hit.shape = &(TOPGeometryPar::Instance()->getGeometry()->getCalPulseShape());
          break;
        default:
          hit.shape = 0;
      }
      m_times.insert(std::pair<double, const Hit>(t, hit));
    }

digitize() [1/2]

void digitize	(	StoreArray< TOPRawDigit > &	rawDigits,
		StoreArray< TOPDigit > &	digits,
		int	threshold = 0,
		int	thresholdCount = 0,
		double	timeJitter = 0
	)		const

Do time digitization using simplified pile-up and double-hit-resolution model.

As a result, the digitized hits are appended to TOPRawDigits, then they are converted to TOPDigits and the relations to TOPSimHits and MCParticles are set with proper weights.

Parameters

rawDigits	array of TOPRawDigits
digits	array of TOPDigits
threshold	pulse height threshold [ADC counts]
thresholdCount	minimal number of samples above threshold
timeJitter	a r.m.s. of an additional time jitter due to electronics

Definition at line 93 of file TimeDigitizer.cc.

    {
 
      if (m_times.empty()) return;
 
      // get parameters of the model
      const auto* geo = TOPGeometryPar::Instance()->getGeometry();
      const auto& tdc = geo->getNominalTDC();
      double hitResolveTime = tdc.getDoubleHitResolution();
      double pileupTime = tdc.getPileupTime();
 
      // split time pattern into multiple hits (according to double-hit resolution)
      std::vector<Iterator> ranges;
      ranges.push_back(m_times.begin());
      double prevTime = m_times.begin()->first;
      for (Iterator it = m_times.begin(); it != m_times.end(); ++it) {
        if (it->first - prevTime > hitResolveTime) ranges.push_back(it);
        prevTime = it->first;
      }
      ranges.push_back(m_times.end());
 
      // loop over splitted regions
      for (unsigned k = 0; k < ranges.size() - 1; k++) {
 
        // temporary containers
        std::vector<double> times;
        std::vector<double> weights;
        std::vector<const TOPSimHit*> simHits;
 
        // take only hits within pileup time and discard others
        prevTime = ranges[k]->first;
        for (Iterator it = ranges[k]; it != ranges[k + 1]; ++it) {
          if (it->first - prevTime > pileupTime) break;
          times.push_back(it->first);
          double pulseHeight = gRandom->Gaus(it->second.pulseHeight, m_rmsNoise);
          weights.push_back(pulseHeight);
          simHits.push_back(it->second.simHit);
          prevTime = it->first;
        }
 
        // determine pulse height
        double height = 0;
        for (const auto& weight : weights) height += weight;
 
        // set weights
        for (auto& weight : weights) weight /= height;
 
        // generate pulse width
        double width = gRandom->Gaus(2.3, 0.4);
        if (width < 0.5) width = 0.5;
 
        // determine detection time
        double time = 0;
        for (unsigned j = 0; j < times.size(); j++) time += times[j] * weights[j];
 
        // add additional time jitter
        if (timeJitter > 0) time += gRandom->Gaus(0., timeJitter);
 
        // emulate feature extraction data
 
        double mean = time + width / 2;
        double sigma = width / 2.35482;
 
        int samplePeak = tdc.getSample(mean);
        if (mean - tdc.getSampleTime(samplePeak) > tdc.getSampleWidth() / 2) samplePeak++;
        short vPeak = height * gauss(tdc.getSampleTime(samplePeak), mean, sigma);
        if (vPeak < threshold) continue;
        if (vPeak > 3000) vPeak = 3000; // saturation - roughly (e.g. 4096 - pedestal)
 
        double halfWid = sigma * sqrt(-2 * log(0.5 * vPeak / height));
        int sampleRise = tdc.getSample(mean - halfWid);
        if (!tdc.isSampleValid(sampleRise)) continue;
        short vRise0 = height * gauss(tdc.getSampleTime(sampleRise), mean, sigma);
        short vRise1 = height * gauss(tdc.getSampleTime(sampleRise + 1), mean, sigma);
 
        int sampleFall = tdc.getSample(mean + halfWid);
        if (!tdc.isSampleValid(sampleFall + 1)) continue;
        short vFall0 = height * gauss(tdc.getSampleTime(sampleFall), mean, sigma);
        short vFall1 = height * gauss(tdc.getSampleTime(sampleFall + 1), mean, sigma);
 
        if (threshold > 0) {
          double halfDt = sigma * sqrt(-2 * log(threshold / height));
          int overThr = tdc.getSample(mean + halfDt) - tdc.getSample(mean - halfDt);
          if (overThr < thresholdCount) continue;
        }
 
        // determine integral
        int numSamples = (sampleFall - sampleRise) * 4; // according to topcaf
        double sigmaIntegral = 0;
        if (numSamples > 1) sigmaIntegral = m_rmsNoise * sqrt(numSamples - 1);
        double integral = gRandom->Gaus(height * 7.0, sigmaIntegral);
 
        // append new raw digit
        auto* rawDigit = rawDigits.appendNew(m_scrodID, TOPRawDigit::c_MC);
        rawDigit->setCarrierNumber(m_carrier);
        rawDigit->setASICNumber(m_asic);
        rawDigit->setASICChannel(m_chan);
        rawDigit->setASICWindow(s_window);
        rawDigit->setSampleRise(sampleRise);
        rawDigit->setDeltaSamplePeak(samplePeak - sampleRise);
        rawDigit->setDeltaSampleFall(sampleFall - sampleRise);
        rawDigit->setValueRise0(vRise0);
        rawDigit->setValueRise1(vRise1);
        rawDigit->setValueFall0(vFall0);
        rawDigit->setValueFall1(vFall1);
        rawDigit->setValuePeak(vPeak);
        rawDigit->setIntegral(integral);
 
        double rawTime = rawDigit->getCFDLeadingTime();
        double cfdTime = rawTime * tdc.getSampleWidth() - tdc.getOffset();
        double cfdWidth = rawDigit->getFWHM() * tdc.getSampleWidth();
        int sampleDivisions = 0x1 << tdc.getSubBits();
        int tfine = int(rawTime * sampleDivisions) % sampleDivisions;
        if (tfine < 0) tfine += sampleDivisions;
        rawDigit->setTFine(tfine);
 
        // append new digit
 
        auto* digit = digits.appendNew(m_moduleID, m_pixelID, rawTime);
        digit->setTime(cfdTime);
        digit->setTimeError(timeJitter);
        digit->setPulseHeight(rawDigit->getValuePeak());
        digit->setIntegral(rawDigit->getIntegral());
        digit->setPulseWidth(cfdWidth);
        digit->setChannel(m_channel);
        digit->setFirstWindow(rawDigit->getASICWindow());
        digit->setStatus(TOPDigit::c_OffsetSubtracted);
        if (m_sampleTimes->isCalibrated()) {
          digit->addStatus(TOPDigit::c_TimeBaseCalibrated);
        }
        digit->addRelationTo(rawDigit);
 
        // set relations to simulated hits and MC particles
 
        std::map<MCParticle*, double> relatedMCParticles;
        for (unsigned j = 0; j < simHits.size(); j++) {
          const auto* simHit = simHits[j];
          const double& weight = weights[j];
          if (simHit) {
            digit->addRelationTo(simHit, weight);
            RelationVector<MCParticle> particles = simHit->getRelationsFrom<MCParticle>();
            for (unsigned i = 0; i < particles.size(); ++i) {
              relatedMCParticles[particles[i]] += particles.weight(i) * weight;
            }
          }
        }
        for (const auto& x : relatedMCParticles) digit->addRelationTo(x.first, x.second);
 
      } // end loop over splitted regions
    }

digitize() [2/2]

void digitize	(	StoreArray< TOPRawWaveform > &	waveforms,
		StoreArray< TOPRawDigit > &	rawDigits,
		StoreArray< TOPDigit > &	digits,
		int	threshold,
		int	hysteresis = 0,
		int	thresholdCount = 0
	)		const

Do full waveform time digitization.

As a result, the digitized hits are appended to TOPRawDigits, then they are converted to TOPDigits and the relations to TOPSimHits and MCParticles are set with proper weights.

Parameters

waveforms	generated waveforms
rawDigits	array of TOPRawDigits
digits	array of TOPDigits
threshold	pulse height threshold [ADC counts]
hysteresis	pulse height threshold hysteresis [ADC counts]
thresholdCount	minimal number of samples above threshold

Definition at line 251 of file TimeDigitizer.cc.

    {
 
      // get parameters of the model
 
      const auto* geo = TOPGeometryPar::Instance()->getGeometry();
      const auto& tdc = geo->getNominalTDC();
 
      // generate waveform
 
      std::vector<unsigned short> windowNumbers;
      int offsetWindows = s_offsetWindows + m_windowShift;
      int winnum = s_window + offsetWindows;
      if (winnum < 0) winnum += s_storageDepth;
      windowNumbers.push_back(winnum % s_storageDepth);
      for (unsigned i = 1; i < s_readoutWindows; i++) {
        windowNumbers.push_back((windowNumbers.back() + 1) % s_storageDepth);
      }
      std::vector<double> baselines(windowNumbers.size(), 0);
      std::vector<double> rmsNoises(windowNumbers.size(), m_rmsNoise);
      double averagePedestal = tdc.getAveragePedestal();
      std::vector<double> pedestals(windowNumbers.size(), averagePedestal);
      int adcRange = tdc.getADCRange();
 
      int startSample = -offsetWindows * TOPRawWaveform::c_WindowSize;
      auto wfData = generateWaveform(startSample, baselines, rmsNoises, pedestals,
                                     adcRange);
 
      // store waveform
 
      auto* waveform = waveforms.appendNew(m_moduleID, m_pixelID, m_channel, m_scrodID,
                                           windowNumbers[0], 0, wfData);
      waveform->setStorageWindows(windowNumbers);
      waveform->setPedestalSubtractedFlag(true);
 
      // do feature extraction
 
      waveform->featureExtraction(threshold, hysteresis, thresholdCount);
 
      // digits
 
      for (const auto& feature : waveform->getFeatureExtractionData()) {
        int sampleRise = feature.sampleRise;
        if (sampleRise < 0) continue;
        unsigned iwin = sampleRise / TOPRawWaveform::c_WindowSize;
        if (iwin >= windowNumbers.size()) continue;
        sampleRise -= iwin * TOPRawWaveform::c_WindowSize; // should fit raw data bits
        if (s_maskSamples and (sampleRise % 64) > 55) continue;
 
        unsigned DsamplePeak = feature.samplePeak - feature.sampleRise;
        if ((DsamplePeak & 0x0F) != DsamplePeak) continue; // does not fit raw data bits
 
        unsigned DsampleFall = feature.sampleFall - feature.sampleRise;
        if ((DsampleFall & 0x0F) != DsampleFall) continue; // does not fit raw data bits
 
        std::vector<unsigned short> winNumbers;
        for (unsigned i = iwin; i < windowNumbers.size(); i++) {
          winNumbers.push_back(windowNumbers[i]);
        }
 
        // append new raw digit and set it
        auto* rawDigit = rawDigits.appendNew(m_scrodID, TOPRawDigit::c_ProductionDebug);
        rawDigit->setCarrierNumber(m_carrier);
        rawDigit->setASICNumber(m_asic);
        rawDigit->setASICChannel(m_chan);
        rawDigit->setASICWindow(windowNumbers[iwin]);
        rawDigit->setStorageWindows(winNumbers);
        rawDigit->setSampleRise(sampleRise);
        rawDigit->setDeltaSamplePeak(DsamplePeak);
        rawDigit->setDeltaSampleFall(DsampleFall);
        rawDigit->setValueRise0(feature.vRise0);
        rawDigit->setValueRise1(feature.vRise1);
        rawDigit->setValueFall0(feature.vFall0);
        rawDigit->setValueFall1(feature.vFall1);
        rawDigit->setValuePeak(feature.vPeak);
        rawDigit->setIntegral(feature.integral);
        double rawTimeLeading = rawDigit->getCFDLeadingTime(); // time in [samples]
        int sampleDivisions = 0x1 << tdc.getSubBits();
        int tfine = int(rawTimeLeading * sampleDivisions) % sampleDivisions;
        if (tfine < 0) tfine += sampleDivisions;
        rawDigit->setTFine(tfine);
        rawDigit->addRelationTo(waveform);
 
        double rawTimeFalling = rawDigit->getCFDFallingTime(); // time in [samples]
        double rawTimeErr = rawDigit->getCFDLeadingTimeError(m_rmsNoise); // in [samples]
 
        // convert to [ns] using time base calibration
        int nwin = iwin + offsetWindows;
        rawTimeLeading += nwin * TOPRawDigit::c_WindowSize;
        rawTimeFalling += nwin * TOPRawDigit::c_WindowSize;
 
        double cfdTime = m_sampleTimes->getTime(s_window, rawTimeLeading) - m_timeOffset;
        double width = m_sampleTimes->getDeltaTime(s_window,
                                                   rawTimeFalling,
                                                   rawTimeLeading);
        int sample = static_cast<int>(rawTimeLeading);
        if (rawTimeLeading < 0) sample--;
        double timeError = rawTimeErr * m_sampleTimes->getTimeBin(s_window, sample);
        double timeErrorSq = timeError * timeError + m_calErrorsSq;
        int pulseHeight = rawDigit->getValuePeak();
 
        if (s_timeWalk) {
          cfdTime -= (*s_timeWalk)->getTimeWalk(pulseHeight);
          timeErrorSq += (*s_timeWalk)->getSigmaSq(pulseHeight);
        }
 
        // append new digit and set it
        auto* digit = digits.appendNew(m_moduleID, m_pixelID, rawTimeLeading);
        digit->setTime(cfdTime);
        digit->setTimeError(sqrt(timeErrorSq));
        digit->setPulseHeight(pulseHeight);
        digit->setIntegral(rawDigit->getIntegral());
        digit->setPulseWidth(width);
        digit->setChannel(m_channel);
        digit->setFirstWindow(s_window);
        if (m_sampleTimes->isCalibrated()) {
          digit->addStatus(TOPDigit::c_TimeBaseCalibrated);
        }
        digit->addRelationTo(rawDigit);
 
        // check validity of feature extraction
 
        if (!rawDigit->isFEValid() or rawDigit->isPedestalJump()) {
          digit->setHitQuality(TOPDigit::c_Junk);
        }
 
        // set relations to simulated hits and MC particles, largest weight first
 
        std::multimap<double, const Hit*, std::greater<double>> weights;
        for (const auto& hit : m_times) {
          double hitTime = hit.first;
          double weight = 0;
          const auto* pulseShape = hit.second.shape;
          if (pulseShape) {
            weight = fabs(pulseShape->getValue(cfdTime - hitTime));
          }
          if (weight > 0.01) {
            weight *= hit.second.pulseHeight;
            weights.insert(std::pair<double, const Hit*>(weight, &hit.second));
          }
        }
        double sum = 0;
        for (const auto& w : weights) sum += w.first;
        if (sum == 0) continue; // noisy hit
 
        std::map<MCParticle*, double> relatedMCParticles;
        for (const auto& w : weights) {
          auto weight = w.first / sum;
          const auto* simHit = w.second->simHit;
          if (simHit and weight > 0) {
            digit->addRelationTo(simHit, weight);
            RelationVector<MCParticle> particles = simHit->getRelationsFrom<MCParticle>();
            for (unsigned i = 0; i < particles.size(); ++i) {
              relatedMCParticles[particles[i]] += particles.weight(i) * weight;
            }
          } else if (w.second->type == c_CalPulse and weight > 0.90) {
            digit->setHitQuality(TOPDigit::c_CalPulse);
          }
        }
        for (const auto& x : relatedMCParticles) digit->addRelationTo(x.first, x.second);
      }
 
    }

gauss()

double gauss ( double  x, double  mean, double  sigma  ) const

inlineprivate

Gauss function (pulse shape approximation)

Parameters

x	argument
mean	mean
sigma	sigma

Returns

value

Definition at line 241 of file TimeDigitizer.h.

      {
        double xx = (x - mean) / sigma;
        return exp(-0.5 * xx * xx);
      }

generateTimeWalk()

double generateTimeWalk ( double  hitTime, double  peakTime  ) const

private

Generate time walk by taking into account pile-up of hits.

Parameters

hitTime	time of the hit
peakTime	peaking time of signal

Returns

time walk

Definition at line 516 of file TimeDigitizer.cc.

    {
      if (not s_timeWalk) return 0;
 
      double pulseHeight = 0;
      for (const auto& hit : m_times) {
        double hTime = hit.first;
        const auto* pulseShape = hit.second.shape;
        if (not pulseShape) continue;
        pulseHeight += hit.second.pulseHeight * pulseShape->getValue(hTime - hitTime + peakTime);
      }
 
      double t = (*s_timeWalk)->getTimeWalk(pulseHeight);
      double sig = (*s_timeWalk)->getSigma(pulseHeight);
 
      return gRandom->Gaus(t, sig);
    }

generateWaveform()

vector< short > generateWaveform ( int  startSample, const std::vector< double > &  baselines, const std::vector< double > &  rmsNoises, const std::vector< double > &  pedestals, int  ADCRange  ) const

private

Generate waveform.

The size (number of ASIC windows) is given by the size of first argument. The size of second argument must be the same as the first one.

Parameters

startSample	starting sample w.r.t first window number
baselines	possible baseline shifts of ASIC windows
rmsNoises	noise levels (r.m.s) per ASIC window
pedestals	average pedestals per ASIC window
ADCRange	ADC range (2^NumBits)

Returns

generated waveform

Definition at line 421 of file TimeDigitizer.cc.

    {
 
      if (baselines.empty() or baselines.size() != rmsNoises.size() or
          baselines.size() != pedestals.size())
        B2FATAL("TOP::TimeDigitizer: inconsistent vector sizes");
 
      // model parameters
 
      const auto* geo = TOPGeometryPar::Instance()->getGeometry();
      const auto& tdc = geo->getNominalTDC();
      const auto& signalShape = geo->getSignalShape();
 
      double dt = tdc.getSampleWidth();
      double fmax = 1 / (2 * dt); // Nyquist frequency
      double tau1 = 1 / (2 * M_PI * signalShape.getPole1());
      double tau2 = 1 / (2 * M_PI * signalShape.getPole2());
      double bw1 = 1 / (4 * tau1);        // bandwidth of first order filter
      double bw2 = 1 / (4 * (tau1 + tau2)); // bandwidth of second order filter
 
      // construct waveform vector containing white noise
 
      vector<double> waveform;
      for (auto rms : rmsNoises) {
        double rms0 = rms * sqrt(fmax / bw2);
        for (unsigned i = 0; i < TOPRawWaveform::c_WindowSize; i++) {
          waveform.push_back(gRandom->Gaus(0, rms0));
        }
      }
 
      // noise smoothing according to second order low pass filter
 
      double a1 = exp(-dt / tau1);
      double v0 = gRandom->Gaus(0, rmsNoises[0] * sqrt(bw1 / bw2));
      double prevValue = v0;
      for (auto& value : waveform) { // first order filter (pole1)
        value = a1 * prevValue + (1 - a1) * value;
        prevValue = value;
      }
      double a2 = exp(-dt / tau2);
      prevValue = v0;
      for (auto& value : waveform) { // first order filter again (pole2)
        value = a2 * prevValue + (1 - a2) * value;
        prevValue = value;
      }
 
      // add possible baseline shifts
 
      int k = 0;
      for (auto baseline : baselines) {
        for (unsigned i = 0; i < TOPRawWaveform::c_WindowSize; i++) {
          waveform[k] += baseline;
          k++;
        }
      }
 
      // add signal
 
      for (const auto& hit : m_times) {
        double hitTime = hit.first;
        double pulseHeight = hit.second.pulseHeight;
        const auto* pulseShape = hit.second.shape;
        if (not pulseShape) continue;
        double timeWalk = generateTimeWalk(hitTime, pulseShape->getPeakingTime());
        int size = waveform.size();
        for (int sample = 0; sample < size; sample++) {
          double t = m_sampleTimes->getTime(s_window, sample - startSample) - m_timeOffset;
          waveform[sample] += pulseHeight * pulseShape->getValue(t - timeWalk - hitTime);
        }
      }
 
      // model saturation effects and convert to short
      // (exact modelling would require pedestals for each sample)
 
      vector<short> wf;
      k = 0;
      for (auto pedestal : pedestals) {
        for (unsigned i = 0; i < TOPRawWaveform::c_WindowSize; i++) {
          int adc = waveform[k] + pedestal;
          if (adc < 0) adc = 0;
          if (adc > adcRange) adc = adcRange;
          adc -= pedestal;
          wf.push_back(adc);
          k++;
        }
      }
 
      return wf;
    }

getASICChannel()

unsigned getASICChannel ( ) const

inline

Returns ASIC channel number.

Returns

ASIC channel number

Definition at line 186 of file TimeDigitizer.h.

{return m_chan;}

getASICNumber()

unsigned getASICNumber ( ) const

inline

Returns ASIC number.

Returns

ASIC number

Definition at line 180 of file TimeDigitizer.h.

{return m_asic;}

getASICWindow()

unsigned getASICWindow ( ) const

inline

Returns ASIC storage window number.

Returns

window number

Definition at line 156 of file TimeDigitizer.h.

{return s_window;}

getCarrierNumber()

unsigned getCarrierNumber ( ) const

inline

Returns carrier board number.

Returns

carrier board number

Definition at line 174 of file TimeDigitizer.h.

{return m_carrier;}

getChannel()

unsigned int getChannel ( ) const

inline

Returns hardware channel number.

Returns

hardware channel number

Definition at line 162 of file TimeDigitizer.h.

{ return m_channel; }

getModuleID()

int getModuleID ( ) const

inline

Return bar ID.

Returns

bar ID

Definition at line 138 of file TimeDigitizer.h.

{ return m_moduleID; }

getPixelID()

int getPixelID ( ) const

inline

Return pixel ID.

Returns

pixel ID (e.g. software channel)

Definition at line 144 of file TimeDigitizer.h.

{ return m_pixelID; }

getScrodID()

unsigned getScrodID ( ) const

inline

Returns SCROD ID.

Returns

SCROD ID

Definition at line 168 of file TimeDigitizer.h.

{return m_scrodID;}

getUniqueID()

unsigned getUniqueID ( ) const

inline

Return unique pixel ID.

Returns

unique pixel ID

Definition at line 150 of file TimeDigitizer.h.

{return m_pixelID + (m_moduleID << 16);}

isValid()

bool isValid ( ) const

inline

Check if digitizer instance is valid (e.g.

module/pixel is mapped to hardware)

Returns

true if valid

Definition at line 192 of file TimeDigitizer.h.

{return m_valid;}

maskSamples()

static void maskSamples ( bool  maskThem )

inlinestatic

Mask samples at the end of a window to emulate phase-2 data.

Parameters

maskThem

mask (true) or not mask (false)

Definition at line 98 of file TimeDigitizer.h.

{s_maskSamples = maskThem;}

setFirstWindow()

static void setFirstWindow ( unsigned  window )

inlinestatic

Sets first ASIC window.

Parameters

window

storage window number

Definition at line 92 of file TimeDigitizer.h.

{s_window = window;}

setNoise()

void setNoise ( double  rmsNoise )

inline

Sets noise level.

Parameters

rmsNoise

r.m.s. of noise [ADC counts]

Definition at line 122 of file TimeDigitizer.h.

{m_rmsNoise = rmsNoise;}

setOffsetWindows()

static void setOffsetWindows ( int  offsetWin )

inlinestatic

Sets the number of windows before the first ASIC window.

Parameters

offsetWin

number of offset windows

Definition at line 86 of file TimeDigitizer.h.

{s_offsetWindows = offsetWin;}

setReadoutWindows()

static void setReadoutWindows ( unsigned  numWin )

inlinestatic

Sets the number of readout windows.

Parameters

numWin

number of readout windows

Definition at line 80 of file TimeDigitizer.h.

{s_readoutWindows = numWin;}

setSampleTimes()

void setSampleTimes ( const TOPSampleTimes *  sampleTimes )

inline

Sets sample times.

Parameters

sampleTimes

sample times

Definition at line 109 of file TimeDigitizer.h.

      {
        if (sampleTimes) {
          m_sampleTimes = sampleTimes;
        } else {
          B2ERROR("TOP::TimeDigitizer::setSampleTimes: argument is NULL pointer");
        }
      }

setStorageDepth()

static void setStorageDepth ( unsigned  storageDepth )

inlinestatic

Sets storage depth.

Parameters

storageDepth

analog storage depth

Definition at line 74 of file TimeDigitizer.h.

{s_storageDepth = storageDepth;}

setTimeWalk()

static void setTimeWalk ( DBObjPtr< TOPCalTimeWalk > *  timeWalk )

inlinestatic

Stores pointer to time walk DB object defined in TOPDigitizerModule.

Definition at line 103 of file TimeDigitizer.h.

{s_timeWalk = timeWalk;}

Member Data Documentation

m_asic

unsigned m_asic = 0

private

ASIC number.

Definition at line 290 of file TimeDigitizer.h.

m_calErrorsSq

double m_calErrorsSq = 0

private

calibration uncertainties squared

Definition at line 282 of file TimeDigitizer.h.

m_carrier

unsigned m_carrier = 0

private

carrier board number

Definition at line 289 of file TimeDigitizer.h.

m_chan

unsigned m_chan = 0

private

ASIC channel number.

Definition at line 291 of file TimeDigitizer.h.

m_channel

unsigned m_channel = 0

private

hardware channel number (0-based)

Definition at line 287 of file TimeDigitizer.h.

m_moduleID

int m_moduleID = 0

private

module ID (1-based)

Definition at line 279 of file TimeDigitizer.h.

m_pixelID

int m_pixelID = 0

private

pixel (e.g.

software channel) ID (1-based)

Definition at line 280 of file TimeDigitizer.h.

m_rmsNoise

double m_rmsNoise = 0

private

r.m.s of noise [ADC counts]

Definition at line 283 of file TimeDigitizer.h.

m_sampleTimes

const TOPSampleTimes* m_sampleTimes = 0

private

sample times

Definition at line 284 of file TimeDigitizer.h.

m_scrodID

unsigned m_scrodID = 0

private

SCROD ID.

Definition at line 288 of file TimeDigitizer.h.

m_timeOffset

double m_timeOffset = 0

private

time offset [ns]

Definition at line 281 of file TimeDigitizer.h.

m_times

std::multimap<double, const Hit> m_times

private

hits sorted by time

Definition at line 294 of file TimeDigitizer.h.

m_valid

bool m_valid = false

private

true, if module/pixel is mapped to hardware

Definition at line 292 of file TimeDigitizer.h.

m_windowShift

int m_windowShift = 0

private

additional wf window shift due to asic mis-alignment

Definition at line 285 of file TimeDigitizer.h.

s_maskSamples

bool s_maskSamples = false

staticprivate

mask samples at window boundary (phase-2)

Definition at line 276 of file TimeDigitizer.h.

s_offsetWindows

int s_offsetWindows = 0

staticprivate

number of windows before first wf window

Definition at line 274 of file TimeDigitizer.h.

s_readoutWindows

unsigned s_readoutWindows = 0

staticprivate

number of readout windows

Definition at line 273 of file TimeDigitizer.h.

s_storageDepth

unsigned s_storageDepth = 0

staticprivate

ASIC analog storage depth.

Definition at line 272 of file TimeDigitizer.h.

s_timeWalk

DBObjPtr< TOPCalTimeWalk > * s_timeWalk = 0

staticprivate

pointer to DB object

Definition at line 277 of file TimeDigitizer.h.

s_window

unsigned s_window = 0

staticprivate

first window number

Definition at line 275 of file TimeDigitizer.h.

---

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

• top/modules/TOPDigitizer/include/TimeDigitizer.h
• top/modules/TOPDigitizer/src/TimeDigitizer.cc