MdCounterSimulator.h

Go to the documentation of this file.

#ifndef _MdCounterSimulatorAG_MdCounterSimulator_h_
#define _MdCounterSimulatorAG_MdCounterSimulator_h_

#include <utl/config.h> // before all

#include <fwk/VModule.h>
// Need the full definition of Pixel::SPE as template arg of the list.
#include <mdet/Pixel.h> 
#include <mdet/SiPM.h>
#include <mdet/BackEndSiPM.h>
#include <mdet/MDetector.h>

#include <evt/Event.h>
#include <mevt/MEvent.h>
//
#include <utl/AugerUnits.h>
#include <utl/Trace-fwd.h>
//#include <utl/Trace.h>
#include <utl/MessageLoggerConfig.h>
#include <utl/UnitsConfig.h>
#include <utl/FFTDataContainer.h>
//
#include <map>
#include <list>
#include <algorithm>
#include <iostream>
#include <vector>
#include <cmath>
#include <fstream>
#include <set>
#include <TVector.h>
//
#include <boost/utility.hpp>
//

//fwds

class TStyle;
class TF1;

namespace mdet {
  class Module;
  class Scintillator;
  class FrontEnd;
  class Channel;
  class FrontEndSiPM;
  class BackEndSiPM;
  class ChannelSiPM;
}

namespace mevt {
  class ScintillatorSimData;
  class Module;
}

namespace utl {
  class TimeStamp;
  class TimeInterval;
  class TabularStream;
}

using namespace mdet;

namespace MdCounterSimulatorAG {


