In This Package:

SolidBase.h

Go to the documentation of this file.

// $Id: SolidBase.h,v 1.18 2008/06/24 13:25:03 jonrob Exp $
#ifndef DETDESC_SOLIDBASE_H 
#define DETDESC_SOLIDBASE_H 1

// DetDesc 
#include "DetDesc/Services.h"
#include "DetDesc/ISolid.h"

class IMessageSvc;

class SolidBase: public virtual ISolid
{
  
public: 
  
  virtual const std::string& name() const { return m_name ; }
  
  virtual ISolid* reset ();

  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 ; 
  
  virtual unsigned int intersectionTicks( const Gaudi::XYZPoint& Point,
                                          const Gaudi::XYZVector & Vector,
                                          const ISolid::Tick& tickMin,
                                          const ISolid::Tick& tickMax,
                                          ISolid::Ticks& ticks   ) const ; 

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

  virtual unsigned int intersectionTicks( const Gaudi::RhoZPhiPoint& Point,
                                          const Gaudi::RhoZPhiVector & Vector,
                                          const ISolid::Tick& tickMin,
                                          const ISolid::Tick& tickMax,
                                          ISolid::Ticks& ticks   ) const ; 
  
  virtual StatusCode queryInterface
  ( const InterfaceID& ID , void** ppI );
  
  virtual unsigned long addRef  () ;
  
  virtual unsigned long release () ;
  
  virtual const ISolid* coverTop () const ;
  
  virtual std::ostream& printOut ( std::ostream& st ) const ;
  
  virtual MsgStream&    printOut ( MsgStream&    st ) const ;
 
public : 
  
  inline double  xMin      () const                { return m_xmin    ; }
  inline double  xMax      () const                { return m_xmax    ; }
  
  inline double  yMin      () const                { return m_ymin    ; }
  inline double  yMax      () const                { return m_ymax    ; }
  
  inline double  zMin      () const                { return m_zmin    ; }
  inline double  zMax      () const                { return m_zmax    ; }
  
  inline double  rMax      () const                { return m_rmax    ; }
  
  inline double  rhoMax    () const                { return m_rhomax  ; }

protected:
  
  template <class aPoint>
  inline bool isOutBBox      
  ( const aPoint& point         , 
    const double      tolerance ) const 
  {
    return 
      point.z () < zMin () - tolerance ||
      point.z () > zMax () + tolerance ||
      point.x () < xMin () - tolerance ||
      point.x () > xMax () + tolerance ||
      point.y () < yMin () - tolerance ||
      point.y () > yMax () + tolerance ;
  };
  template <class aPoint>
  inline bool isOutBBox      
  ( const aPoint& point ) const 
  {
    return 
      point.z () < zMin () ||
      point.z () > zMax () ||
      point.x () < xMin () ||
      point.x () > xMax () ||
      point.y () < yMin () ||
      point.y () > yMax () ;
  };
  
  template <class aPoint>
  inline bool isOutBSphere   
  ( const aPoint& point         ,
    const double      tolerance ) const 
  {
    const  double rmax = rMax()  + tolerance ;
    return rmax <= 0 || point.mag2() > rmax * rmax ;
  };
  
  template <class aPoint>
  inline bool isOutBSphere ( const aPoint& point  ) const 
  {
    return  point.mag2 () > rMax () * rMax () ;
  };
  
  template <class aPoint>
  inline bool isOutBCylinder 
  ( const aPoint& point         , 
    const double      tolerance ) const 
  {
    const double rhomax = rhoMax() + tolerance ;
    return rhomax <= 0 ? true : 
      point.z     () < zMin   () - tolerance ? true :
      point.z     () > zMax   () + tolerance ? true :
      point.perp2 () > rhomax * rhomax       ? true : false ;
  };
  
  template <class aPoint>
  inline bool isOutBCylinder ( const aPoint& point ) const 
  {
    return 
      point.z     () < zMin   () ||
      point.z     () > zMax   () ||
      point.perp2 () > rhoMax () * rhoMax () ;
  };
  
  template<class aPointA, class aPointB>
  inline bool isOutBBox      
  ( const aPointA& p1            , 
    const aPointB& p2            , 
    const double      tolerance ) const 
  {  
    return 
      ( (p1.z() < zMin()-tolerance && p2.z() < zMin()-tolerance) ||
        (p1.z() > zMax()+tolerance && p2.z() > zMax()+tolerance) ||
        (p1.x() < xMin()-tolerance && p2.x() < xMin()-tolerance) ||
        (p1.x() > xMax()+tolerance && p2.x() > xMax()+tolerance) ||
        (p1.y() < yMin()-tolerance && p2.y() < yMin()-tolerance) ||
        (p1.y() > yMax()+tolerance && p2.y() > yMax()+tolerance) );
  };

  template<class aPointA, class aPointB>
  inline bool isOutBBox      
  ( const aPointA& p1            , 
    const aPointB& p2 ) const 
  { 
    return 
      ( p1.z() < zMin() && p2.z() < zMin() ) ||
      ( p1.z() > zMax() && p2.z() > zMax() ) ||
      ( p1.x() < xMin() && p2.x() < xMin() ) ||
      ( p1.x() > xMax() && p2.x() > xMax() ) ||
      ( p1.y() < yMin() && p2.y() < yMin() ) ||
      ( p1.y() > yMax() && p2.y() > yMax() ) ;
  };

  template <class aPoint, class aVector>
  inline bool isOutBBox      
  ( const aPoint&   p             , 
    const aVector&  v             , 
    const ISolid::Tick& tmin          ,
    const ISolid::Tick& tmax          , 
    const double        tolerance ) const 
  {
    return isOutBBox( p + tmin * v , p + tmax * v , tolerance );
  };  
  
  template <class aPoint, class aVector>
  inline bool isOutBBox      
  ( const aPoint&   p             , 
    const aVector&  v             , 
    const ISolid::Tick& tmin          ,
    const ISolid::Tick& tmax ) const 
  {
    return isOutBBox( p + tmin * v , p + tmax * v );
  };  
  
  template <class aPoint, class aVector>
  inline bool crossBSphere      
  ( const aPoint&   p             , 
    const aVector&  v             , 
    const double        tolerance = 0 ) const 
  {
    const double pp   = p.mag2 ()           ;
    const double vv   = v.mag2 ()           ;
    const double pv   = p.Dot  ( v )        ;
    const double rmax = rMax() + tolerance  ;
    const double dd   = rmax * rmax         ;
    return ( rmax > 0                       && 
             !(0 == vv && pp > dd)          &&
             !( (vv*pp) - (pv*pv) > vv*dd ) );
  };
  
  template <class aPoint, class aVector>
  inline bool crossBCylinder      
  ( const aPoint&   p             , 
    const aVector&  v             , 
    const double        tolerance = 0 ) const 
  {
    const double pp     = p.perp2 ()                  ;
    const double vv     = v.perp2 ()                  ;
    const double pv     = p.Dot ( v ) - p.z() * v.z() ;
    const double rhomax = rhoMax() + tolerance  ;
    const double dd     = rhomax * rhomax     ;
    return ( rhomax > 0                     &&
             !( 0 == vv && pp > dd )        &&
             !( (vv*pp) - (pv*pv) > vv*dd ) );
  };

protected:

  inline void    setXMin   ( const double value )  { m_xmin   = value ; }
  inline void    setXMax   ( const double value )  { m_xmax   = value ; }

  inline void    setYMin   ( const double value )  { m_ymin   = value ; }
  inline void    setYMax   ( const double value )  { m_ymax   = value ; }

  inline void    setZMin   ( const double value )  { m_zmin   = value ; }
  inline void    setZMax   ( const double value )  { m_zmax   = value ; }

  inline void    setRMax   ( const double value )  { m_rmax   = value ; }
  inline void    setRhoMax ( const double value )  { m_rhomax = value ; }

  void checkBP() const ;
  
  IMessageSvc* msgSvc() const;
    
protected:
  
  SolidBase( const std::string& Name="Undefined" );
  
  virtual ~SolidBase();

private:
  //  SolidBase();

  // assignement operator is disabled 
  SolidBase& operator=( const SolidBase& ) ;

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;

unsigned int intersectionTicksImpl( ISolid::Ticks& ticks ) const;
  
protected:
  
  std::string     m_name  ; 
  mutable ISolid* m_cover ; 
  
  double m_xmin   ;
  double m_ymin   ;
  double m_zmin   ;
  
  double m_xmax   ;
  double m_ymax   ;
  double m_zmax   ;
  
  double m_rmax   ;
  double m_rhomax ;
  
  DetDesc::Services* m_services;
};

// ===========================================================================
// The End 
// ===========================================================================
#endif //< DETDESC_SOLIDBASE_H
// ===========================================================================

---