VMM_Shaper Class Reference

#include <VMM_Shaper.h>

Collaboration diagram for VMM_Shaper:

Public Member Functions
	VMM_Shaper (const float peakTime, const float lowerTimeWindow, const float upperTimeWindow)
virtual	~VMM_Shaper ()=default
void	initialize ()
bool	vmmPeakResponse (const std::vector< float > &effectiveCharge, const std::vector< float > &electronsTime, const double electronicsThreshold, double &amplitudeFirstPeak, double &timeFirstPeak) const
bool	vmmThresholdResponse (const std::vector< float > &effectiveCharge, const std::vector< float > &electronsTime, const double electronicsThreshold, double &amplitudeAtFirstPeak, double &timeAtThreshold) const
bool	hasChargeAboveThreshold (const std::vector< float > &effectiveCharge, const std::vector< float > &electronsTime, const double electronicsThreshold) const

Private Member Functions
double	vmmResponse (const std::vector< float > &effectiveCharge, const std::vector< float > &electronsTime, double time) const
double	findPeak (const std::vector< float > &effectiveCharge, const std::vector< float > &electronsTime, const double electronicsThreshold) const
bool	aboveThresholdSimple (const std::vector< float > &effectiveCharge, const std::vector< float > &electronsTime, const double electronicsThreshold) const

Private Attributes
double	m_peakTime {0.}
double	m_lowerTimeWindow {0.}
double	m_upperTimeWindow {0.}
double	m_timeStep {0.}
double	m_inverseTimeStep {0.}
double	m_preCalculationVMMShaper {0.}
double	m_a {0.}
double	m_pole0 {0.}
double	m_re_pole1 {0.}
double	m_im_pole1 {0.}
double	m_pole1_square {0.}
double	m_k1_abs {0.}
double	m_argK1 {0.}
double	m_peakTimeChargeScaling {0.}
double	m_pole0_ns {0.}
double	m_re_pole1_ns {0.}
double	m_im_pole1_ns {0.}

Detailed Description

Definition at line 10 of file VMM_Shaper.h.

Constructor & Destructor Documentation

VMM_Shaper()

VMM_Shaper::VMM_Shaper	(	const float	peakTime,
		const float	lowerTimeWindow,
		const float	upperTimeWindow )

Definition at line 21 of file VMM_Shaper.cxx.

                                                                                                     :
    m_peakTime(peakTime), m_lowerTimeWindow(lowerTimeWindow), m_upperTimeWindow(upperTimeWindow), m_timeStep(0.1) {
    m_inverseTimeStep = 1. / m_timeStep;
    initialize();
}

~VMM_Shaper()

virtual VMM_Shaper::~VMM_Shaper ( )

virtualdefault

Member Function Documentation

aboveThresholdSimple()

bool VMM_Shaper::aboveThresholdSimple ( const std::vector< float > & effectiveCharge, const std::vector< float > & electronsTime, const double electronicsThreshold ) const

private

Definition at line 204 of file VMM_Shaper.cxx.

                                                                               {
    // check if total strip charge is above threshold, otherwise skip VMM
    float chargeSum = 0;
    for (unsigned int i_elec = 0; i_elec < effectiveCharge.size(); i_elec++) {
        if (electronsTime.at(i_elec) >= m_lowerTimeWindow - m_peakTime && electronsTime.at(i_elec) <= m_upperTimeWindow) {
            chargeSum += effectiveCharge.at(i_elec) * m_peakTimeChargeScaling;
        }
    }
    return chargeSum >= electronicsThreshold;
}

findPeak()

double VMM_Shaper::findPeak ( const std::vector< float > & effectiveCharge, const std::vector< float > & electronsTime, const double electronicsThreshold ) const

private

