PixelSimData.h

Go to the documentation of this file.

#ifndef _fevt_PixelSimData_h_
#define _fevt_PixelSimData_h_

#include <vector>

#include <boost/iterator/indirect_iterator.hpp>

#include <fevt/FdConstants.h>

#include <fdet/Channel.h>

#include <utl/Trace.h>
#include <utl/MultiTrace.h>
#include <utl/ShadowPtr.h>


namespace fevt {

  class PixelSimData {

  public:


    utl::TraceD& GetPhotonTrace(const FdConstants::LightSource source = FdConstants::eTotal)
    { return fPhotonTrace->GetTrace(source); }
    const utl::TraceD& GetPhotonTrace(const FdConstants::LightSource source = FdConstants::eTotal) const
    { return fPhotonTrace->GetTrace(source); }

    void MakePhotonTrace(unsigned int size, double binning, 
                         const FdConstants::LightSource source = FdConstants::eTotal);
    void MakePhotonTrace(const utl::TraceD& t, const FdConstants::LightSource source = FdConstants::eTotal);
    void ClearPhotonTraces() { fPhotonTrace->Clear(); }

    bool HasPhotonTrace(const FdConstants::LightSource source) const
    { return fPhotonTrace->HasLabel(source); }

    typedef utl::MultiTraceD::Iterator PhotonTraceIterator;
    typedef utl::MultiTraceD::ConstIterator ConstPhotonTraceIterator;

    PhotonTraceIterator PhotonTracesBegin()
    { return fPhotonTrace->Begin(); }
    ConstPhotonTraceIterator PhotonTracesBegin() const
    { return fPhotonTrace->Begin(); }

    PhotonTraceIterator PhotonTracesEnd()
    { return fPhotonTrace->End(); }
    ConstPhotonTraceIterator PhotonTracesEnd() const
    { return fPhotonTrace->End(); }




    utl::TraceD& GetPhotonWeightSquareTrace(const FdConstants::LightSource source = FdConstants::eTotal)
    { return fPhotonWeightSquareTrace->GetTrace(source); }
    const utl::TraceD& GetPhotonWeightSquareTrace(const FdConstants::LightSource source = FdConstants::eTotal) const
    { return fPhotonWeightSquareTrace->GetTrace(source); }

    void MakePhotonWeightSquareTrace(unsigned int size, double binning, 
                                     const FdConstants::LightSource source = FdConstants::eTotal);
    void MakePhotonWeightSquareTrace(const utl::TraceD& t,
                                     const FdConstants::LightSource source = FdConstants::eTotal);

    bool HasPhotonWeightSquareTrace(const FdConstants::LightSource source) const
    { return fPhotonWeightSquareTrace->HasLabel(source); }
    void ClearPhotonWeightSquareTraces() { fPhotonWeightSquareTrace->Clear(); }

    typedef utl::MultiTraceD::Iterator PhotonWeightSquareTraceIterator;
    typedef utl::MultiTraceD::ConstIterator ConstPhotonWeightSquareTraceIterator;

    PhotonWeightSquareTraceIterator PhotonWeightSquareTracesBegin()
    { return fPhotonWeightSquareTrace->Begin(); }
    ConstPhotonWeightSquareTraceIterator PhotonWeightSquareTracesBegin() const
    { return fPhotonWeightSquareTrace->Begin(); }

    PhotonWeightSquareTraceIterator PhotonWeightSquareTracesEnd()
    { return fPhotonWeightSquareTrace->End(); }
    ConstPhotonWeightSquareTraceIterator PhotonWeightSquareTracesEnd() const
    { return fPhotonWeightSquareTrace->End(); }

    
    void SetNumSamples(const int nSamp) { fNumSamples = nSamp; }
    int GetNumSamples() const { return fNumSamples; }

    void SetMean(const double mean) { fMean = mean; }
    double GetMean() const { return fMean; }

    void SetRMS(const double rms) { fRMS = rms; }
    double GetRMS() const { return fRMS; }

    void SetThreshold(const int thr) { fThreshold = thr; }
    int GetThreshold() const { return fThreshold; }

    void SetMeanBgPhotonFlux(const double mean) { fMeanBgPhotonFlux = mean; }
    double GetMeanBgPhotonFlux() const { return fMeanBgPhotonFlux; }

    int GetMaxBoxcarsum() const {return fBoxcarsumMax;}
    double GetMeanBoxcarsum() const {return fBoxcarsumMean;}
    double GetRmsBoxcarsum() const {return fBoxcarsumRms;}
    int GetFltTime() const {return fFltTime;}
    int GetFltDuration() const {return fFltDuration;}

    void SetMaxBoxcarsum(int v) {fBoxcarsumMax=v;}
    void SetMeanBoxcarsum(double v)  {fBoxcarsumMean=v;}
    void SetRmsBoxcarsum(double v) {fBoxcarsumRms=v;}
    void SetFltTime(int v)  {fFltTime=v;}
    void SetFltDuration(int v)  {fFltDuration=v;}

  private: 
    PixelSimData();
    ~PixelSimData();

    int fNumSamples;
    double fMean;
    double fRMS;
    int fThreshold;
    double fMeanBgPhotonFlux;
    utl::InitializedShadowPtr<utl::MultiTraceD> fPhotonTrace;
    utl::InitializedShadowPtr<utl::MultiTraceD> fPhotonWeightSquareTrace; // only used if the light components @ pixel are stored

    int fBoxcarsumMax;
    double fBoxcarsumMean;
    double fBoxcarsumRms;
    int fFltTime;
    int fFltDuration;
    
    friend class Pixel;
    friend class utl::ShadowPtr<PixelSimData>;

  };

} //namespace


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: