MPositionable.h

Go to the documentation of this file.

#ifndef _det_MPositionable_h
#define _det_MPositionable_h

#include <utl/ShadowPtr.h>
#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/CoordinateSystemPtr.h>
#include <utl/TransformationMatrix.h>
#include <fwk/LocalCoordinateSystem.h>

#include <string>


namespace det {

  template<class Config>
  class MPositionable {
  public:
    MPositionable(const Config& cp) : fConfig(cp) { }

    virtual ~MPositionable() { }

    utl::CoordinateSystemPtr GetLocalCoordinateSystem() const;

    utl::Point GetPosition() const;

  protected:
    static const std::string kCoordinateTypeTag;
    static const std::string kComponent1Tag;
    static const std::string kComponent2Tag;
    static const std::string kComponent3Tag;
    static const std::string kEulerPhiTag;
    static const std::string kEulerThetaTag;
    static const std::string kEulerPsiTag;
    typedef std::string CoordinateType;
    /*
     * Discarded by now: CoordinateSystem is also prepared for this.
     * Seems clearer the use of a string tag instead of an integral value.
     *
     * typedef int CoordinateType;
     */
    /*
     * In the following there are several virtual methods that are thought to
     * allow deriving classes to fill some holes (ie in a Template pattern fashion)
     * regarding the coordinates of this object coordinate system.
     *
     * One of them is even a pure virtual method without an implementation provided
     * here, the others have an implementation by this class.
     *
     * Currently most of them are protected methods, tough it may be enough to have them
     * just private (ie the deriving classes just need to overrided / define any of
     * these methods, but no do an actual call to one of them). Making these methods
     * privated would follow the guideline given by Herb Sutter in
     *
     * "Virtuality"
     * C/C++ Users Journal, 19(9), September 2001.
     * (http://www.gotw.ca/publications/mill18.htm) where it's said:
     * Guideline #2: Prefer to make virtual functions private.
     * Guideline #3: Only if derived classes need to invoke the base implementation of a virtual function, make the virtual function protected.
     *
     * On the other hand, all these functions are getters that doesn't perform any operation but to retrieve a value (maybe accesing configuration),
     * so there's no workflow to be ensured by this class (ie there's on risk to call them in some not foreseen situation): so at last
     * it seems reasonable to leave them protected so as to allow deriving classes a (probably necessary) call to one of them.
     *
     * But, at last, for the pure virtual function case there's no point to have it protected: it has to be defined by deriving classes, and so when
     * defined "down the hierarchy" the accesss control modifier here specified is overrided; conversely, if not defined, it couldn't be called: it has
     * no definition provided (remember that a __pure__ virtual function may have, anyway, a definition provided: the, say, "purity" just enforces
     * deriving classes to provide an implementation by themselves)!
     */
    virtual double GetComponent1() const;

    virtual double GetComponent2() const;

    virtual double GetComponent3() const;

    virtual double GetEulerPhi() const;

    virtual double GetEulerTheta() const;

    virtual double GetEulerPsi() const;

    virtual CoordinateType GetCoordinateType() const;

  private:
    virtual utl::CoordinateSystemPtr GetReferenceCoordinateSystem() const = 0;

    mutable utl::ShadowPtr<double> fComponent1;
    mutable utl::ShadowPtr<double> fComponent2;
    mutable utl::ShadowPtr<double> fComponent3;
    mutable utl::ShadowPtr<double> fEulerPhi;
    mutable utl::ShadowPtr<double> fEulerTheta;
    mutable utl::ShadowPtr<double> fEulerPsi;
    mutable utl::ShadowPtr<CoordinateType> fCoordinateType;
    mutable utl::CoordinateSystemPtr fLocalCoordinateSystem;
    const Config& fConfig;
  };


  template<class Config>
  const std::string MPositionable<Config>::kComponent1Tag = "positionComponent1";

  template<class Config>
  const std::string MPositionable<Config>::kComponent2Tag = "positionComponent2";

  template<class Config>
  const std::string MPositionable<Config>::kComponent3Tag = "positionComponent3";

  template<class Config>
  const std::string MPositionable<Config>::kEulerPhiTag = "eulerPhi";