Definition at line 122 of file VMM_Shaper.cxx.

                                                                     {
    if (effectiveCharge.empty()) return -9999;  // protect min_element
    double startTime = m_lowerTimeWindow;
    double minElectronTime = *std::min_element(electronsTime.begin(), electronsTime.end());
 
    minElectronTime += 0.8 * m_peakTime;  // only start looking for the peak close to the first possible peak
    if (startTime < minElectronTime)
        startTime = minElectronTime;  // if smallest strip times are higher then the lower time window, just start the loop from the
                                      // smallest electron time
 
    double oldResponse = 0;
    // double currentDerivative = 0;
 
    double timeStepScaleFactor = 5.0;
 
    for (double time = startTime; time < m_upperTimeWindow; time += m_timeStep * timeStepScaleFactor) {
        double response = vmmResponse(effectiveCharge, electronsTime, time);
        if (oldResponse < response) {
            oldResponse = response;
            continue;
        }
        oldResponse = response;
 
        int searchWindow = 5;
 
        std::vector<double> tmpTime, tmpResponse;
 
        tmpTime.reserve(2 * timeStepScaleFactor);
        tmpResponse.reserve(2 * timeStepScaleFactor);
 
        for (double fineTime = (time - 1.5 * m_timeStep * timeStepScaleFactor); fineTime < time + 0.5 * m_timeStep * timeStepScaleFactor;
             fineTime += m_timeStep) {
            tmpTime.push_back(fineTime);
            tmpResponse.push_back(vmmResponse(effectiveCharge, electronsTime, fineTime));
        }
 
        int nBins = tmpTime.size();
 
        for (int i_time = 1; i_time < nBins - 1; i_time++) {
            if (tmpResponse.at(i_time) < tmpResponse.at(i_time + 1)) continue;
 
            if (tmpResponse.at(i_time) < electronicsThreshold) break;
 
            bool checkTimeWindow = false;
            for (int i_timeOfPeak = i_time - searchWindow + 1; i_timeOfPeak <= i_time + searchWindow; i_timeOfPeak++) {
                if (i_timeOfPeak < 1 || i_timeOfPeak == nBins - 1) continue;
 
                double oldDerivative = (tmpResponse.at(i_time) - tmpResponse.at(i_time - 1));
                double newDerivative = (tmpResponse.at(i_time + 1) - tmpResponse.at(i_time));
                if (newDerivative > oldDerivative) {
                    checkTimeWindow = false;
                    break;
                } else {
                    checkTimeWindow = true;
                }
            }
            if (checkTimeWindow) return tmpTime.at(i_time);
        }
    }
    return -9999;  // no peak found
}

hasChargeAboveThreshold()

bool VMM_Shaper::hasChargeAboveThreshold	(	const std::vector< float > &	effectiveCharge,
		const std::vector< float > &	electronsTime,
		const double	electronicsThreshold ) const

Definition at line 185 of file VMM_Shaper.cxx.

                                                                                  {
    if (!aboveThresholdSimple(effectiveCharge, electronsTime, electronicsThreshold)) return false;
 
    if (effectiveCharge.empty()) return false;  // protect min_element
    double startTime = m_lowerTimeWindow;
    double minElectronTime = *std::min_element(electronsTime.begin(), electronsTime.end());
    // since we are only checking if signal is above threshold, we can start searching close to the peak
    minElectronTime += m_peakTime * 0.8;
    if (startTime < minElectronTime)
        startTime = minElectronTime;  // if smallest strip times are higher then the lower time window, just start the loop from the
                                      // smallest electron time
 
    for (double time = startTime; time < m_upperTimeWindow; time += m_timeStep) {
        if (vmmResponse(effectiveCharge, electronsTime, time) >= electronicsThreshold) { return true; }
    }
    return false;
}

initialize()

void VMM_Shaper::initialize

(

)

