In This Package:

SolidSphere.h

Go to the documentation of this file.

// $Id: SolidSphere.h,v 1.19 2008/10/28 14:41:39 cattanem Exp $ 
// ===========================================================================
#ifndef     DETDESC_SOLIDSPHERE_H
#define     DETDESC_SOLIDSPHERE_H 1 
// DetDesc 
#include "DetDesc/SolidBase.h" 
// Units
#include "GaudiKernel/SystemOfUnits.h" 

template <class TYPE>
class SolidFactory;


class SolidSphere: public virtual SolidBase
{
  friend class SolidFactory<SolidSphere>;
  
public:
  
  SolidSphere( const std::string& name                             ,
               const double       OuterRadius                      ,
               const double       InsideRadius    =   0.0          , 
               const double       StartPhiAngle   =   0.0 * Gaudi::Units::degree,
               const double       DeltaPhiAngle   = 360.0 * Gaudi::Units::degree,
               const double       StartThetaAngle =   0.0 * Gaudi::Units::degree,
               const double       DeltaThetaAngle = 180.0 * Gaudi::Units::degree,
               const int          CoverModel      =   0            );

  // destructor 
  virtual ~SolidSphere();
  
  inline std::string typeName () const { return "SolidSphere"; };
  
  bool isInside ( const Gaudi::XYZPoint& point ) const;
  bool isInside ( const Gaudi::Polar3DPoint& point ) const ;
  bool isInside ( const Gaudi::RhoZPhiPoint& point ) const ;

  const ISolid* cover () const;
  
  virtual std::ostream& printOut ( std::ostream& os = std::cout ) const;  
  
  virtual MsgStream&    printOut ( MsgStream& os ) const;  
  
  virtual unsigned int intersectionTicks( const Gaudi::XYZPoint & Point,
                                          const Gaudi::XYZVector& Vector,
                                          ISolid::Ticks& ticks  ) const ;

  virtual unsigned int intersectionTicks( const Gaudi::Polar3DPoint  & Point,
                                          const Gaudi::Polar3DVector & Vector,
                                          ISolid::Ticks     & ticks) const ; 

  virtual unsigned int intersectionTicks( const Gaudi::RhoZPhiPoint  & Point,
                                          const Gaudi::RhoZPhiVector & Vector,
                                          ISolid::Ticks     & ticks) const ;
  
  inline       double               insideRadius   () const 
  { return m_sphere_insideR  ; };
  
  inline       double               insideR2   () const 
  { return m_sphere_insideR2 ; }; 
  
  inline       double               outerRadius  () const 
  { return m_sphere_outerR  ; };
  
  inline       double               outerR2       () const 
  { return m_sphere_outerR2 ; }; 
  
  inline       double               startPhiAngle  () const 
  { return m_sphere_startPhiAngle  ; }; 
  
  inline       double               deltaPhiAngle  () const 
  { return m_sphere_deltaPhiAngle  ; }; 
  
  inline       double               startThetaAngle() const 
  { return m_sphere_startThetaAngle; };
 
  inline       double               deltaThetaAngle() const
  { return m_sphere_deltaThetaAngle; }; 
  
  inline       double  insideDiameter () const 
  { return insideRadius()    * 2 ; }; 

  inline       double  outerDiameter  () const 
  { return outerRadius()     * 2 ; };
 
  inline       double  endPhiAngle    () const 
  { return m_sphere_startPhiAngle   + m_sphere_deltaPhiAngle   ; }; 
  
  inline       double  endThetaAngle  () const 
  { return m_sphere_startThetaAngle + m_sphere_deltaThetaAngle ; };
  
  Ticks::size_type maxNumberOfTicks() const { return 4 ; }

protected:
  
  bool noPhiGap   () const { return m_noPhiGap   ; }
  bool noThetaGap () const { return m_noThetaGap ; }
  
  template<class aPoint>
  inline bool insideR     ( const aPoint& point ) const ;
  
  template<class aPoint>
  inline bool insidePhi   ( const aPoint& point ) const ;
  
  template<class aPoint>
  inline bool insideTheta ( const aPoint& point ) const ;
  
protected:

  SolidSphere( const std::string& name = "Anonymous Sphere" );

  void setBP();
  
private:
  //
  SolidSphere           ( const SolidSphere& );  // no copy-constructor 
  SolidSphere& operator=( const SolidSphere& );  // no assignment 

  template <class aPoint>
  bool isInsideImpl(const aPoint& point) const;

  template<class aPoint, class aVector>
  unsigned int intersectionTicksImpl( const aPoint  & Point,
                                      const aVector & Vector,
                                      ISolid::Ticks& ticks ) const;

  //
private:

  double                m_sphere_outerR2         ;  
  double                m_sphere_insideR2        ; 
  double                m_sphere_startPhiAngle   ;
  double                m_sphere_deltaPhiAngle   ; 
  double                m_sphere_startThetaAngle ; 
  double                m_sphere_deltaThetaAngle ;
  int                   m_sphere_coverModel      ;
  //
  double                m_sphere_outerR          ;  
  double                m_sphere_insideR         ; 
  // 
  bool                  m_noPhiGap               ;
  bool                  m_noThetaGap             ;
  //
};
// ===========================================================================


// ===========================================================================
// ===========================================================================
template <class aPoint>
inline bool SolidSphere::insideR( const aPoint& point ) const 
{
  const double r2 = point.mag2();
  if(  r2 >  outerR2 () ) { return false ; }
  if(  r2 < insideR2 () ) { return false ; }
  // inside! 
  return true ;
};
// ===========================================================================

// ===========================================================================
// ===========================================================================
template <class aPoint>
inline bool SolidSphere::insidePhi( const aPoint& point ) const 
{
  if( noPhiGap()                                    ) { return true ; }
  double phi = point.phi() ;   // [-180,180] 
  if( startPhiAngle ()                   <= phi &&
      startPhiAngle () + deltaPhiAngle() >= phi     ) { return true ; }
  phi += 360 * Gaudi::Units::degree ;
  if( startPhiAngle ()                   <= phi &&
      startPhiAngle () + deltaPhiAngle() >= phi     ) { return true ; }
  // 
  return false ;
};
// ===========================================================================

// ===========================================================================
// ===========================================================================
template <class aPoint>
inline bool SolidSphere::insideTheta( const aPoint& point ) const 
{
  if( noThetaGap()                                        ) { return true ; }
  const double theta = point.theta() ;  
  if( startThetaAngle ()                     <= theta &&
      startThetaAngle () + deltaThetaAngle() >= theta     ) { return true ; }
  // 
  return false ;
};
// ===========================================================================

// ===========================================================================
// The END 
// ===========================================================================
#endif 
// ===========================================================================

---