MM_ElectronicsResponseSimulation Class Reference

#include <MM_ElectronicsResponseSimulation.h>

Collaboration diagram for MM_ElectronicsResponseSimulation:

Classes
struct	ConfigModule
struct	DataCache

Public Member Functions
	MM_ElectronicsResponseSimulation (ConfigModule &&module)
	MM_ElectronicsResponseSimulation.cxx MC for micromegas athena integration.
	~MM_ElectronicsResponseSimulation ()=default
MM_DigitToolOutput	getPeakResponseFrom (const MM_ElectronicsToolInput &digiInput) const
MM_DigitToolOutput	getThresholdResponseFrom (const MM_ElectronicsToolInput &digiInput) const
float	getPeakTime () const
float	getTimeWindowLowerOffset () const
float	getTimeWindowUpperOffset () const
float	getVmmDeadTime ()
float	getVmmUpperGrazeWindow ()
float	getStripdeadtime () const
float	getARTdeadtime () const

Private Member Functions
void	vmmPeakResponseFunction (DataCache &cache, const MM_ElectronicsToolInput &digiInput) const
void	vmmThresholdResponseFunction (DataCache &cache, const MM_ElectronicsToolInput &digiInput) const

Private Attributes
const ConfigModule	m_cfg {}
std::unique_ptr< VMM_Shaper >	m_vmmShaper {}

Detailed Description

Definition at line 31 of file MM_ElectronicsResponseSimulation.h.

Constructor & Destructor Documentation

MM_ElectronicsResponseSimulation()

MM_ElectronicsResponseSimulation::MM_ElectronicsResponseSimulation

(

ConfigModule &&

module

)

MM_ElectronicsResponseSimulation.cxx MC for micromegas athena integration.

Definition at line 21 of file MM_ElectronicsResponseSimulation.cxx.

                                                                                       :
    m_cfg{std::move(module)} {
    // let the VMM peak search run in a wider window in order to simulate the dead time and to avoid a bug at the upper limit of the time
    // window
    m_vmmShaper =
        std::make_unique<VMM_Shaper>(m_cfg.peakTime, m_cfg.timeWindowLowerOffset - m_cfg.vmmDeadtime, m_cfg.timeWindowUpperOffset + m_cfg.vmmUpperGrazeWindow);
    m_vmmShaper->initialize();
}

~MM_ElectronicsResponseSimulation()

MM_ElectronicsResponseSimulation::~MM_ElectronicsResponseSimulation ( )

default

Member Function Documentation

getARTdeadtime()

float MM_ElectronicsResponseSimulation::getARTdeadtime ( ) const

inline

Definition at line 60 of file MM_ElectronicsResponseSimulation.h.

{ return m_cfg.artDeadTime; };

getPeakResponseFrom()

MM_DigitToolOutput MM_ElectronicsResponseSimulation::getPeakResponseFrom

(

const MM_ElectronicsToolInput &

digiInput

)

const

ToDo: include loop for calculating Trigger study vars

Definition at line 30 of file MM_ElectronicsResponseSimulation.cxx.

                                                                                                                       {
    DataCache cache{};
    vmmPeakResponseFunction(cache, digiInput);

    // MM_DigitToolOutput(bool hitWasEff, std::vector <int> strpos, std::vector<float> time, std::vector<int> charge, std::vector<float>
    // threshold, int strTrig, float strTimeTrig ):
    MM_DigitToolOutput to_ret{true, std::move(cache.nStripElectronics), 
                                 std::move(cache.tStripElectronicsAbThr), 
                                 std::move(cache.qStripElectronics), 5, 0.3};
 
    return to_ret;
}

getPeakTime()

float MM_ElectronicsResponseSimulation::getPeakTime ( ) const

inline

Definition at line 54 of file MM_ElectronicsResponseSimulation.h.

{ return m_cfg.peakTime; };

getStripdeadtime()

float MM_ElectronicsResponseSimulation::getStripdeadtime ( ) const

inline

Definition at line 59 of file MM_ElectronicsResponseSimulation.h.

{ return m_cfg.stripDeadTime; };

getThresholdResponseFrom()

MM_DigitToolOutput MM_ElectronicsResponseSimulation::getThresholdResponseFrom

(

const MM_ElectronicsToolInput &

digiInput

)

const

Definition at line 44 of file MM_ElectronicsResponseSimulation.cxx.

                                                                                                                            {
    DataCache cache{};
    vmmThresholdResponseFunction(cache, digiInput);
    MM_DigitToolOutput to_ret{true, std::move(cache.nStripElectronics), 
                                std::move(cache.tStripElectronicsAbThr), 
                                std::move(cache.qStripElectronics), 5, 0.3};
    return to_ret;
}

getTimeWindowLowerOffset()

float MM_ElectronicsResponseSimulation::getTimeWindowLowerOffset ( ) const

inline

Definition at line 55 of file MM_ElectronicsResponseSimulation.h.

{ return m_cfg.timeWindowLowerOffset; };

getTimeWindowUpperOffset()

float MM_ElectronicsResponseSimulation::getTimeWindowUpperOffset ( ) const

inline

Definition at line 56 of file MM_ElectronicsResponseSimulation.h.

{ return m_cfg.timeWindowUpperOffset; };

getVmmDeadTime()

float MM_ElectronicsResponseSimulation::getVmmDeadTime ( )

inline

