In This Package:

SolidCons.h

Go to the documentation of this file.

// $Id: SolidCons.h,v 1.22 2008/10/28 12:04:37 cattanem Exp $ 
// ===========================================================================
#ifndef     DETDESC_SOLIDCONS_H
#define     DETDESC_SOLIDCONS_H 1   
// STD and STL 
#include <cmath> 
#include <iostream>
// Units
#include "GaudiKernel/SystemOfUnits.h"
// Geometry Definitions
#include "GaudiKernel/Point3DTypes.h"
#include "GaudiKernel/Vector3DTypes.h"
// DetDesc 
#include "DetDesc/SolidBase.h" 
// forward declarations 
template <class TYPE>
class SolidFactory;

class SolidCons: public virtual SolidBase
{
  friend class SolidFactory<SolidCons>;

public:
  
  SolidCons( const std::string& name                                  ,
             const double       ZHalfLength                           , 
             const double       OuterRadiusAtMinusZ                   ,
             const double       OuterRadiusAtPlusZ                    ,
             const double       InnerRadiusAtMinusZ  =   0.0          , 
             const double       InnerRadiusAtPlusZ   =   0.0          , 
             const double       StartPhiAngle =   0.0 * Gaudi::Units::degree, 
             const double       DeltaPhiAngle = 360.0 * Gaudi::Units::degree,
             const int          CoverModel           =   0            );

  virtual ~SolidCons();
  
  inline std::string typeName () const { return "SolidCons"; };
  
  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&                   )    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 ;
  
  unsigned int intersectionTicks( const Gaudi::XYZPoint& Point,
                                  const Gaudi::XYZVector & Vector,
                                  const ISolid::Tick& tickMin,
                                  const ISolid::Tick& tickMax,
                                  ISolid::Ticks& ticks   ) const ; 

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

  unsigned int intersectionTicks( const Gaudi::RhoZPhiPoint& Point,
                                  const Gaudi::RhoZPhiVector & Vector,
                                  const ISolid::Tick& tickMin,
                                  const ISolid::Tick& tickMax,
                                  ISolid::Ticks& ticks   ) const ; 

  inline double  innerRadiusAtMinusZ () const 
  { return m_cons_innerRadiusMinusZ ; };
  
  inline double  outerRadiusAtMinusZ () const 
  { return m_cons_outerRadiusMinusZ ; };
  
  inline double  innerRadiusAtPlusZ  () const 
  { return m_cons_innerRadiusPlusZ  ; };
  
  inline double  outerRadiusAtPlusZ  () const 
  { return m_cons_outerRadiusPlusZ  ; };
  
  inline double  zHalfLength         () const 
  { return m_cons_zHalfLength       ; };

  inline double  startPhiAngle       () const 
  { return m_cons_startPhiAngle     ; }; 

  inline double  deltaPhiAngle       () const
  { return m_cons_deltaPhiAngle     ; }; 

  inline double  innerDiameterAtMinusZ () const 
  { return m_cons_innerRadiusMinusZ * 2 ; };
  
  inline double  outerDiameterAtMinusZ () const 
  { return m_cons_outerRadiusMinusZ * 2 ; };
  
  inline double  innerDiameterAtPlusZ  () const 
  { return m_cons_innerRadiusPlusZ  * 2 ; };
  
  inline double  outerDiameterAtPlusZ  () const 
  { return m_cons_outerRadiusPlusZ  * 2 ; };
  
  inline double  zLength               () const 
  { return m_cons_zHalfLength       * 2 ; };
  
  inline double  endPhiAngle           () const 
  { return m_cons_startPhiAngle + m_cons_deltaPhiAngle ; }; 
  
protected:

  inline double iR_z( const double z ) const ;
  
  inline double oR_z( const double z ) const ;


  bool noPhiGap() const { return m_noPhiGap ; }
  
  inline bool insidePhi ( const double phi /* [-pi,pi] */ ) const ;

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

  Ticks::size_type maxNumberOfTicks() const { return 4 ; }

protected:
  
  SolidCons( const std::string& Name = "Anonymous CONS") ;

  void setBP();

private:

  SolidCons           ( const SolidCons & );  
  SolidCons& operator=( const SolidCons & );  

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

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

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

private:

  double                  m_cons_zHalfLength       ;
  double                  m_cons_outerRadiusMinusZ ;
  double                  m_cons_outerRadiusPlusZ  ;
  double                  m_cons_innerRadiusMinusZ ;
  double                  m_cons_innerRadiusPlusZ  ;
  double                  m_cons_startPhiAngle     ;
  double                  m_cons_deltaPhiAngle     ;
  int                     m_cons_coverModel        ;
  bool                    m_noPhiGap               ;
  
};
// ===========================================================================

// ===========================================================================
// ===========================================================================
inline double SolidCons::iR_z( const double z ) const
{  
  const double a = 
    ( innerRadiusAtPlusZ () - innerRadiusAtMinusZ () ) / zHalfLength ();
  const double b = 
    ( innerRadiusAtPlusZ () + innerRadiusAtMinusZ () )  ; 
  return 0.5 * ( a * z  + b );
};
// ===========================================================================

// ===========================================================================
// ===========================================================================
inline double SolidCons::oR_z( const double z ) const
{
  const double a = 
    ( outerRadiusAtPlusZ () - outerRadiusAtMinusZ () ) / zHalfLength ();
  const double b = 
    ( outerRadiusAtPlusZ () + outerRadiusAtMinusZ () )  ; 
  return 0.5*(a*z+b);
};
// ===========================================================================

// ===========================================================================
// ===========================================================================
inline bool SolidCons::insidePhi ( const double phi /* [-pi,pi] */ ) const
{
  return 
    noPhiGap() ||
    ( startPhiAngle ()                   <= phi &&
      startPhiAngle () + deltaPhiAngle() >= phi     ) ||
    ( startPhiAngle ()                   <= phi + 2*M_PI &&
      startPhiAngle () + deltaPhiAngle() >= phi + 2*M_PI ) ;
};

// ===========================================================================
// ===========================================================================
template< class aPoint>
inline bool SolidCons::insidePhi ( const aPoint& point ) const 
{
  return noPhiGap() || insidePhi( point.phi() ) ;
};
// ===========================================================================
#endif 
// ===========================================================================

---