CDetector/Station.h

Go to the documentation of this file.

#ifndef _cdet_Station_h_
#define _cdet_Station_h_

#include <vector>
#include <list>
#include <map>
#include <string>
#include <bitset>

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

#include <det/VManager.h>
#include <det/Detector.h>
#include <sdet/SDetector.h>
#include <cdet/CDetectorConstants.h>
#include <utl/AugerUnits.h>
#include <utl/AugerException.h>
#include <utl/CoordinateSystemPtr.h>
#include <utl/ReferenceEllipsoid.h>
#include <utl/Validated.h>
#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/TimeStamp.h>
#include <utl/TimeRange.h>
#include <utl/TabulatedFunction.h>
#include <utl/ShadowPtr.h>

namespace cevt {
  class Pad;
}

namespace cdet {
  

  class Station {      

  private:
    // These constants are to be read from external file ....
    // all code that uses them must be changed accordingly
    //
    static const double kTimeBinSize;

  public:
    static double GetTimeBinning() { return kTimeBinSize; }
    
    const std::string& GetName() const;
    
    int GetId() const { return fId; }

    const utl::TimeStamp& GetCommissionTime() const
    { return GetCommissionTimeRange().GetStartTime(); }

    const utl::TimeStamp& GetDecommissionTime() const
    { return GetCommissionTimeRange().GetStopTime(); }

    const utl::TimeRange& GetCommissionTimeRange() const;

    //const utl::Point& GetPosition() const;
    // temporary solution for detector creeping (bug #307)
    utl::Point GetPosition() const;

    // Get RPC ID from pad id
    unsigned int GetRPCId(const unsigned int & padId) const {return int(padId/10000);}; 


    // Get functions to access MARTA detector data


    int GetNumberRPCChambers() const;

    const utl::Point & GetRPCPosition(const unsigned int id) const;

    double GetRPCRotation(const unsigned int id) const;

    utl::CoordinateSystemPtr GetRPCCoordinateSystem(unsigned int id) const;

    utl::Point GetPadPosition(const cevt::Pad & pad) const;
    utl::Point GetPadPosition(const unsigned int & padId) const;

    // ID of pad given position in RPC
    unsigned int GetPadId(const utl::Point & position) const;

    std::vector<unsigned int> GetListPadIds() const;

    // Dimensions of precast tank support. 
    // See GAP-2013-052 for the technical drawing of the proposed precast structure
    std::vector<double> GetTankSupportTopSlabDimensions() const;
    std::vector<double> GetTankSupportCentralFootDimensions() const;
    std::vector<double> GetTankSupportCentralFootBaseDimensions() const;
    std::vector<double> GetTankSupportOuterFootDimensions() const;
    std::vector<double> GetTankSupportOuterFootBaseDimensions() const;
    double GetTankSupportOuterFootDistanceToCenter() const;


    std::vector<double> GetRPCHousingInnerDimensions() const;
    std::vector<double> GetRPCHousingThickness() const; 
    double GetSpacerThickness() const;



    double GetRPCSizeX() const;    
    double GetRPCSizeY() const;    

    int GetNumberPadsX() const;
    int GetNumberPadsY() const;

    double GetPadSizeX() const;
    double GetPadSizeY() const;
    double GetPadArea() const;
    double GetDeadTime() const;

    bool IsInGrid(const cdet::CDetectorConstants::GridIndex index = cdet::CDetectorConstants::eStandard) const;


    bool IsDense() const { return fDense; }
    
    bool IsInEngineeringArray() const { return false; }

    // ------------------
    // Dynamic quantities
    // ------------------

    // ---------------------
    // Station subcomponents
    // --------------------- 

  private:

    Station(const int id);      
    ~Station();
    
    Station(const Station&);
    Station operator=(const Station&);

    void Update() const;

    template<typename T>
    det::VManager::Status
    GetStationData(T& requestedData, 
                   const std::string& property, 
                   const std::string& component, 
                   const std::string& errorMsg, const bool throwOnFailure = true)
      const
    {
      det::VManager::IndexMap indexMap;
      indexMap["stationId"] = fStationIdString;

      const det::VManager& manager =
        det::Detector::GetInstance().GetCManagerRegister();
      const det::VManager::Status status =
        manager.GetData(requestedData, property, component, indexMap);

      if (throwOnFailure && status == det::VManager::eNotFound)
        NotFoundAndThrow(errorMsg);

      return status;
    }


    template<typename T>
    det::VManager::Status
    GetRPCData(const std::string& id,
               T& requestedData,
               const std::string& property,
               const std::string& component,
               const std::string& errorMsg, const bool throwOnFailure = true)
      const
    {
        det::VManager::IndexMap indexMap;
        indexMap["stationId"] = fStationIdString;
        indexMap["RPCId"] = id; 

        const det::VManager& manager =
          det::Detector::GetInstance().GetCManagerRegister();
        const det::VManager::Status status =
          manager.GetData(requestedData, property, component, indexMap);

        if (throwOnFailure && status == det::VManager::eNotFound)
          NotFoundAndThrow(errorMsg);

      return status;
    }


    void NotFoundAndThrow(const std::string& msg) const;

    //

    int fId;
    // station id held as a string as that is what is passed through the
    // detector manager interface
    std::string fStationIdString; 
    

    // Quantities filled by lazy evaluation
    // ------------------------------------
    mutable utl::Validated<std::string> fName;
    typedef std::bitset<CDetectorConstants::kGridIndexSize> InGridType;
    mutable utl::Validated< InGridType > fInGrid;

    mutable utl::Validated<int> fNumberRPCChambers;
    mutable std::map<unsigned int, utl::Point> fRPCPositions;
    mutable std::map<unsigned int, double> fRPCRotations;
    mutable std::map<unsigned int, utl::CoordinateSystemPtr> fRPCCoordinateSystems;

    mutable utl::Validated<std::vector<double> > fTankSupportTopSlabDimensions;
    mutable utl::Validated<std::vector<double> > fTankSupportCentralFootDimensions;
    mutable utl::Validated<std::vector<double> > fTankSupportCentralFootBaseDimensions;
    mutable utl::Validated<std::vector<double> > fTankSupportOuterFootDimensions;
    mutable utl::Validated<std::vector<double> > fTankSupportOuterFootBaseDimensions;
    mutable utl::Validated<double> fTankSupportOuterFootDistanceToCenter;

    mutable utl::Validated<std::vector<double> > fRPCHousingInnerDimensions;
    mutable utl::Validated<std::vector<double> > fRPCHousingThickness;

    mutable utl::Validated<double> fRPCSizeX;
    mutable utl::Validated<double> fRPCSizeY;

    mutable utl::Validated<std::vector<unsigned int> > fListPadIds;
    mutable utl::Validated<int> fNumberPadsX;
    mutable utl::Validated<int> fNumberPadsY;

    mutable utl::Validated<double> fPadSizeX;
    mutable utl::Validated<double> fPadSizeY;
    mutable utl::Validated<double> fPadArea;
    mutable utl::Validated<double> fDeadTime;

    mutable utl::CoordinateSystemPtr fReferenceSystem;
    mutable utl::Validated<utl::Point> fPosition;

    // used in UTM conversions
    mutable utl::ReferenceEllipsoid::EllipsoidID fEllipsoid;
    mutable utl::Validated<int> fIsInAcquisition;
    mutable utl::Validated<int> fGroupId;
    mutable utl::Validated<utl::TimeRange> fCommissionTimeRange;

    bool fDense;
    
    friend class CDetector;

  };
  
}

#endif

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