QIE8Simulator.cc

Go to the documentation of this file.

#include <cmath>
#include <cfloat>

#include "CalibCalorimetry/HcalAlgos/interface/QIE8Simulator.h"

QIE8Simulator::QIE8Simulator()
    : preampOutputCut_(-1.0e100), inputGain_(1.0),
      outputGain_(1.0), runCount_(0),
      chargeNode_(AbsElectronicODERHS::invalidNode),
      integrateToGetCharge_(false),
      useCubic_(false)
{
}

QIE8Simulator::QIE8Simulator(const AbsElectronicODERHS& model,
                             const unsigned chargeNode,
                             const bool interpolateCubic,
                             const double preampOutputCut,
                             const double inputGain,
                             const double outputGain)
    : solver_(model),
      preampOutputCut_(preampOutputCut),
      inputGain_(inputGain),
      outputGain_(outputGain),
      runCount_(0),
      chargeNode_(chargeNode),
      useCubic_(interpolateCubic)
{
    if (chargeNode >= AbsElectronicODERHS::invalidNode)
        throw cms::Exception(
            "In QIE8Simulator constructor: invalid charge collection node");
    integrateToGetCharge_ = chargeNode == model.outputNode();
    validateGain();
    zeroInitialConditions();
}

unsigned QIE8Simulator::run(const double dt, const double tstop,
                            const double tDigitize,
                            double* TS, const unsigned lenTS)
{
    if (chargeNode_ >= AbsElectronicODERHS::invalidNode)
        throw cms::Exception(
            "In QIE8Simulator::run: preamp model is not set");

    // Check arguments for validity
    if (dt <= 0.0) throw cms::Exception(
        "In QIE8Simulator::run: invalid time step");

    if (tstop < dt) throw cms::Exception(
        "In QIE8Simulator::run: invalid stopping time");

    if (lenTS && tDigitize < 0.0) throw cms::Exception(
        "In QIE8Simulator::run: can't digitize at t < 0");

    // Determine the number of time steps
    const double dsteps = tstop/dt;
    unsigned n = dsteps;
    if (dsteps != static_cast<double>(n))
        ++n;
    if (n >= maxlen)
        n = maxlen - 1;

    // Run the simulation
    AbsElectronicODERHS& rhs = modifiableRHS();
    const unsigned numNodes = rhs.numberOfNodes();
    if (numNodes)
    {
        assert(initialConditions_.size() == numNodes);
        solver_.run(&initialConditions_[0], numNodes, dt, n);
    }
    else
    {
        // Special situation: the simulation does not
        // need to solve any ODE. Instead, it will fill
        // out the output directly.
        if (!(integrateToGetCharge_ && chargeNode_ == 0U))
            throw cms::Exception("In QIE8Simulator::run: "
                                     "invalid mode of operation");
        const unsigned runLen = n + 1U;
        if (historyBuffer_.size() < runLen)
            historyBuffer_.resize(runLen);
        double* hbuf = &historyBuffer_[0];
        for (unsigned istep=0; istep<runLen; ++istep, ++hbuf)
            rhs.calc(istep*dt, nullptr, 0U, hbuf);
        solver_.setHistory(dt, &historyBuffer_[0], 1U, runLen);
    }

    // Truncate the preamp output if this will affect subsequent results
    if (integrateToGetCharge_ && preampOutputCut_ > -0.9e100)
        solver_.truncateCoordinate(chargeNode_, preampOutputCut_, DBL_MAX);

    // Digitize the accumulated charge
    unsigned filled = 0;
    if (lenTS)
    {
        assert(TS);
        const double lastTStop = solver_.lastMaxT();
        const double tsWidth = this->adcTSWidth();
        double oldCharge = getCharge(tDigitize);
        for (unsigned its=0; its<lenTS; ++its)
        {
            const double t0 = tDigitize + its*tsWidth;
            if (t0 < lastTStop)
            {
                double t1 = t0 + tsWidth;
                if (t1 > lastTStop)
                    t1 = lastTStop;
                else
                    ++filled;
                const double q = getCharge(t1);
                TS[its] = (q - oldCharge)*outputGain_;
                oldCharge = q;
            }
            else
                TS[its] = 0.0;
        }
    }
    ++runCount_;
    return filled;
}

double QIE8Simulator::preampOutput(const double t) const
{
    if (!runCount_) throw cms::Exception(
        "In QIE8Simulator::preampOutput: please run the simulation first");
    const unsigned preampNode = getRHS().outputNode();
    if (preampNode >= AbsElectronicODERHS::invalidNode)
        return 0.0;
    else
        return outputGain_*solver_.interpolateCoordinate(
            preampNode, t, useCubic_);
}

double QIE8Simulator::controlOutput(const double t) const
{
    if (!runCount_) throw cms::Exception(
        "In QIE8Simulator::controlOutput: please run the simulation first");
    const unsigned controlNode = getRHS().controlNode();
    if (controlNode >= AbsElectronicODERHS::invalidNode)
        return 0.0;
    else
        return solver_.interpolateCoordinate(controlNode, t, useCubic_);
}

double QIE8Simulator::preampPeakTime() const
{
    if (!runCount_) throw cms::Exception(
        "In QIE8Simulator::preampPeakTime: please run the simulation first");
    const unsigned preampNode = getRHS().outputNode();
    if (preampNode >= AbsElectronicODERHS::invalidNode) throw cms::Exception(
        "In QIE8Simulator::preampPeakTime: no preamp node in the circuit");
    return solver_.getPeakTime(preampNode);
}

void QIE8Simulator::setInitialConditions(
    const double* values, const unsigned sz)
{
    const unsigned nExpected = getRHS().numberOfNodes();
    if (sz != nExpected) throw cms::Exception(
        "In QIE8Simulator::setInitialConditions: unexpected number "
        "of initial conditions");
    assert(sz == initialConditions_.size());
    if (sz)
    {
        double* c = &initialConditions_[0];
        for (unsigned i=0; i<sz; ++i)
            *c++ = *values++;
    }
}

void QIE8Simulator::setRHS(const AbsElectronicODERHS& rhs,
                           const unsigned chargeNode,
                           const bool useCubicInterpolation)
{
    if (chargeNode >= AbsElectronicODERHS::invalidNode) 
        throw cms::Exception(
            "In QIE8Simulator::setRHS invalid charge collection node");
    solver_.setRHS(rhs);
    chargeNode_ = chargeNode;
    integrateToGetCharge_ = chargeNode == rhs.outputNode();
    useCubic_ = useCubicInterpolation;
    zeroInitialConditions();
}

void QIE8Simulator::zeroInitialConditions()
{
    const unsigned sz = getRHS().numberOfNodes();
    if (initialConditions_.size() != sz)
        initialConditions_.resize(sz);
    if (sz)
    {
        double* c = &initialConditions_[0];
        for (unsigned i=0; i<sz; ++i)
            *c++ = 0.0;
    }
}

void QIE8Simulator::validateGain() const
{
    if (inputGain_ <= 0.0) throw cms::Exception(
        "In QIE8Simulator::validateGain: invalid input gain");
}

double QIE8Simulator::lastStopTime() const
{
    if (!runCount_) throw cms::Exception(
        "In QIE8Simulator::lastStopTime: please run the simulation first");
    return solver_.lastMaxT();
}

double QIE8Simulator::totalIntegratedCharge(const double t) const
{
    if (!runCount_) throw cms::Exception(
        "In QIE8Simulator::totalIntegratedCharge: "
        "please run the simulation first");
    return outputGain_*getCharge(t);
}