SEvent/StationSimData.h

Go to the documentation of this file.

#ifndef _sevt_StationSimData_h_
#define _sevt_StationSimData_h_

#include <sevt/StationGPSData.h>
#include <sevt/StationTriggerData.h>
#include <utl/ShadowPtr.h>
#include <utl/TimeStamp.h>
#include <utl/Particle.h>
#include <utl/IteratorRange.h>
#include <boost/range/adaptor/map.hpp>
#include <vector>
#include <algorithm>
#include <map>
#include <string>


namespace io {
  class StationSimData_ROOT;
}

namespace sevt {

  class StationSimData {

  private:
    typedef std::pair<StationTriggerData, StationGPSData> TriggerGPSPair;
    typedef std::map<utl::TimeStamp, TriggerGPSPair> TriggerGPSMap;
    typedef TriggerGPSMap::iterator TriggerGPSMapIterator;
    typedef TriggerGPSMap::const_iterator ConstTriggerGPSMapIterator;

  public:
    typedef std::vector<utl::Particle> ParticleVector;
    typedef ParticleVector::iterator ParticleIterator;
    typedef ParticleVector::const_iterator ConstParticleIterator;

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

    unsigned int GetNParticles() const { return fParticles.size(); }

  private:
    // Add particle to list of particles to be injected into the
    // virtual cyclinder housing either the WCD or both the WCD and
    // SSD (larger cylinder) if an SSD exists.
    void AddParticle(const utl::Particle& particle);

    // Update counters for particles to be injected into the virtual
    // cylinder (see description of AddParticle above) whose
    // trajectories intersect the WCD
    void CountParticle(const utl::Particle& particle);

  public:
    void ClearParticleList();

    unsigned int GetNumberOfMuons() const { return fNumberOfMuons; }

    void SetNumberOfMuons(const unsigned int n) { fNumberOfMuons = n; }

    unsigned int GetNumberOfElectrons() const { return fNumberOfElectrons; }

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

    unsigned int GetNumberOfPhotons() const { return fNumberOfPhotons; }

    void SetNumberOfPhotons(const unsigned int n) { fNumberOfPhotons = n; }

    unsigned int GetTotalParticleCount() const { return fTotalParticleCount; }

    void SetTotalParticleCount(const unsigned int n) { fTotalParticleCount = n; }

    unsigned int GetTotalSimParticleCount() const { return fTotalSimParticleCount; }

    void SetTotalSimParticleCount(const unsigned int n) { fTotalSimParticleCount = n; }

    unsigned int GetTotalSimCandidateParticleCount() const { return fTotalSimCandidateParticleCount; }

    void SetTotalSimCandidateParticleCount(const unsigned int n) { fTotalSimCandidateParticleCount = n; }

    unsigned int GetMaxNParticles() const { return fMaxNParticles; }

    void SetMaxNParticles(const unsigned int max) { fMaxNParticles = max; }

    double GetThinning() const { return fThinning; }

    void SetThinning(const double th) { fThinning = th; }

    double GetThinningFactor() const { return fThinningFactor; }

    void SetThinningFactor(const double f) { fThinningFactor = f; }

    double GetUsedWeight() const { return fUsedWeight; }

    void SetUsedWeight(const double w) { fUsedWeight = w; }

    const utl::TimeStamp& GetPlaneFrontTime() const { return fPlaneFrontTime; }

    void SetPlaneFrontTime(const utl::TimeStamp& time) { fPlaneFrontTime = time; }


    void SetSimulatorSignature(const std::string& name) { fSimulatorSignature = name; }

    const std::string& GetSimulatorSignature() const;


    bool IsInsideMinRadius() const { return fHoleStation; }


    void SetIsInsideMinRadius(const bool isIn = true) { fHoleStation = isIn; }

    typedef decltype(std::begin(boost::adaptors::keys(TriggerGPSMap()))) TriggerTimeIterator;
    typedef TriggerTimeIterator ConstTriggerTimeIterator;  // for backwards compatibility

    TriggerTimeIterator TriggerTimesBegin() const { return std::begin(boost::adaptors::keys(fTriggerAndGPSData)); }
    TriggerTimeIterator TriggerTimesEnd() const { return std::end(boost::adaptors::keys(fTriggerAndGPSData)); }
    OFFLINE_MAKE_CONST_ITERATOR_RANGE(TriggerTimeIterator, TriggerTimes)

    
    bool HasTriggerData(const utl::TimeStamp& time) const { return HasGPSData(time); }

    bool HasGPSData(const utl::TimeStamp& time) const;

    sevt::StationGPSData& GetGPSData(const utl::TimeStamp& time);
    const sevt::StationGPSData& GetGPSData(const utl::TimeStamp& time) const;

    void MakeTriggerAndGPSData(const utl::TimeStamp& time);

    sevt::StationTriggerData& GetTriggerData(const utl::TimeStamp& time);
    const sevt::StationTriggerData& GetTriggerData(const utl::TimeStamp& time) const;

    utl::TimeInterval GetAbsoluteTimeOffset() const { return fAbsoluteTimeOffset; }
    void SetAbsoluteTimeOffset(const utl::TimeInterval& dt) { fAbsoluteTimeOffset = dt; }

  private:
    StationSimData() = default;
    ~StationSimData() = default;

    void AlwaysInsertParticle(const utl::Particle& particle) { fParticles.push_back(particle); }

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

    void Shrink();

    utl::TimeStamp fPlaneFrontTime;
    bool fHoleStation = false;
    std::string fSimulatorSignature;
    ParticleVector fParticles;

    TriggerGPSMap fTriggerAndGPSData;

    unsigned int fNumberOfMuons = 0;
    unsigned int fNumberOfElectrons = 0;
    unsigned int fNumberOfPhotons = 0;
    unsigned int fTotalParticleCount = 0;
    unsigned int fTotalSimParticleCount = 0;
    unsigned int fTotalSimCandidateParticleCount = 0;

    unsigned int fMaxNParticles = std::numeric_limits<unsigned int>::max();
    double fThinning = 1; // particle list was thinned with this factor
    double fThinningFactor = 1; // each time limit is reached, thinning is bumped by this factor
    double fUsedWeight = 1; // the exact signal scaling can differ slightly from the thinning

    utl::TimeInterval fAbsoluteTimeOffset;

    friend class Station;
    friend class io::StationSimData_ROOT;
    friend class utl::ShadowPtr<StationSimData>;

  };

}


#endif