SDetector.h

Go to the documentation of this file.

#ifndef _sdet_SDetector_h_
#define _sdet_SDetector_h_

#include <sdet/Station.h>
#include <sdet/SDetectorConstants.h>
#include <utl/Validated.h>
#include <utl/IteratorRange.h>
#include <boost/iterator/transform_iterator.hpp>
#include <iterator>
#include <cstddef>
#include <string>
#include <vector>
#include <map>
#include <set>


namespace det {
  class Detector;
}

namespace utl {
  class NonExistentComponentException;
}

namespace sevt {
  class Station;
  class PMT;
}

namespace sdet {

  class SDetector {

  private:
    typedef std::map<int, const sdet::Station*> InternalStationMap;
    typedef InternalStationMap::const_iterator InternalStationIterator;

  public:
    class StationIterator :
      public std::iterator<std::input_iterator_tag, const sdet::Station&, ptrdiff_t, const sdet::Station*, const sdet::Station& > {

    public:
      // use this to loop over all stations
      StationIterator(const InternalStationIterator& it)
        : fInternalIterator(it), fEnd(it) { }

      // use this to loop only over stations that match the GridIndex
      StationIterator(const InternalStationIterator& begin,
                      const InternalStationIterator& end,
                      const SDetectorConstants::GridIndex index)
        : fInternalIterator(begin), fEnd(end), fIndex(index), fFilter(true) { }

      StationIterator&
      operator++()
      {
        ++fInternalIterator;
        if (fFilter)
          // step further to next hit or end
          for ( ; fInternalIterator != fEnd; ++fInternalIterator)
            if (fInternalIterator->second->IsInGrid(fIndex) || fInternalIterator->second->IsDense())
              break;
        return *this;
      }

      bool operator==(const StationIterator& other) const
      { return fInternalIterator == other.fInternalIterator; }

      bool operator!=(const StationIterator& other) const
      { return !operator==(other); }

      const Station& operator*() const
      { return *fInternalIterator->second; }

      const Station* operator->() const
      { return fInternalIterator->second; }

    private:
      InternalStationIterator fInternalIterator;
      InternalStationIterator fEnd;
      SDetectorConstants::GridIndex fIndex = SDetectorConstants::eAny;
      bool fFilter = false;
    };


    StationIterator StationsBegin() const
    { return StationIterator(fCommissionedStationList.begin()); }

    StationIterator StationsEnd() const
    { return StationIterator(fCommissionedStationList.end()); }
    OFFLINE_MAKE_CONST_ITERATOR_RANGE(StationIterator, Stations)

    

    StationIterator GridStationsBegin(const SDetectorConstants::GridIndex index) const
    { return StationIterator(fCommissionedStationList.begin(), fCommissionedStationList.end(), index); }

    StationIterator GridStationsEnd(const SDetectorConstants::GridIndex index) const
    { return StationIterator(fCommissionedStationList.end(), fCommissionedStationList.end(), index); }
    OFFLINE_MAKE_CONST_ITERATOR_RANGE_ARG(StationIterator, GridStations, const SDetectorConstants::GridIndex arg)

    

    StationIterator AllStationsBegin() const
    { return StationIterator(fFullStationMap.begin()); }

    StationIterator AllStationsEnd() const
    { return StationIterator(fFullStationMap.end()); }
    OFFLINE_MAKE_CONST_ITERATOR_RANGE(StationIterator, AllStations)

    
    bool IsStationCommissioned(const int stationId) const
    { return fCommissionedStationList.find(stationId) != fCommissionedStationList.end(); }

    bool IsStationDense(const int stationId) const
    { return std::find(fDenseStationSubList.begin(), fDenseStationSubList.end(),
                       stationId) != fDenseStationSubList.end(); }

    const Station& GetStation(const int stationId) const;

    const Station& GetStation(const sevt::Station& station) const;

    const Station& GetAllStation(const int stationId) const;

    const std::vector<int>& GetFullStationList() const;

    const std::vector<int>& GetDenseStationList() const
    { return fDenseStationSubList; }

    typedef std::map<int, std::set<int> > StationGroups;
    typedef StationGroups::const_iterator StationGroupsIterator;

    const StationGroups& GetStationGroups() const { return fStationGroups; }

    const PMT& GetPMT(const sevt::PMT& pmt) const;

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

    SDetector(const SDetector& sdetector);
    SDetector& operator=(const SDetector& sdetector);

    void Update();
    void UpdateDense();

    void FetchStationGroups() const;

    // Container for all stations commissioned at the
    // current detector time.
    mutable InternalStationMap fCommissionedStationList;

    // List of all stations available in the external sources
    // (external sources are, for example, the XML file with
    // station list or perhaps some MySQL database)
    mutable utl::Validated<std::vector<int>> fFullStationList;
    mutable InternalStationMap fFullStationMap;
    mutable StationGroups fStationGroups;

    // list of all dense stations.  Used to set the IsDense flag
    mutable std::vector<int> fDenseStationSubList;

    friend class det::Detector;

  };

}


#endif