DetPlane.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/* 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 = 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_;

#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