Definition at line 27 of file VMM_Shaper.cxx.

                            {
    // hardcoded vmm shaper values are provided by G. Iakovidis
    m_a = (m_peakTime * (1e-9)) / 1.5;
    m_pole0 = 1.263 / m_a;
    m_re_pole1 = 1.149 / m_a;
    m_im_pole1 = -0.786 / m_a;
    m_pole1_square = m_re_pole1 * m_re_pole1 + m_im_pole1 * m_im_pole1;
    m_k1_abs = std::sqrt(Re_K1 * Re_K1 + Im_K1 * Im_K1);
    m_argK1 = std::atan2(Im_K1, Re_K1);
 
    // scale factor for charge taking into account the mm ion flow time of ~150ns
    // if the peaking time is lower then that, only a fration of the total charge is integrated
    m_peakTimeChargeScaling = (m_peakTime < mmIonFlowTime ? 1.0 * m_peakTime / mmIonFlowTime : 1.0);
 
    // preCalculate factor to avoid recalculating for each electron
    m_preCalculationVMMShaper = chargeScaleFactor * m_peakTimeChargeScaling * std::pow(m_a, 3) * m_pole0 * m_pole1_square;
 
    m_pole0_ns = m_pole0 * (1e-9);
    m_re_pole1_ns = m_re_pole1 * (1e-9);
    m_im_pole1_ns = m_im_pole1 * (1e-9);
}

vmmPeakResponse()

bool VMM_Shaper::vmmPeakResponse	(	const std::vector< float > &	effectiveCharge,
		const std::vector< float > &	electronsTime,
		const double	electronicsThreshold,
		double &	amplitudeFirstPeak,
		double &	timeFirstPeak ) const

Definition at line 64 of file VMM_Shaper.cxx.

                                                                                                                             {
    double t_peak = findPeak(effectiveCharge, electronsTime, electronicsThreshold);
 
    if (t_peak == -9999) return false;  // no peak found
 
    amplitudeFirstPeak = vmmResponse(effectiveCharge, electronsTime, t_peak);
    timeFirstPeak = t_peak;
    return true;
}

vmmResponse()

double VMM_Shaper::vmmResponse ( const std::vector< float > & effectiveCharge, const std::vector< float > & electronsTime, double time ) const

private

Definition at line 49 of file VMM_Shaper.cxx.

                                                                                                                                {
    double response = 0;
    for (unsigned int i_electron = 0; i_electron < effectiveCharge.size(); i_electron++) {
        if (time < electronsTime.at(i_electron)) continue;
        double t = (time - electronsTime.at(i_electron));
        // now follows the vmm shaper response function provided by G. Iakovidis
        // It is described in section 7.1.3 of https://cds.cern.ch/record/1955475
        double st =
            effectiveCharge.at(i_electron) * m_preCalculationVMMShaper *
            ((K0 * std::exp(-t * m_pole0_ns)) + (2. * m_k1_abs * std::exp(-t * m_re_pole1_ns) * std::cos(-t * m_im_pole1_ns + m_argK1)));
        response += st;
    }
    return response;
}

vmmThresholdResponse()

bool VMM_Shaper::vmmThresholdResponse	(	const std::vector< float > &	effectiveCharge,
		const std::vector< float > &	electronsTime,
		const double	electronicsThreshold,
		double &	amplitudeAtFirstPeak,
		double &	timeAtThreshold ) const

