MEvent/ScintillatorSimData.h

Go to the documentation of this file.

#ifndef _mevt_ScintillatorSimData_h_
#define _mevt_ScintillatorSimData_h_

// For frienship declaration, just forward declare.
#include <utl/ShadowPtr_fwd.h>
#include <utl/Particle.h>
//
#include <utl/ShadowPtr.h>
#include <utl/Trace.h>
#include <utl/TimeStamp.h>

#include <list>

#include <boost/iterator/indirect_iterator.hpp>
#include <mdet/Pixel.h>

namespace mevt {

  class Scintillator;


  class ScintillatorSimData {

  public:
    // structure holds information about single photo electron pulses before amplification - if PMT
    struct SPEPulse {
      double fMu;  // time
      double fSigma;  // width in time, std (depends on setting of pulseParametrization in MModelConfig!!)
      double fAmplitude;  // charge (depends on setting of pulseParametrization in MModelConfig!!)
      int fDestPixelId; // id of pixel where the spe goes after crosstalk, is not necessary the one that is retrieved by ScintillatorToPixelId() !
    };

    // structure holds information about photo equivalent pulses before amplification - if SiPM
    struct PEPulse {
      double fT0;
      double fAmplitude1;  // Amplitude 1 (depends on setting of pulseParametrization in MModelConfig!!)
      double fAmplitude2;  // Amplitude 2 (depends on setting of pulseParametrization in MModelConfig!!)
      double fAmplitude3;  // Amplitude 3 (depends on setting of pulseParametrization in MModelConfig!!)
      double fRiseTime;  // Rise Time (depends on setting of pulseParametrization in MModelConfig!!)
      double fFallTime1;  // Fall Time fast (depends on setting of pulseParametrization in MModelConfig!!)
      double fFallTime2;  // Fall Time slow (depends on setting of pulseParametrization in MModelConfig!!)
      double fFallTime3;  // Fall Time slow (depends on setting of pulseParametrization in MModelConfig!!)
      int fDestPixelId;  // id of pixel where the spe goes after crosstalk, is not necessary the one that is retrieved by ScintillatorToPixelId() !
    };

     // structure holds the arrival time of the G4 simulated photons
     struct PhotonTime {
       double fTime;
     };

  private:
    /*
     * sevt::StationSimData
     * uses std::vector as container. Even more, the name of the typedef
     * talks about vector. The name I believe should be other, but that's
     * a cosmetic issue.
     * The usage context is the following:
     * - No random access.
     * - Insertion only at the end.
     * - Front-to-back linear iteration.
     * - No prior knowledge of total number of particles.
     * - A O(1) (implicit) way of calculating the number of particles
     *   through the difference between begin and end iterators.
     *
     * Then a vector (continuous memory allocation) may not
     * be the most proper structure: mainly due to the reallocation, copying
     * of the contained objects when the current total continuous storage
     * exhaust. With a naive implementation of vector (allocating +1 buckets
     * storage) the insertion of n elements from scratch ends up begin n^2.
     * Nevertheless, typical implementations of the standard library
     * upon each reallocation they require times two the previous size.
     * Given that, an amortized linear time is achieved (though plenty
     * of copying and destructing underneath).
     * I actually ran the example application
     * /Documentation/ExampleApplications/SSimulation
     * with list and vector, with 10000 and 100000 particles and no
     * difference was found (the benchmark wasn't too conlusive, of course).
     *
     * The cons agains the usage of list are:
     * - Memory overhead. List is double-linked (the single linked slist) is not
     *   standard. In this case each node is composed of a particle (wrapped in a shadow
     *   pointer) so the addition of, say, 8 bytes for the two pointers sees marginal.
     * - Memory contiguity. The continuous storage may allow some fetching optimizations
     *   but given that at the end the actual objets are heap-allocated and then accessed
     *   through pointers it seems that no locality advantage will be found.
     *
     * Having said this, I prefer std::list; and keeping a counter in this class to
     * keep track of the number of particles (recall that size in list is tipically
     * linear). Having an explicit member to query the number of particles seems
     * better than to have it calculated through the difference of pointers.
     */
    typedef utl::ShadowPtr<utl::Particle> ParticlePtr;
    typedef std::list<ParticlePtr> InternalParticleContainer;
    typedef InternalParticleContainer::iterator InternalParticleIterator;
    typedef InternalParticleContainer::const_iterator InternalConstParticleIterator;

    typedef std::list<SPEPulse> SPEPulseContainer;
    typedef std::list<PEPulse> PEPulseContainer;
    typedef std::list<PhotonTime> PhotonTimeContainer;

  public:
    typedef boost::indirect_iterator<InternalParticleIterator, utl::Particle&> ParticleIterator;
    typedef boost::indirect_iterator<InternalConstParticleIterator, const utl::Particle&> ConstParticleIterator;
    typedef SPEPulseContainer::iterator SPEPulseIterator;
    typedef SPEPulseContainer::const_iterator ConstSPEPulseIterator;

    typedef PEPulseContainer::iterator PEPulseIterator;
    typedef PEPulseContainer::const_iterator ConstPEPulseIterator;

