KVPosition.h

/***************************************************************************
                          kvposition.h  -  description
                             -------------------
    begin                : Sun May 19 2002
    copyright            : (C) 2002 by J.D. Frankland
    email                : frankland@ganil.fr
 
$Id: KVPosition.h,v 1.20 2009/01/19 14:36:57 ebonnet Exp $
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef KVPOSITION_H
#define KVPOSITION_H
#include "TMath.h"
#include "KVBase.h"
#include "TVector3.h"
#include "TRotation.h"
class TGeoHMatrix;
class TGeoBBox;
 
class KVPosition {
private:
    Double_t fTheta;
    mutable Double_t fPhi;
    Double_t fTheta_min;
    Double_t fTheta_max;
    Double_t fPhi_min;
    Double_t fPhi_max;
    Double_t fDistance;
 
   /* ROOT Geometry */
    TGeoHMatrix* fMatrix;
    TGeoBBox* fShape;
    mutable Double_t fSolidAngle;
 
   TVector3 GetSCVector() const
   {
      return GetVolumeCentre() - GetSurfaceCentre();
   }
   Double_t GetOC_SC_CosAngle() const
   {
      return GetVolumeCentre().Unit().Dot(GetSCVector().Unit());
   }
 
public:
   KVPosition();
   KVPosition(Double_t thmin, Double_t thmax, Double_t phmin, Double_t phmax, Double_t dist = 0.0);
   void init();
   virtual ~KVPosition();
   virtual void SetAzimuthalAngle(Double_t ph);
   virtual void SetPolarAngle(Double_t th);
   virtual void SetPolarWidth(Double_t pw);
   virtual void SetPolarMinMax(Double_t min, Double_t max);
   virtual void SetAzimuthalWidth(Double_t aw);
   virtual void SetAzimuthalMinMax(Double_t min, Double_t max);
   void SetPhiMinMax(Double_t min, Double_t max)
   {
      SetAzimuthalMinMax(min, max);
   }
   virtual TVector3 GetRandomDirection(Option_t* t = "isotropic");
   TRotation GetRandomIsotropicRotation();
   virtual void GetRandomAngles(Double_t& th, Double_t& ph, Option_t* t = "isotropic");
   void CalculateEstimatedAngularLimits(int N=10000);
   virtual TVector3 GetDirection();
 
   Bool_t IsInPolarRange(const Double_t theta);
   Bool_t IsInPhiRange(const Double_t phi);
   Bool_t IsSmallerThan(KVPosition* pos);
   Bool_t IsAlignedWith(KVPosition* pos);
   Bool_t IsOverlappingWith(KVPosition* pos);
   Bool_t IsAzimuthallyWiderThan(KVPosition* pos);
 
   Double_t GetPhiMin() const
   {
      if(ROOTGeo() && fPhi_min==fPhi_max)
         const_cast<KVPosition*>(this)->CalculateEstimatedAngularLimits();
      return fPhi_min;
   }
   Double_t GetPhiMax() const
   {
      if(ROOTGeo() && fPhi_min==fPhi_max)
         const_cast<KVPosition*>(this)->CalculateEstimatedAngularLimits();
      return fPhi_max;
   }
   Double_t GetThetaMin() const
   {
      if(ROOTGeo() && fTheta_min==fTheta_max)
         const_cast<KVPosition*>(this)->CalculateEstimatedAngularLimits();
      return fTheta_min;
   }
   Double_t GetThetaMax() const
   {
      if(ROOTGeo() && fTheta_min==fTheta_max)
         const_cast<KVPosition*>(this)->CalculateEstimatedAngularLimits();
      return fTheta_max;
   }
   Double_t GetAzimuthalWidth(Double_t phmin = -1., Double_t phimax =
                                 -1.) const;
   virtual Double_t GetTheta() const
   {
      return fTheta;
   }
   virtual Double_t GetSinTheta() const
   {
      return TMath::Sin(fTheta * TMath::DegToRad());
   }
   virtual Double_t GetCosTheta() const
   {
      return TMath::Cos(fTheta * TMath::DegToRad());
   }
   virtual Double_t GetPhi() const
   {
      if (fPhi >= 360.0)
         fPhi -= 360.;
      return fPhi;
   }
   void SetTheta(Double_t t)
   {
      SetPolarAngle(t);
   }
   void SetPhi(Double_t p)
   {
      SetAzimuthalAngle(p);
   }
   void SetDistance(Double_t d)
   {
      fDistance = d;
   }
   virtual Double_t GetDistance(void) const
   {
      return fDistance;
   }
   void GetCornerCoordinates(TVector3*, Double_t /*depth*/ = 0);
   void GetCornerCoordinatesInOwnFrame(TVector3*, Double_t /*depth*/ = 0);
   void GetWidthsFromDimension(Double_t lin_dim);
 
   virtual Double_t GetSolidAngle(void) const;
 
   /* ROOT Geometry */
   virtual Bool_t ROOTGeo() const
   {
      return (fMatrix && fShape);
   }
   virtual void SetMatrix(const TGeoHMatrix*);
   virtual void SetShape(TGeoBBox*);
   virtual TGeoHMatrix* GetMatrix() const;
   virtual TGeoBBox* GetShape() const;
   virtual TVector3 GetRandomPointOnSurface() const;
   virtual TVector3 GetSurfaceCentre() const;
   virtual TVector3 GetVolumeCentre() const;
   virtual TVector3 GetSurfaceNormal() const;
   virtual Double_t GetSurfaceArea(int npoints = 100000) const;
   virtual Double_t GetMisalignmentAngle() const;
 
   ClassDef(KVPosition, 1)//Class handling geometry of detectors in a multidetector array
};
 
#endif