GloballyPositioned.h

Go to the documentation of this file.

#ifndef Geom_GloballyPositioned_H
#define Geom_GloballyPositioned_H

#include "DataFormats/GeometryVector/interface/Point3DBase.h"
#include "DataFormats/GeometryVector/interface/Vector3DBase.h"
#include "DataFormats/GeometryVector/interface/LocalTag.h"
#include "DataFormats/GeometryVector/interface/GlobalTag.h"
#include "DataFormats/GeometrySurface/interface/TkRotation.h"

template <class T>
class GloballyPositioned {
public:

  typedef T                             Scalar;
  typedef Point3DBase<T,GlobalTag>      PositionType;
  typedef TkRotation<T>                 RotationType;
  typedef Point3DBase<T,GlobalTag>      GlobalPoint;
  typedef Point3DBase<T,LocalTag>       LocalPoint;
  typedef Vector3DBase<T,GlobalTag>     GlobalVector;
  typedef Vector3DBase<T,LocalTag>      LocalVector;

  static T iniPhi() {
    return 999.9978;
  }
  static T iniEta() {
    return 999.9978;
  }

  GloballyPositioned(){}
  GloballyPositioned( const PositionType& pos, const RotationType& rot) :
    thePos(pos), theRot(rot) {resetCache();}

  virtual ~GloballyPositioned() {}

  const PositionType& position() const { return thePos;}

  const RotationType& rotation() const { return theRot;}

  T phi() const {
    if (thePhi==iniPhi()) thePhi = thePos.barePhi();
    return thePhi;
  }
  T eta() const { 
    if (theEta==iniEta()) theEta = thePos.eta();
    return theEta;
  }


  // multiply inverse is faster
  class ToLocal {
  public:
    ToLocal(GloballyPositioned const & frame) :
      thePos(frame.position()), theRot(frame.rotation().transposed()){}
    
    LocalPoint toLocal( const GlobalPoint& gp) const {
      return LocalPoint( theRot.multiplyInverse( gp.basicVector() -
             thePos.basicVector()) 
                       );
    }
    
    LocalVector toLocal( const GlobalVector& gv) const {
      return LocalVector(theRot.multiplyInverse(gv.basicVector()));
    } 
    
  private:
    PositionType  thePos;
    RotationType  theRot;
    
  };

  

  GlobalPoint toGlobal( const LocalPoint& lp) const {
    return GlobalPoint( rotation().multiplyInverse( lp.basicVector()) +
            position().basicVector());
  }

  template <class U>
  Point3DBase< U, GlobalTag>
  toGlobal( const Point3DBase< U, LocalTag>& lp) const {
    return Point3DBase< U, GlobalTag>( rotation().multiplyInverse( lp.basicVector()) +
                       position().basicVector());
  }

  GlobalVector toGlobal( const LocalVector& lv) const {
    return GlobalVector( rotation().multiplyInverse( lv.basicVector()));
  }

  template <class U>
  Vector3DBase< U, GlobalTag>
  toGlobal( const Vector3DBase< U, LocalTag>& lv) const {
    return Vector3DBase< U, GlobalTag>( rotation().multiplyInverse( lv.basicVector()));
  }

  LocalPoint toLocal( const GlobalPoint& gp) const {
    return LocalPoint( rotation() * (gp.basicVector()-position().basicVector()));
  }

  template <class U>
  Point3DBase< U, LocalTag>
  toLocal( const Point3DBase< U, GlobalTag>& gp) const {
    return Point3DBase< U, LocalTag>( rotation() * 
                      (gp.basicVector()-position().basicVector()));
  }

  LocalVector toLocal( const GlobalVector& gv) const {
    return LocalVector( rotation() * gv.basicVector());
  }

  template <class U>
  Vector3DBase< U, LocalTag>
  toLocal( const Vector3DBase< U, GlobalTag>& gv) const {
    return Vector3DBase< U, LocalTag>( rotation() * gv.basicVector());
  }

  void move( const GlobalVector& displacement) {
    thePos += displacement;
    resetCache();
  }

  void rotate( const RotationType& rotation) {
    theRot *= rotation;
    resetCache();
  }

private:

  PositionType  thePos;
  RotationType  theRot;


  void resetCache() {
    if ((thePos.x() == 0.) && (thePos.y() == 0.)) {
      thePhi = theEta = 0.; // avoid FPE
    } else {
      thePhi = iniPhi();
      theEta = iniEta();
    }
  }


  void setCache() {
    if ((thePos.x() == 0.) && (thePos.y() == 0.)) {
      thePhi = theEta = 0.; // avoid FPE
    } else {
      thePhi = thePos.barePhi();
      theEta = thePos.eta();
    }
  }
  
  mutable T thePhi;
  mutable T theEta;

};
  
#endif