CEvent/Station.h

Go to the documentation of this file.

#ifndef _cevt_Station_h_
#define _cevt_Station_h_

#include <vector>
#include <boost/iterator/indirect_iterator.hpp>

#include <utl/ShadowPtr.h>
#include <utl/AugerException.h>
#include <utl/TimeStamp.h>
#include <utl/TimeDistribution.h>
#include <utl/MultiTimeDistribution.h>
#include <utl/TimeDistributionAlgorithm.h>

#include <cevt/StationConstants.h>
#include <cevt/StationSimData.h>
#include <cevt/StationRecData.h>
// #include <cevt/StationTriggerData.h>
// #include <cevt/StationCalibData.h>
// #include <cevt/StationGPSData.h>
#include <cevt/Pad.h>


static const char CvsId_cevt_Station[] =
  "$Id$";


namespace cevt {

  class CEvent;


  class Station {

  private:
    typedef std::vector<Pad*>::iterator InternalPadIterator;
    typedef std::vector<Pad*>::const_iterator InternalConstPadIterator;

  public:
    Station(const Station& station);
    Station& operator=(const Station& station);

    typedef boost::indirect_iterator<InternalPadIterator, Pad&> PadIterator;

    typedef boost::indirect_iterator<InternalConstPadIterator, const Pad&> ConstPadIterator;

    int GetId() const { return fId; }



    bool HasPad(const unsigned int padId) const;

    Pad& GetPad(const unsigned int padId);
    const Pad& GetPad(const unsigned int padId) const;


    void MakePad(const unsigned int padId);

    unsigned int GetNumberActivePads() 
    { return fPads.size(); }

    unsigned int GetNumberActivePads() const
    { return fPads.size(); }


    PadIterator PadsBegin()
    { return PadIterator(fPads.begin()); }

    PadIterator PadsEnd()
    { return PadIterator(fPads.end()); }
 
    ConstPadIterator PadsBegin() const
    { return ConstPadIterator(fPads.begin()); }

    ConstPadIterator PadsEnd() const
    { return ConstPadIterator(fPads.end()); }



    // this should go away with FatBastard
    typedef StationConstants::SignalComponent SignalComponent;

    static const SignalComponent eTotal = StationConstants::eTotal;
    static const SignalComponent eElectron = StationConstants::eElectron;
    static const SignalComponent ePhoton = StationConstants::ePhoton;
    static const SignalComponent eMuon = StationConstants::eMuon;

    static const SignalComponent eHadron = StationConstants::eHadron;
    static const SignalComponent eDecayElectron = StationConstants::eDecayElectron;
    static const SignalComponent eDeltaRay = StationConstants::eDeltaRay;
    static const SignalComponent eElectronFromShowerElectron = StationConstants::eElectronFromShowerElectron;
    static const SignalComponent eElectronFromShowerMuon = StationConstants::eElectronFromShowerMuon;
    static const SignalComponent eElectronFromShowerPhoton = StationConstants::eElectronFromShowerPhoton;
    static const SignalComponent eElectronFromOtherSource = StationConstants::eElectronFromOtherSource; 

    static const SignalComponent ePhotonFromShowerElectron = StationConstants::ePhotonFromShowerElectron; 
    static const SignalComponent ePhotonFromShowerMuon = StationConstants::ePhotonFromShowerMuon;
    static const SignalComponent ePhotonFromShowerPhoton = StationConstants::ePhotonFromShowerPhoton;  
    static const SignalComponent ePhotonFromOtherSource = StationConstants::ePhotonFromOtherSource;

    static const SignalComponent eBackgroundElectron = StationConstants::eBackgroundElectron;
    static const SignalComponent eBackgroundPhoton = StationConstants::eBackgroundPhoton;
    static const SignalComponent eBackgroundMuon = StationConstants::eBackgroundMuon;
    static const SignalComponent eBackgroundHadron = StationConstants::eBackgroundHadron;
    static const SignalComponent eOtherNeutrals = StationConstants::eOtherNeutrals;


