CLHEP 2.0.4.7 Reference Documentation     CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

Normal3D.h

Go to the documentation of this file.

// -*- C++ -*-
// $Id: Normal3D.h,v 1.3 2003/10/23 21:29:50 garren Exp $
// ---------------------------------------------------------------------------
//
// This file is a part of the CLHEP - a Class Library for High Energy Physics.
//
// History:
// 09.09.96 E.Chernyaev - initial version
// 12.06.01 E.Chernyaev - CLHEP-1.7: introduction of BasicVector3D to decouple
//                        the functionality from CLHEP::Hep3Vector
// 01.04.03 E.Chernyaev - CLHEP-1.9: template version
//

#ifndef HEP_NORMAL3D_H
#define HEP_NORMAL3D_H

#include <iosfwd>
#include "CLHEP/Geometry/defs.h"
#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Geometry/BasicVector3D.h"

namespace HepGeom {

  class Transform3D;

  template<class T>
  class Normal3D : public BasicVector3D<T> {};

  template<>
  class Normal3D<float> : public BasicVector3D<float> {
  public:
    Normal3D() {}

    Normal3D(float x, float y, float z) : BasicVector3D<float>(x,y,z) {}

    explicit Normal3D(const float * a)
      : BasicVector3D<float>(a[0],a[1],a[2]) {}

    Normal3D(const Normal3D<float> & v) : BasicVector3D<float>(v) {}

    Normal3D(const BasicVector3D<float> & v) : BasicVector3D<float>(v) {}

    ~Normal3D() {}

    Normal3D<float> & operator=(const Normal3D<float> & v) {
      set(v.x(),v.y(),v.z()); return *this;
    }

    Normal3D<float> & operator=(const BasicVector3D<float> & v) {
      set(v.x(),v.y(),v.z()); return *this;
    }

    Normal3D<float> & transform(const Transform3D & m);
  };

  Normal3D<float>
  operator*(const Transform3D & m, const Normal3D<float> & n);

  template<>
  class Normal3D<double> : public BasicVector3D<double> {
  public:
    Normal3D() {}

    Normal3D(double x, double y, double z) : BasicVector3D<double>(x,y,z) {}

    explicit Normal3D(const float * a)
      : BasicVector3D<double>(a[0],a[1],a[2]) {}

    explicit Normal3D(const double * a)
      : BasicVector3D<double>(a[0],a[1],a[2]) {}

    Normal3D(const Normal3D<double> & v) : BasicVector3D<double>(v) {}

    Normal3D(const BasicVector3D<float> & v) : BasicVector3D<double>(v) {}

    Normal3D(const BasicVector3D<double> & v) : BasicVector3D<double>(v) {}

    ~Normal3D() {}

    Normal3D(const CLHEP::Hep3Vector & v)
      : BasicVector3D<double>(v.x(),v.y(),v.z()) {}

    operator CLHEP::Hep3Vector () const { return CLHEP::Hep3Vector(x(),y(),z()); }

    Normal3D<double> & operator=(const Normal3D<double> & v) {
      set(v.x(),v.y(),v.z()); return *this;
    }

    Normal3D<double> & operator=(const BasicVector3D<float> & v) {
      set(v.x(),v.y(),v.z()); return *this;
    }

    Normal3D<double> & operator=(const BasicVector3D<double> & v) {
      set(v.x(),v.y(),v.z()); return *this;
    }

    Normal3D<double> & transform(const Transform3D & m);
  };

  Normal3D<double>
  operator*(const Transform3D & m, const Normal3D<double> & n);

} /* namespace HepGeom */

#ifdef ENABLE_BACKWARDS_COMPATIBILITY
//  backwards compatibility will be enabled ONLY in CLHEP 1.9
typedef HepGeom::Normal3D<double> HepNormal3D;
#endif

#endif /* HEP_NORMAL3D_H */

---