Definition at line 57 of file MM_ElectronicsResponseSimulation.h.

{ return m_cfg.vmmDeadtime; }

getVmmUpperGrazeWindow()

float MM_ElectronicsResponseSimulation::getVmmUpperGrazeWindow ( )

inline

Definition at line 58 of file MM_ElectronicsResponseSimulation.h.

{ return m_cfg.vmmUpperGrazeWindow; }

vmmPeakResponseFunction()

void MM_ElectronicsResponseSimulation::vmmPeakResponseFunction ( DataCache & cache, const MM_ElectronicsToolInput & digiInput ) const

private

Definition at line 53 of file MM_ElectronicsResponseSimulation.cxx.

                                                                                                                               {
    
    
    const std::vector<int>& numberofStrip = digiInput.NumberOfStripsPos();
    const std::vector<std::vector<float>>& qStrip =  digiInput.chipCharge();
    const std::vector<std::vector<float>>& tStrip = digiInput.chipTime();
    const std::vector<float>& stripsElectronicsThreshold = digiInput.stripThreshold();
    
    for (unsigned int ii = 0; ii < numberofStrip.size(); ii++) {
        // find min and max times for each strip:
        bool thisStripFired{false};
        double leftStripFired = false;
        double rightStripFired = false;
 
        // find the maximum charge:
        if (m_cfg.useNeighborLogic) {  // only check neighbor strips if VMM neighbor logic is enabled
            if (ii > 0) {
                leftStripFired =
                    m_vmmShaper->hasChargeAboveThreshold(qStrip.at(ii - 1), tStrip.at(ii - 1), stripsElectronicsThreshold.at(ii - 1));
            }
 
            if (ii + 1 < numberofStrip.size()) {
                rightStripFired =
                    m_vmmShaper->hasChargeAboveThreshold(qStrip.at(ii + 1), tStrip.at(ii + 1), stripsElectronicsThreshold.at(ii + 1));
            }
        }
 
        thisStripFired = m_vmmShaper->hasChargeAboveThreshold(qStrip.at(ii), tStrip.at(ii), stripsElectronicsThreshold.at(ii));
 
        // check if neighbor strip was above threshold
        bool neighborFired = leftStripFired || rightStripFired;
 
        // Look at strip if it or its neighbor was above threshold  and if neighbor logic of the VMM is enabled:
        if (thisStripFired || (m_cfg.useNeighborLogic && neighborFired)) {
            double charge{FLT_MAX}, time{FLT_MAX};
 
            // if strip is below threshold but read through NL reduce threshold to low value of 1e to still find the peak
            float tmpScaledThreshold = (thisStripFired ? stripsElectronicsThreshold.at(ii) : 1);
 
            bool foundPeak = m_vmmShaper->vmmPeakResponse(qStrip.at(ii), tStrip.at(ii), tmpScaledThreshold, charge, time);
            if (!foundPeak) continue;  // if no peak was found within the enlarged time window the strip is skipped and no digit is created.
            if (time < m_cfg.timeWindowLowerOffset || time > m_cfg.timeWindowUpperOffset)
                continue;  // only accept strips in the correct time window
 
            cache.nStripElectronics.push_back(numberofStrip.at(ii));
            cache.tStripElectronicsAbThr.push_back(time);
            cache.qStripElectronics.push_back(charge);
        }
    }
}

vmmThresholdResponseFunction()

void MM_ElectronicsResponseSimulation::vmmThresholdResponseFunction ( DataCache & cache, const MM_ElectronicsToolInput & digiInput ) const

private

Definition at line 104 of file MM_ElectronicsResponseSimulation.cxx.

                                                                                                                                    {
    
    const std::vector<int>& numberofStrip = digiInput.NumberOfStripsPos();
    const std::vector<std::vector<float>>& qStrip = digiInput.chipCharge();
    const std::vector<std::vector<float>>& tStrip = digiInput.chipTime();
    const std::vector<float>& electronicsThreshold = digiInput.stripThreshold();
 
    for (unsigned int ii = 0; ii < numberofStrip.size(); ii++) {
        double localThresholdt{FLT_MAX}, localThresholdq{FLT_MAX};
 
        bool crossedThreshold =
            m_vmmShaper->vmmThresholdResponse(qStrip.at(ii), tStrip.at(ii), electronicsThreshold.at(ii), localThresholdq, localThresholdt);
        if (!crossedThreshold)
            continue;  // if no threshold crossing was found within the time window the strip is skipped and no digits are created.
        if (localThresholdt < m_cfg.timeWindowLowerOffset || localThresholdt > m_cfg.timeWindowUpperOffset)
            continue;  // only accept strips in the correct time window
 
        cache.nStripElectronics.push_back(numberofStrip.at(ii));
        cache.tStripElectronicsAbThr.push_back(localThresholdt);
        cache.qStripElectronics.push_back(localThresholdq);
    }
}

Member Data Documentation

m_cfg

const ConfigModule MM_ElectronicsResponseSimulation::m_cfg {}

private

Definition at line 65 of file MM_ElectronicsResponseSimulation.h.

{};

m_vmmShaper

std::unique_ptr<VMM_Shaper> MM_ElectronicsResponseSimulation::m_vmmShaper {}

private

Definition at line 74 of file MM_ElectronicsResponseSimulation.h.

{};

---

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

• MM_ElectronicsResponseSimulation.h
• MM_ElectronicsResponseSimulation.cxx