DetPlane.h

Go to the documentation of this file.

/* Copyright 2008-2010, Technische Universitaet Muenchen,
   Authors: Christian Hoeppner & Sebastian Neubert & Johannes Rauch

   This file is part of GENFIT.

   GENFIT is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   GENFIT is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with GENFIT.  If not, see <http://www.gnu.org/licenses/>.
*/
// Description:
//      Detector plane - a geometric object
#ifndef genfit_DetPlane_h
#define genfit_DetPlane_h

#include "AbsFinitePlane.h"

#include <TObject.h>
#include <TVector3.h>

#ifndef __CINT__
#include <boost/scoped_ptr.hpp>
#endif


namespace genfit {

class DetPlane : public TObject {

 public:


  // Constructors/Destructors ---------
  DetPlane(AbsFinitePlane* finite = NULL);

  DetPlane(const TVector3& o,
             const TVector3& u,
             const TVector3& v,
             AbsFinitePlane* finite = NULL);

  DetPlane(const TVector3& o,
             const TVector3& n,
             AbsFinitePlane* finite = NULL);

  virtual ~DetPlane();

  DetPlane(const DetPlane&);
  DetPlane& operator=(DetPlane);
  void swap(DetPlane& other); // nothrow

  // Accessors -----------------------
  const TVector3& getO() const {return o_;}
  const TVector3& getU() const {return u_;}
  const TVector3& getV() const {return v_;}

  // Modifiers -----------------------
  void set(const TVector3& o,
           const TVector3& u,
           const TVector3& v);
  void setO(const TVector3& o);
  void setO(double, double, double);
  void setU(const TVector3& u);
  void setU(double, double, double);
  void setV(const TVector3& v);
  void setV(double, double, double);
  void setUV(const TVector3& u, const TVector3& v);
  void setON(const TVector3& o, const TVector3& n);

  void setFinitePlane(AbsFinitePlane* finite){finitePlane_.reset(finite);}

  // Operations ----------------------
  TVector3 getNormal() const;
  void setNormal(const TVector3& n);
  void setNormal(double, double, double);
  void setNormal(const double& theta, const double& phi);

  TVector2 project(const TVector3& x) const;

  TVector2 LabToPlane(const TVector3& x) const;

  TVector3 toLab(const TVector2& x) const;

  // get vector from point to plane (normal)
  TVector3 dist(const TVector3& point) const;

  TVector2 straightLineToPlane(const TVector3& point, const TVector3& dir) const;

  void straightLineToPlane(const double& posX, const double& posY, const double& posZ,
                           const double& dirX, const double& dirY, const double& dirZ,
                           double& u, double& v) const;

  void Print(const Option_t* = "") const;

  friend bool operator== (const DetPlane& lhs, const DetPlane& rhs);
  friend bool operator!= (const DetPlane& lhs, const DetPlane& rhs);

  double distance(const TVector3& point) const;
  double distance(double, double, double) const;


  bool isInActive(const TVector3& point, const TVector3& dir) const {
    if(finitePlane_.get() == NULL) return true;
    return this->isInActive( this->straightLineToPlane(point,dir));
  }

  bool isInActive(const double& posX, const double& posY, const double& posZ,
                  const double& dirX, const double& dirY, const double& dirZ) const {
    if(finitePlane_.get() == NULL) return true;
    double u, v;
    this->straightLineToPlane(posX, posY, posZ, dirX, dirY, dirZ, u, v);
    return this->isInActive(u, v);
  }

  bool isInActive(double u, double v) const{
    if(finitePlane_.get() == NULL) return true;
    return finitePlane_->isInActive(u,v);
  }

  bool isInActive(const TVector2& v) const{
    return isInActive(v.X(),v.Y());
  }

  bool isFinite() const {
    return (finitePlane_.get() != NULL);
  }

  void rotate(double angle);

  void reset();

 private:
  // Private Methods -----------------
  void sane();

  TVector3 o_;
  TVector3 u_;
  TVector3 v_;

#ifndef __CINT__
  boost::scoped_ptr<AbsFinitePlane> finitePlane_; // Ownership
#else
  class AbsFinitePlane* finitePlane_; 
#endif


 public:
  ClassDef(DetPlane,1)

};

} /* End of namespace genfit */
#endif // genfit_DetPlane_h