    static const SignalComponent eShowerMuonDecayPhoton = StationConstants::eShowerMuonDecayPhoton;
    static const SignalComponent eShowerMuonDecayElectron = StationConstants::eShowerMuonDecayElectron;
    static const SignalComponent eMySource0 = StationConstants::eMySource0;
    static const SignalComponent eMySource1 = StationConstants::eMySource1;
    static const SignalComponent eMySource2 = StationConstants::eMySource2;
    static const SignalComponent eMySource3 = StationConstants::eMySource3;
    static const SignalComponent eMySource4 = StationConstants::eMySource4;
    static const SignalComponent eMySource5 = StationConstants::eMySource5;
    static const SignalComponent eMySource6 = StationConstants::eMySource6;
    static const SignalComponent eMySource7 = StationConstants::eMySource7;
    static const SignalComponent eMySource8 = StationConstants::eMySource8;
    static const SignalComponent eMySource9 = StationConstants::eMySource9;
    // just to track size
    static const SignalComponent eLastSource = eMySource9;
    
    static std::string GetSignalComponentName(const SignalComponent sc);
    static cevt::Station::SignalComponent GetSignalComponent(const utl::Particle&);



    utl::TimeStamp GetHitsStartTime() const { return fHitsStartTime; }

    void SetHitsStartTime(const utl::TimeStamp& Time) { fHitsStartTime = Time; }

    unsigned int GetTotalHits(const SignalComponent source = eTotal) const;

    utl::TimeDistributionI&  
    GetHits(const SignalComponent source = eTotal)
    { return fHits->GetTimeDistribution(source); }

    const utl::TimeDistributionI& 
    GetHits(const SignalComponent source = eTotal) const
    { return fHits->GetTimeDistribution(source); }

    void MakeHits(const SignalComponent source = eTotal);

    bool HasHits(const SignalComponent source = eTotal) const
    { return fHits->HasLabel(source); }

    const utl::MultiTimeDistributionI& GetMultiHits()
    { return *fHits; }

    void ClearHits()
    { fHits->Clear(); }

    typedef utl::MultiTimeDistributionI::Iterator HitsIterator;
    typedef utl::MultiTimeDistributionI::ConstIterator ConstHitsIterator;

    HitsIterator HitsBegin() { return fHits->Begin(); }
    HitsIterator HitsEnd()   { return fHits->End(); }
    ConstHitsIterator HitsBegin() const { return fHits->Begin(); }
    ConstHitsIterator HitsEnd() const { return fHits->End(); }




    StationSimData& GetSimData()
    { return *fSimData; }
    const StationSimData& GetSimData() const
    { return *fSimData; }
    void MakeSimData();
    bool HasSimData() const { return bool(fSimData); }

    StationRecData& GetRecData()
    { return *fRecData; }
    const StationRecData& GetRecData() const
    { return *fRecData; }
    void MakeRecData();
    bool HasRecData() const { return bool(fRecData); }


    // CBT not use for now...
//     /// Get Trigger data for the station
//     StationTriggerData& GetTriggerData()
//     { return *fTriggerData; }
//     const StationTriggerData& GetTriggerData() const
//     { return *fTriggerData; }
//     /// Make trigger data object
//     void MakeTriggerData();
//     /// Check whether trigger data object exists
//     bool HasTriggerData() const { return fTriggerData; }

//     /// Get calibration data for the station
//     StationCalibData& GetCalibData()
//     { return *fCalibData; }
//     const StationCalibData& GetCalibData() const
//     { return *fCalibData; }
//     /// Make calibration data object
//     void MakeCalibData();
//     /// Check whether calibration data object exists
//     bool HasCalibData() const { return fCalibData; }

//     /// Get GPS data for the station
//     StationGPSData& GetGPSData()
//     { return *fGPSData; }
//     const StationGPSData& GetGPSData() const
//     { return *fGPSData; }
//     /// Make GPS data object
//     void MakeGPSData();
//     /// Check whether GPS data object edists
//     bool HasGPSData() const { return fGPSData; }
//     //@}