  template<class Config>
  const std::string MPositionable<Config>::kEulerThetaTag = "eulerTheta";

  template<class Config>
  const std::string MPositionable<Config>::kEulerPsiTag = "eulerPsi";

  template<class Config>
  const std::string MPositionable<Config>::kCoordinateTypeTag = "coordinateType";

  template<class Config>
  double
  MPositionable<Config>::GetComponent1()
    const
  {
    /* Hack to fix compilation using g++ 4.1.2 on SL 5.5 (present in most GRID nodes) RFG 2013
       See: http://www.gotw.ca/publications/mill17.htm */
    return fConfig.template GetData<double, utl::ThrowOnZeroDereference, utl::ShadowPtr>(fComponent1, kComponent1Tag);
  }

  template<class Config>
  double MPositionable<Config>::GetComponent2() const
  { return fConfig.template GetData<double, utl::ThrowOnZeroDereference, utl::ShadowPtr>(fComponent2, kComponent2Tag); }

  template<class Config>
  double MPositionable<Config>::GetComponent3() const
  { return fConfig.template GetData<double, utl::ThrowOnZeroDereference, utl::ShadowPtr>(fComponent3, kComponent3Tag); }

  template<class Config>
  double MPositionable<Config>::GetEulerPhi() const
  { return fConfig.template GetData<double, utl::ThrowOnZeroDereference, utl::ShadowPtr>(fEulerPhi, kEulerPhiTag); }

  template<class Config>
  double MPositionable<Config>::GetEulerTheta() const
  { return fConfig.template GetData<double, utl::ThrowOnZeroDereference, utl::ShadowPtr>(fEulerTheta, kEulerThetaTag); }

  template<class Config>
  double MPositionable<Config>::GetEulerPsi() const
  { return fConfig.template GetData<double, utl::ThrowOnZeroDereference, utl::ShadowPtr>(fEulerPsi, kEulerPsiTag); }

  template<class Config>
  typename MPositionable<Config>::CoordinateType MPositionable<Config>::GetCoordinateType() const
  { return fConfig.template GetData<CoordinateType, utl::ThrowOnZeroDereference, utl::ShadowPtr>(fCoordinateType, kCoordinateTypeTag); }

  template<class Config>
  utl::Point MPositionable<Config>::GetPosition() const
  { return utl::Point(0, 0, 0, GetLocalCoordinateSystem()); }

  template<class Config>
  utl::CoordinateSystemPtr
  MPositionable<Config>::GetLocalCoordinateSystem()
    const
  {
    if (!fLocalCoordinateSystem) {
      // Alias for convenience.
      typedef utl::Vector::CoordinateType Type;
      // Retrieve the reference one and the apply the pertaining transformations.
      auto cs = GetReferenceCoordinateSystem();
      // Displacement components.
      const double c1 = GetComponent1();
      const double c2 = GetComponent2();
      const double c3 = GetComponent3();
      // Now the rotation part.
      const double phi = GetEulerPhi();
      const double theta = GetEulerTheta();
      const double psi = GetEulerPsi();
      // Check if there is something to be done (if not cs stays the same)...
      if (c1 || c2 || c3 || phi || theta || psi) {
        // Create the given coordinate type (the innermost creation may throw).
        const Type& ct = Type::Create(Type::KindCreator::Create(GetCoordinateType()));
        // Construct the displacement vector.
        const utl::Vector trans(c1, c2, c3, cs, ct);
        // Move the system.
        cs = utl::CoordinateSystem::Translation(trans, cs);
        /*
         * Apply the rotations in the established conventional order and
         * to the correspoding axes (some of them being the result of
         * previously applied rotations). See this class' main comment.
         *
         * The rotations are finally forwarded to CLHEP rotation classes,
         * which state that they are counterclockwise (see Transform3D.h
         * in there).
         */
        if (phi)
          cs = utl::CoordinateSystem::RotationZ(phi, cs);
        if (theta)
          cs = utl::CoordinateSystem::RotationX(theta, cs);
        if (psi)
          cs = utl::CoordinateSystem::RotationZ(psi, cs);
      }
      fLocalCoordinateSystem = cs;
    }
    return fLocalCoordinateSystem;
  }

}


#endif