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>
 
#include <memory>
 
 
namespace genfit {

class DetPlane : public TObject {
 
 public:
 
 
  // Constructors/Destructors ---------
  DetPlane(AbsFinitePlane* finite = nullptr);
 
  DetPlane(const TVector3& o,
             const TVector3& u,
             const TVector3& v,
             AbsFinitePlane* finite = nullptr);
 
  DetPlane(const TVector3& o,
             const TVector3& n,
             AbsFinitePlane* finite = nullptr);
 
  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() == nullptr) 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() == nullptr) 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() == nullptr) 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() != nullptr);
  }

  void rotate(double angle);

  void reset();
 
 private:
  // Private Methods -----------------
  void sane();
 
  TVector3 o_;
  TVector3 u_;
  TVector3 v_;
 
  std::unique_ptr<AbsFinitePlane> finitePlane_; // Ownership
 
 public:
  ClassDef(DetPlane,1)
 
};
 
} /* End of namespace genfit */
 
#endif // genfit_DetPlane_h