SDetector/Scintillator.h

Go to the documentation of this file.

#ifndef _sdet_Scintillator_h_
#define _sdet_Scintillator_h_

#include <vector>
#include <string>

#include <det/VManager.h>
#include <det/Detector.h>
#include <sdet/PMT.h>

#include <utl/AugerUnits.h>
#include <utl/AugerException.h>
#include <utl/CoordinateSystemPtr.h>
#include <utl/Validated.h>
#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/TabulatedFunction.h>
#include <utl/ShadowPtr.h>
#include <utl/config.h>


namespace sdet {

  class Scintillator {

  public:
    double GetBarLength() const;

    double GetBarWidth() const;

    double GetBarThickness() const;

    unsigned int GetNBars() const;

    // The "Gap" is the distance between the two wings of scintillator bars.

    double GetGap() const;

    /*
     * Fiber properties refer to single fibers, which are routed through two scintillator
     * bars. In the transition from one bar to the next, they are bent in a U-turn.
     */
    double GetFiberLength() const;

    double GetFiberUTurnDiameter() const;

    // "Housing" refers to the polystyrene bed into which the scintillator bars are inserted.

    double GetHousingLength() const;

    double GetHousingWidth() const;

    double GetHousingThickness() const;

    // "Casing" refers to the alumninum frame in which the housing and bars reside.

    double GetCasingThickness() const;

    double GetSandwichPanelThickness() const;

    double GetRoofOffset() const;

    double GetRoofThickness() const;

    /*
     * Position in Station coordinate system is returned, where the origin
     * is located at the intersection between the tank's central axis and
     * the ground. The position of the scintillator origin (the point returned)
     * is schematically shown and described in SModels.xml.
     */
    utl::Point GetPosition() const;

    double GetFiberExpDecayConstant() const;

    double GetBarExpDecayConstant() const;

    double GetAttenuationLength() const;

    double GetBarLeakageExpCoefficient() const;

    double GetBarLeakageMaxRatio() const;

    double GetEffectiveRefractiveIndex() const;

    double GetReferencePENumber() const;

    double GetSigmaBarToBar() const;

    double GetReferenceEnergy() const;

    /*
     * Returns the distances photons must travel along a fiber in both directions in
     * order to reach the PMT.
     */
    std::vector<double> GetDistancesToPMT(const utl::Point& p) const;

    /*
     * Returns the distances between the point of partical traversal and the ends
     * of the traversed bar. The first element in the vector is the distance to the
     * end closest to the PMT.
     */
    std::pair<double, double> GetDistancesToBarEnds(const utl::Point& p) const;

    /*
     * The "halo" argument of both the IsHit and IsInsideBar functions will extend the acceptance
     * region of the function by the entered distance. In the case of IsHit, each side of the
     * rectangular intersection planes is extended by "halo." In the case of IsInsideBar, each
     * scintillator wing's rectangular prism dimensions (length, width, height) is extended by
     * "halo." Keep in mind in both cases that only the actual scintillator bars are considered.
     * The housing and casing of the scintillator module are not.
     */
    bool IsHit(const utl::Point& from, const utl::Vector& direction, const double halo = 0) const;

    bool IsInsideBar(const utl::Point& p, const double halo = 0) const;

    /*
     * The GetMaxRadius and GetMaxHeight functions are used to determine the
     * boundaries (in cylindrical coordinates) necessary to encompass the
     * scintillator. One example usage is the injection cylinder of the
     * CachedShowerRegenerator. It is more effective to calculate these maximum
     * variables here than to read all the variables necessary to calculate
     * the them in the relevant modules.
     */
    double GetMaxRadius() const;

    double GetMaxHeight() const;

  private:
    Scintillator(const int stationId, const unsigned int isUUB);

    void Update() const;

    /*
     * Helper method to do the redundant work of preparing requests for
     * scintillator data, sending them to the manager and reporting any errors.
     * The errorMsg argument should contain a meaningful error message that
     * will help users understand the situation if the requested component is
     * not found.  It should have a description in English of what was not
     * located.
     */
    template<typename T>
    det::VManager::Status
    GetScintillatorData(T& requestedData,
                        const std::string& property,
                        const std::string& component,
                        const std::string& errorMsg,
                        const bool throwOnFailure = true)
      const
    {
      const det::VManager& manager =
        det::Detector::GetInstance().GetSManagerRegister();
      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 fStationId = 0;
    mutable det::VManager::IndexMap indexMap;
    mutable utl::Validated<double> fBarLength;
    mutable utl::Validated<double> fBarWidth;
    mutable utl::Validated<double> fBarThickness;
    mutable utl::Validated<unsigned int> fNBars;
    mutable utl::Validated<double> fGap;
    mutable utl::Validated<double> fFiberLength;
    mutable utl::Validated<double> fFiberUTurnDiameter;
    mutable utl::Validated<double> fHousingLength;
    mutable utl::Validated<double> fHousingWidth;
    mutable utl::Validated<double> fHousingThickness;
    mutable utl::Validated<double> fCasingThickness;
    mutable utl::Validated<double> fSandwichPanelThickness;
    mutable utl::Validated<double> fRoofOffset;
    mutable utl::Validated<double> fRoofThickness;
    mutable utl::Validated<utl::Point> fPosition;
    mutable utl::Validated<double> fFiberExpDecayConstant;
    mutable utl::Validated<double> fBarExpDecayConstant;
    mutable utl::Validated<double> fAttenuationLength;
    mutable utl::Validated<double> fBarLeakageExpCoefficient;
    mutable utl::Validated<double> fBarLeakageMaxRatio;
    mutable utl::Validated<double> fEffectiveRefractiveIndex;
    mutable utl::Validated<double> fSigmaBarToBar;
    mutable utl::Validated<double> fReferencePENumber;
    mutable utl::Validated<double> fReferenceEnergy;

    std::pair<double, double> fDistancesToPMT{0, 0};

    friend class Station;

  };

}


#endif