  class MdCounterSimulator : 
      public boost::noncopyable,
      public fwk::VModule {
  public:
    enum SimulationType { 
      eFromMEvent,              
      eFromMEventSimulatedScint 
    };

    enum IntegratorSimulationType {
      eStepByStep,
      eSimplified 
    };
    static const char* const kSimulationTypeTags[];

    static const char* const kIntegratorSimulationTypeTags[];

    MdCounterSimulator();
    ~MdCounterSimulator();
    VModule::ResultFlag Init();
    VModule::ResultFlag Run(evt::Event& e);
    VModule::ResultFlag Finish();

        typedef utl::TraceD TimeTrace;
        typedef utl::TraceC FrequencyTrace;
  private:
    typedef std::list<mdet::Pixel::SPE>    PulseContainer;
    typedef std::list<mdet::SiPM::PE>    SiPMPulseContainer;

    struct SignalInformation {
      SignalInformation() : fScintSimData(0) {
      }
      PulseContainer fPulses;
      SiPMPulseContainer fSiPMPulses;
      const mevt::ScintillatorSimData* fScintSimData;
    };
    typedef std::map<int, SignalInformation > SignalsMap;
    virtual void ProcessPulses(
      const mdet::Channel& c, 
      const SignalInformation& signalInfo, 
      utl::TraceB& trace, 
      double& span,
      const utl::TimeInterval& traceStart,
      const utl::TimeStamp& eventTime);

    /*Overload for SiPM simulation. Calls ChannelSiPM and enables analogic trace.*/
    virtual void ProcessPulses(
      const mdet::ChannelSiPM& c,
      const SignalInformation& signalInfo,
      utl::TraceB& trace,
          utl::TraceD& analogSignal,
      double& span,
      const utl::TimeInterval& traceStart,
          double& minTimePreFE,
          double& maxTimePreFE,
          double& analogicTraceStartTime,
          double& analogicTraceEndTime);

    virtual double GetPulseTimeSpan(
      const SignalInformation& si,
      const utl::TimeStamp& eventTime,
          double& minTimePreFE,
          double& maxTimePreFE,
          double& analogicTraceStartTime,
          double& analogicTraceEndTime);

    virtual void ApplyCITIROCTransfer(
      const mdet::ChannelSiPM& channel,
      const SignalInformation& si,
          const double pulseTimeSpan,
          double minTimePreFE,
      double analogicTraceStartTime,
          double analogicTraceEndTime,
          TimeTrace& totalPulsePostFrontEndTrace,
      TimeTrace& totalPulsePostDiscriminatorTrace,
          utl::TraceD& traceAnalogical);

    virtual void SampleTrace(
      double minTimePostFE,
          double maxTimePostFE,
          double binning,
          const mdet::FrontEndSiPM& frontEnd,
          const utl::TimeInterval& traceStart,
          TimeTrace& totalPulsePostDiscriminatorTrace,
          utl::TraceB& trace);

    virtual void InjectDigitalNoise(
      const mdet::Module& module,
          mevt::Module& evtModule);

    virtual void PlotChannel(
      const double traceStartTime,
          const double minTimePreFE,
          const double binning,
          const mdet::ChannelSiPM& channel,
          utl::TraceD& traceAnalogical,
          TimeTrace& totalPulsePostFrontEndTrace,
          TimeTrace& totalPulsePostDiscriminatorTrace,
          utl::TraceB& trace);


    virtual void ProcessPulsesIntegrator(
          const mdet::Module& module,
          std::vector<utl::TraceD> analogicalTraces,
          utl::TraceUSI& traceIntegratorA,
          utl::TraceUSI& traceIntegratorB,
          const utl::TimeInterval& traceStart,
          double& minTimePreFE,
          double& maxTimePreFE);

    virtual void ApplyBackEndTransferWStepSaturation(
      const mdet::BackEndSiPM& backEnd,
      const double maxTimePreFE,
      const double minTimePreFE,
      TimeTrace& traceAfterADCLowGain,
      TimeTrace& traceAfterADCHighGain,
      TVectorD& totalAnalogicalInput,
      const std::vector<utl::TraceD> traceAnalogical);

    virtual void ApplyBackEndTransfer(
      const mdet::BackEndSiPM& backEnd,
          const double maxTimePreFE,
          const double minTimePreFE,
      TimeTrace& traceAfterADCLowGain,
          TimeTrace& traceAfterADCHighGain,
          TVectorD& totalAnalogicalInput,
          const std::vector<utl::TraceD> traceAnalogical);


    virtual void ApplyTransferBlock(
      utl::FFTDataContainer<utl::Trace, TimeTrace::ValueType, FrequencyTrace::ValueType>& fft,
          const mdet::BackEndSiPM& backEnd,
          BackEndSiPM::TransferStep step);

    virtual void ApplyTransferBlocks(
      utl::FFTDataContainer<utl::Trace, TimeTrace::ValueType, FrequencyTrace::ValueType>& fft,
      utl::FFTDataContainer<utl::Trace, TimeTrace::ValueType, FrequencyTrace::ValueType>& fftHG,
      const mdet::BackEndSiPM& backEnd);

    virtual void SampleTraceADC(
      const double minTimePostFE,
          const double maxTimePostFE,
          const mdet::FrontEndSiPM& frontEnd,
      const utl::TimeInterval& traceStart,
          TimeTrace& traceAfterADCLowGain,
          TimeTrace& traceAfterADCHighGain,
          utl::TraceUSI& traceIntegratorA,
          utl::TraceUSI& traceIntegratorB);

    virtual void PlotIntegrator(
      const double traceStartTime,
          const double minTimePreFE,
          const double binning,
          const mdet::FrontEndSiPM& frontEnd,
          TVectorD& traceAnalogical,
          TimeTrace& traceIntegratorAAmplifier,
          TimeTrace& traceIntegratorBAmplifier,
          utl::TraceUSI& traceIntegratorA,
          utl::TraceUSI& traceIntegratorB);

    VModule::ResultFlag RunFromMEvent(evt::Event& e);
    VModule::ResultFlag RunFromMEventScintillatorSimulated(evt::Event& e);
    virtual VModule::ResultFlag SimulatePulses(
      const mdet::Scintillator& scint, 
      const mevt::ScintillatorSimData& ssd, 
      mevt::ScintillatorSimData& ssd_nonconst, 
      SignalsMap& sm);
    virtual VModule::ResultFlag SimulateElectronics(
      mevt::Module& evtModule, 
      const mdet::Module& module, 
      const SignalsMap& sm,
      const utl::TimeStamp& eventTime);
    int GetTriggerTimeFromSD(evt::Event& , const mdet::Counter&, mevt::MEvent::CounterIterator, double& );
    void Init(std::unique_ptr<utl::TabularStream>& pt, unsigned int nCol) const;
    void Dump(const TF1& fun, const std::string& suffix);
    unsigned int fRunNumber;
    unsigned int fNDiscretization;
    utl::MessageLoggerConfig fLog;
    std::vector<std::string> fPlotFileExtensions;
    unsigned int fNumPlotPoints;
    SimulationType fSimType;
    IntegratorSimulationType fIntegratorSimType;
    unsigned int fNRepetitions;
    unsigned int fNBinsHistograms;
    unsigned int fMinSPE;
    unsigned int fMaxSPE;
    unsigned int fStepSPE;
    bool fForcedSDTrigger; // Uses MD data irrespectively of WCD trigger
    bool fIgnoreCrossTalk; // The idea of this flag could be extended to other cases.
    utl::UnitsConfig fUnits;
    std::string fPulseFilename;
    std::ofstream fPulseFile;
    unsigned int fNPulseSamples;
    double fPulseSampleWindow; 
    bool fGenerateSPEPulseOutput;
    bool fGeneratePreFETotalPulseOutput;
    bool fGeneratePostFETotalPulseOutput;
    bool fIncludeBaseLineFluctuationIntegrator;

    bool fInjectNoiseBinary;
    typedef int ParticleType;
    std::set<ParticleType> fAllowedParticleTypes;
    /*
     * Ploting configuration.
     */
    // Configure if the plot is to be output.
    bool fPlotChannelPulses;
    bool fPlotOutcome;
    bool fPlotInputOutput;
    bool fPlotTransferAmpResponse;
    bool fPlotTransferPhaseResponse;
    bool fPlotDelay;
    bool fPlotFftPriorAmp;
    bool fPlotFftPostAmp;

    // Configure if the default (plot or not) is toggled.
    bool fTogglePlotchannelPulses;
    bool fToggleOutcome;
    bool fToggleInputOutput;
    bool fToggleTransferAmpResponse;
    bool fToggleTransferPhaseResponse;
    bool fToggleDelay;
    bool fToggleFftPriorAmp;
    bool fTogglePlotFftPostAmp;
    // 
    TStyle *fStyle;
    //
    REGISTER_MODULE("MdCounterSimulatorAG", MdCounterSimulator);
  };
}

#endif // _MdCounterSimulatorAG_MdCounterSimulator_h_