Definition at line 75 of file VMM_Shaper.cxx.

                                                                                                                                      {
    if (!aboveThresholdSimple(effectiveCharge, electronsTime, electronicsThreshold)) return false;
 
    if (effectiveCharge.empty()) return false;  // protect min_element
    double startTime = m_lowerTimeWindow;
    double minElectronTime = *std::min_element(electronsTime.begin(), electronsTime.end());
    if (startTime < minElectronTime)
        startTime = minElectronTime;  // if smallest strip times are higher then the lower time window, just start the loop from the
                                      // smallest electron time
 
    double tmpTimeAtThreshold = -9999;
 
    for (double time = startTime; time < minElectronTime + 0.9 * m_peakTime;
         time += 10 * m_timeStep) {  // quick search till the first possible peak
        if (vmmResponse(effectiveCharge, electronsTime, time) <= electronicsThreshold) continue;
        for (double fineTime = time; fineTime >= time - 10 * m_timeStep;
             fineTime -=
             m_timeStep) {  // since value above threshold was found, loop back in time to find the crossing with the timeStep precission
            if (vmmResponse(effectiveCharge, electronsTime, fineTime) >= electronicsThreshold) continue;
            tmpTimeAtThreshold = fineTime + 0.5 * m_timeStep;  //  get time between time above and time below threshold
            break;
        }
        break;
    }
 
    if (tmpTimeAtThreshold == -9999) {  // threshold crossing not yet found
        // check if first possible peak was before start time
        double tmpStartTime = std::max(minElectronTime + 0.9 * m_peakTime, startTime);
        for (double time = tmpStartTime; time < m_upperTimeWindow; time += m_timeStep) {
            if (vmmResponse(effectiveCharge, electronsTime, time) >= electronicsThreshold) {
                tmpTimeAtThreshold = time;
                break;
            }
        }
    }
 
    if (tmpTimeAtThreshold == -9999) return false;
 
    double t_peak = findPeak(effectiveCharge, electronsTime, electronicsThreshold);
    if (t_peak == -9999) return false;
 
    timeAtThreshold = tmpTimeAtThreshold;
    amplitudeAtFirstPeak = vmmResponse(effectiveCharge, electronsTime, t_peak);
    return true;
}

Member Data Documentation

m_a

double VMM_Shaper::m_a {0.}

private

Definition at line 35 of file VMM_Shaper.h.

{0.};

m_argK1

double VMM_Shaper::m_argK1 {0.}

private

Definition at line 41 of file VMM_Shaper.h.

{0.};

m_im_pole1

double VMM_Shaper::m_im_pole1 {0.}

private

Definition at line 38 of file VMM_Shaper.h.

{0.};

m_im_pole1_ns

double VMM_Shaper::m_im_pole1_ns {0.}

private

Definition at line 51 of file VMM_Shaper.h.

{0.};

m_inverseTimeStep

double VMM_Shaper::m_inverseTimeStep {0.}

private

Definition at line 31 of file VMM_Shaper.h.

{0.};

m_k1_abs

double VMM_Shaper::m_k1_abs {0.}

private

Definition at line 40 of file VMM_Shaper.h.

{0.};

m_lowerTimeWindow

double VMM_Shaper::m_lowerTimeWindow {0.}

private

Definition at line 27 of file VMM_Shaper.h.

{0.};

m_peakTime

double VMM_Shaper::m_peakTime {0.}

private

Definition at line 26 of file VMM_Shaper.h.

{0.};

m_peakTimeChargeScaling

double VMM_Shaper::m_peakTimeChargeScaling {0.}

private

Definition at line 42 of file VMM_Shaper.h.

{0.};

m_pole0

double VMM_Shaper::m_pole0 {0.}

private

Definition at line 36 of file VMM_Shaper.h.

{0.};

m_pole0_ns

double VMM_Shaper::m_pole0_ns {0.}

private

Definition at line 49 of file VMM_Shaper.h.

{0.};

m_pole1_square

double VMM_Shaper::m_pole1_square {0.}

private

Definition at line 39 of file VMM_Shaper.h.

{0.};

m_preCalculationVMMShaper

double VMM_Shaper::m_preCalculationVMMShaper {0.}

private

Definition at line 33 of file VMM_Shaper.h.

{0.};

m_re_pole1

double VMM_Shaper::m_re_pole1 {0.}

private

Definition at line 37 of file VMM_Shaper.h.

{0.};

m_re_pole1_ns

double VMM_Shaper::m_re_pole1_ns {0.}

private

Definition at line 50 of file VMM_Shaper.h.

{0.};

m_timeStep

double VMM_Shaper::m_timeStep {0.}

private

Definition at line 30 of file VMM_Shaper.h.

{0.};

m_upperTimeWindow

double VMM_Shaper::m_upperTimeWindow {0.}

private

Definition at line 28 of file VMM_Shaper.h.

{0.};

---

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

• VMM_Shaper.h
• VMM_Shaper.cxx