    typedef PhotonTimeContainer::iterator PhotonTimeIterator;
    typedef PhotonTimeContainer::const_iterator ConstPhotonTimeIterator;

    ParticleIterator ParticlesBegin() { return fParticles.begin(); }
    ConstParticleIterator ParticlesBegin() const { return fParticles.begin(); }
    ParticleIterator ParticlesEnd() { return fParticles.end(); }
    ConstParticleIterator ParticlesEnd() const { return fParticles.end(); }

    void AddParticle(const utl::Particle& particle);

    SPEPulseIterator SPEPulsesBegin() { return fSPEPulses.begin(); }
    ConstSPEPulseIterator SPEPulsesBegin() const { return fSPEPulses.begin(); }
    SPEPulseIterator SPEPulsesEnd() { return fSPEPulses.end(); }
    ConstSPEPulseIterator SPEPulsesEnd() const { return fSPEPulses.end(); }

    void AddSPEPulse(const double mu, const double sigma, const double amplitude, const int destPixelId);

    int GetNumberOfSPEPulses() const {return fSPEPulses.size();}

    PEPulseIterator PEPulsesBegin() { return fPEPulses.begin(); }
    ConstPEPulseIterator PEPulsesBegin() const { return fPEPulses.begin(); }
    PEPulseIterator PEPulsesEnd() { return fPEPulses.end(); }
    ConstPEPulseIterator PEPulsesEnd() const { return fPEPulses.end(); }

    void AddPEPulse(const double t0, const double a1, const double a2, const double a3, const double timeRise,
                    const double timeFall1, const double timeFall2, const double timeFall3, const int destPixelId);

    int GetNumberOfPEPulses() const {return fPEPulses.size();}

    PhotonTimeIterator PhotonTimesBegin() { return fPhotonTimes.begin(); }
    ConstPhotonTimeIterator PhotonTimesBegin() const { return fPhotonTimes.begin(); }
    PhotonTimeIterator PhotonTimesEnd() { return fPhotonTimes.end(); }
    ConstPhotonTimeIterator PhotonTimesEnd() const { return fPhotonTimes.end(); }

    void AddPhotonTime(const double t0);
    double GetPhotonTime(const PhotonTime& photon) const;

    int GetNumberOfPhotonTimes() const { return fPhotonTimes.size(); }

    void IncrementNumberOfInjectedMuons() { ++fNumberOfInjectedMuons; }

    void IncrementNumberOfCornerClippingMuons() { ++fNumberOfCornerClippingMuons; }

    void IncrementNumberOfElectrons() { ++fNumberOfElectrons; }

    void AddEnergyDeposit(const double edep) { fEnergyDeposit += edep; }

    void AddEnergyDepositMuons(const double edep) { fEnergyDepositMuons += edep; }

    void SetNumberOfInjectedMuons(const unsigned int nmuons) { fNumberOfInjectedMuons = nmuons; }

    void SetNumberOfCornerClippingMuons(const unsigned int nmuons) { fNumberOfCornerClippingMuons = nmuons; }

    void SetNumberOfElectrons(const unsigned int electrons) { fNumberOfElectrons = electrons; }

    void SetEnergyDeposit(const double edep) { fEnergyDeposit = edep; }

    void SetEnergyDepositMuons(const double edep) { fEnergyDepositMuons = edep; }

    unsigned int GetNumberOfInjectedMuons() const { return fNumberOfInjectedMuons; }

    unsigned int GetNumberOfCornerClippingMuons() const { return fNumberOfCornerClippingMuons; }

    unsigned int GetNumberOfElectrons() const { return fNumberOfElectrons; }

    double GetEnergyDeposit() const { return fEnergyDeposit; }

    unsigned int GetEnergyDepositMuons() const { return fEnergyDepositMuons; }

    void ClearParticleList();

    unsigned int GetNumberOfParticles() const { return fNParticles; }

    utl::TraceD& GetAnalogicTrace();

    const utl::TraceD& GetAnalogicTrace() const;

    void MakeAnalogicTrace();

    bool HasAnalogicTrace() const;
   
  private:
    ScintillatorSimData() = default;
    ~ScintillatorSimData() = default;

    unsigned int fNParticles = 0;
    unsigned int fNumberOfInjectedMuons = 0;
    unsigned int fNumberOfCornerClippingMuons = 0;
    unsigned int fNumberOfElectrons = 0;
    double fEnergyDeposit = 0;
    double fEnergyDepositMuons = 0;
    InternalParticleContainer fParticles;

    utl::ShadowPtr<utl::TraceD> fAnalogicTrace;

    

    SPEPulseContainer fSPEPulses;

    PEPulseContainer fPEPulses;

    PhotonTimeContainer fPhotonTimes;
    /*
     * Like sevt::StationRecData nothing said about
     * operator= and copy-construction: let the compiler
     * generate'em.
     */
    friend class Scintillator;
    friend class utl::ShadowPtr<ScintillatorSimData>;
    /*
     * The usual case is just to have primitive types
     * in here. So this class is like POD but a little
     * spiced in the sense that its construction is
     * privileged.
     */
  };

}


#endif