    // should go away with FatBastard
    typedef StationConstants::ReconstructionStatus ReconstructionStatus;
    static const ReconstructionStatus eCandidate = StationConstants::eCandidate;
    static const ReconstructionStatus eRejected = StationConstants::eRejected;
    static const ReconstructionStatus eSilent = StationConstants::eSilent;

    typedef StationConstants::RejectionStatus RejectionStatus;
    static const RejectionStatus eNoRejection = StationConstants::eNoRejection;
    static const RejectionStatus eOutOfTime = StationConstants::eOutOfTime;
    static const RejectionStatus eOffGrid = StationConstants::eOffGrid;
    static const RejectionStatus eDenseArray = StationConstants::eDenseArray;
    static const RejectionStatus eEngineeringArray = StationConstants::eEngineeringArray;
    static const RejectionStatus eMCInnerRadiusCut = StationConstants::eMCInnerRadiusCut;
    static const RejectionStatus eNoRecData = StationConstants::eNoRecData;
    static const RejectionStatus eLonely = StationConstants::eLonely;
    static const RejectionStatus eNoTrigger = StationConstants::eNoTrigger;
    static const RejectionStatus eErrorCode = StationConstants::eErrorCode;
    static const RejectionStatus eNoCalibData = StationConstants::eNoCalibData;
    static const RejectionStatus eNoGPSData = StationConstants::eNoGPSData;
    static const RejectionStatus eBadCalib = StationConstants::eBadCalib;
    static const RejectionStatus eNotDenseArray = StationConstants::eNotDenseArray;
    static const RejectionStatus eNumRejectionStatusBits = StationConstants::eNumRejectionStatusBits;



    bool IsCandidate() const { return fReconstructionStatus == eCandidate; }
    bool IsRejected() const { return fReconstructionStatus == eRejected; }
    bool IsSilent() const { return fReconstructionStatus == eSilent; }

    void SetCandidate() { fReconstructionStatus = eCandidate; }
    void SetRejected(const int reason)
    { fReconstructionStatus = eRejected; fRejectionStatus |= reason; }
    void SetSilent() { fReconstructionStatus = eSilent; }

    int GetRejectionStatus() const { return fRejectionStatus; }
    void ClearRejectionStatus() { fRejectionStatus = eNoRejection; }

  private:
    Station(const int stationId);
    ~Station();

    static const std::string fgSourceNameLookup[eLastSource + 1];

    int fId;
    std::vector<Pad*> fPads;
    utl::ShadowPtr<StationSimData> fSimData;
    utl::ShadowPtr<StationRecData> fRecData;
//     utl::ShadowPtr<StationCalibData> fCalibData;
//     utl::ShadowPtr<StationTriggerData> fTriggerData;
//     utl::ShadowPtr<StationGPSData> fGPSData;
    utl::TimeStamp fHitsStartTime;
    utl::InitializedShadowPtr<utl::MultiTimeDistributionI> fHits;
    ReconstructionStatus fReconstructionStatus;
    int fRejectionStatus;

    friend class cevt::CEvent;

  };


  class CandidateStationFilter {
  public:
    bool operator()(const Station& station)
    { return station.IsCandidate(); }
  };


  class SilentStationFilter {
  public:
    bool operator()(const Station& station)
    { return station.IsSilent(); }
  };


  class RejectedStationFilter {
  public:
    RejectedStationFilter(const int statusMask)
      : fStatusMask(statusMask) { }
    
    bool operator()(const Station& station)
    { return station.GetRejectionStatus() & fStatusMask; }

  private:
    int fStatusMask;
  };
}


#include <cevt/Pad.h>
#include <cevt/StationSimData.h>
#include <cevt/StationRecData.h>
// #include <cevt/StationTriggerData.h>
// #include <cevt/StationCalibData.h>
// #include <cevt/StationGPSData.h>


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. CEvent/Station.o -k"
// End: