CscRODReadOut.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#include "CscRODReadOut.h"
 
// constructor
CscRODReadOut::CscRODReadOut() : m_cscIdHelper(nullptr), m_chamberBitValue(0) {
    m_TIME_OFFSET = 46.825;  // ns
    m_SIGNAL_WIDTH = 16.08;  // ns
    m_NUMBER_OF_INTEGRATION = 12;
    m_Z0 = (m_NUMBER_OF_INTEGRATION + 1) - sqrt(m_NUMBER_OF_INTEGRATION + 1);  // time bin at the maximum
                                                                               // obtained by setting the derivative = 0
                                                                               // this gives 2 solutions:
                                                                               // Z0=9.394 and 16.606
                                                                               // 9.394 is for positive amplitude
 
    // conversion factor from ee charge to ADC count
    // assuming for now 1 ADC count = 0.32 femtoCoulomb!
 
    /* From Valeri Tcherniatine --- April 11, 2004
      conversion= ( e*G*k*m*d*1.6e-19)/2000
      e=75 - average number ionization e in CSC
      G=10^5 - gas gain
      k=0.15 - factor taking to account electronic time integration (charge
      deficit) and only one cathode readout
      m=0.5 - part of induce charge contained in max. strip
      d=7 - value of dynamic range expressed in average particle ionization
      deposition in CSC. At this value (7) out of region inefficiency is <2%.
      1.6e-19 - e charge
      2000 - max. ADC counts for positive part of signal
      Collect all numbers together conversion = 0.32 femtoCoulomb per ADC count
    */
 
    m_CHARGE_TO_ADC_COUNT = (0.32e-15) / (1.602e-19);
    m_norm = signal(m_Z0);
}
 
CscRODReadOut::CscRODReadOut(double startTime, double signalWidth, uint16_t numIntegration) : m_cscIdHelper(nullptr), m_chamberBitValue(0) {
    m_TIME_OFFSET = startTime;     // ns
    m_SIGNAL_WIDTH = signalWidth;  // ns
    m_NUMBER_OF_INTEGRATION = numIntegration;
    m_Z0 = (m_NUMBER_OF_INTEGRATION + 1) - sqrt(m_NUMBER_OF_INTEGRATION + 1);  // time bin at the maximum
                                                                               // obtained by setting the derivative = 0
                                                                               // this gives 2 solutions:
                                                                               // Z0=9.394 and 16.606
                                                                               // 9.394 is for positive amplitude
 
    m_CHARGE_TO_ADC_COUNT = (0.32e-15) / (1.602e-19);
    m_norm = signal(m_Z0);
}
 
void CscRODReadOut::encodeFragments(const std::vector<uint16_t>& amplitude, std::vector<uint32_t>& v) const {
    int numberOfFragments = amplitude.size();
 
    // now the data
 
    int j = 0;
    while (j < numberOfFragments) {
        uint32_t v32 = 0;
        uint16_t amp[2] = {0, 0};
        for (int i = 0; i < 2; i++) { amp[i] = (BODY_AMPLITUDE << 12) | amplitude[i + j]; }
        set32bits(amp, v32);
        v.push_back(v32);
        j += 2;
    }
}
 
int CscRODReadOut::findCharge(double samplingTime, const std::vector<uint16_t>& amplitude, double& time) {
    // very crude - to be done better
 
    int charge = 0;
    time = 0.0;
 
    int numberOfSamplings = amplitude.size();
 
    uint16_t max = 0;
    int maxIndex = -1;
    for (int i = 0; i < numberOfSamplings; i++) {
        if (amplitude[i] > max) {
            max = amplitude[i];
            maxIndex = i;
        }
    }
 
    if (max == 0) return charge;
    if (maxIndex < 0 || maxIndex >= numberOfSamplings) return charge;

    if (maxIndex == 0)
        return amplitude[0];
    else if (maxIndex == (numberOfSamplings - 1))
        return amplitude[numberOfSamplings - 1];
    else {
        double a, b, c;
        double y1 = amplitude[maxIndex - 1];
        double y2 = amplitude[maxIndex];
        double y3 = amplitude[maxIndex + 1];
        a = 0.5 * (y3 + y1 - 2 * y2);
        b = 0.5 * (y3 - y1);
        c = y2;

        double offset = (a == 0) ? 0 : -b / (2 * a);
        charge = static_cast<int>(a * offset * offset + b * offset + c - amplitude[0]);  
        time = (maxIndex + offset) * samplingTime;
        return charge;
    }
}