In This Package:

SolidPolycone.h

Go to the documentation of this file.

// $Id: SolidPolycone.h,v 1.15 2008/12/11 15:33:25 cattanem Exp $ 
// ============================================================================
#ifndef DETDESC_SOLIDPOLYCONE_H 
#define DETDESC_SOLIDPOLYCONE_H 1
// Include files
// STD and STL 
#include <cmath> 
#include <iostream>
#include <functional>
#include <algorithm>
#include <vector>
// 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 SolidPolycone: public virtual SolidBase
{
  friend class SolidFactory<SolidPolycone>;

public:
  
  typedef std::pair<double,double>  Pair     ;
  typedef std::pair<double,Pair>    Triplet  ;
  typedef std::vector<Triplet>      Triplets ;
  typedef Triplets::const_iterator  Iterator ;
  
  SolidPolycone( const std::string&  Name                       ,
                 const Triplets   &  Params                     ,
                 const double        StartPhiAngle = 0          ,
                 const double        DeltaPhiAngle = 360*Gaudi::Units::degree );

  virtual ~SolidPolycone();
  
  inline std::string typeName () const { return "SolidPolycone"; };
  
  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 ;
  
  inline unsigned int number   () const { return triplets().size() ; }
  
  inline const Triplets&
  triplets () const { return m_triplets ; }
  
  inline Triplets::const_iterator 
  begin    () const { return triplets().begin(); }
  
  inline Triplets::const_iterator 
  end      () const { return triplets().end  (); }

  inline double  z( Triplets::size_type index ) const 
  { return ( begin() + index )->first ; }
  
  inline double  RMax( Triplets::size_type index ) const 
  { return ( begin() + index )->second.first ; }
  
  inline double  RMin( Triplets::size_type index ) const 
  { return ( begin() + index )->second.second ; }
  
  inline double startPhiAngle() const { return m_startPhiAngle;}

  inline double deltaPhiAngle() const { return m_deltaPhiAngle;}
  
  inline Triplets::size_type index( const double thisz ) const 
  { 
    Triplets::size_type i = thisz < z(0) || thisz > z(number()-1) ? number()-1 : 0 ;
    for(; i<number()-1 && z(i+1) <= thisz; ++i) {}
    return i ;
  }

  Ticks::size_type maxNumberOfTicks() const { return (number()+1)*2 ; }

protected:
  
  class CmpZ: 
    public std::binary_function<Triplet,double,bool>
  { 
  public:
    inline bool operator() ( const Triplet& triplet , const double&  Z ) const
    { return triplet.first >= Z ; }
  };

protected:
  static Triplets makeTriplets(double ZHalfLength        , 
                               double OuterRadiusMinusZ  ,
                               double OuterRadiusPlusZ   ,
                               double InnerRadiusMinusZ  , 
                               double InnerRadiusPlusZ ) ;

  static Triplets makeTriplets(double ZHalfLength        , 
                               double OuterRadius,
                               double InnerRadius) {
    return makeTriplets(ZHalfLength,OuterRadius,OuterRadius,InnerRadius,InnerRadius) ; }

protected:
  
  SolidPolycone( const std::string& Name = "Anonymous Polycone") ;

  void setBP();
  
private:
  
  SolidPolycone           ( const SolidPolycone & );  
  SolidPolycone& operator=( const SolidPolycone & );  

  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;

  inline bool 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 ) ;
  }

  bool noPhiGap() const { return m_deltaPhiAngle == 360 * Gaudi::Units::degree ; }

private:
  
  Triplets       m_triplets      ; 
  double         m_startPhiAngle ; 
  double         m_deltaPhiAngle ; 
  
  //-------------------------------------
  //Define a function to sort only the first element of a pair
  struct sort_first
  {
    bool operator () (const Triplet& left, const Triplet& right)
    { return left.first < right.first;  }
  };
  //-------------------------------------
  
};

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

---