In This Package:

LogVolBase.h

Go to the documentation of this file.

// $Id: LogVolBase.h,v 1.16 2007/01/17 12:10:13 cattanem Exp $ 
#ifndef     DETDESC_LOGVOLBASE_H
#define     DETDESC_LOGVOLBASE_H
#include <functional>
#include <algorithm> 
#include "GaudiKernel/IValidity.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/Transform3DTypes.h"
#include "DetDesc/ISolid.h" 
#include "DetDesc/Services.h" 
#include "DetDesc/IPVolume.h"
#include "DetDesc/IPVolume_predicates.h" 
#include "DetDesc/LogVolumeException.h"
#include "DetDesc/Surface.h"
#include "DetDesc/ValidDataObject.h"

class IDataProviderSvc;
class IMessageSvc;

class LogVolBase: 
  public virtual ILVolume   , 
  public         ValidDataObject 
{
  
protected:
  
  LogVolBase( const std::string& name        = "" , 
              const std::string& sensitivity = "" ,
              const std::string& magnetic    = "" );
  
  virtual ~LogVolBase();
  
public:
  
  inline virtual const std::string&  name () const 
  {
    static std::string s_empty = "";
    IRegistry* pReg = registry();
    return (0!=pReg) ? pReg->identifier() : s_empty;;
  }
  
  inline virtual        PVolumes& pvolumes ()      { return m_pvolumes ; } 
  
  inline virtual const PVolumes& pvolumes () const { return m_pvolumes ; }
  
  inline virtual ILVolume::ReplicaType noPVolumes () const
  { return m_pvolumes.size() ; }
  
  inline virtual const IPVolume* operator[]
  ( const ILVolume::ReplicaType& index ) const
  {
    return m_pvolumes.size() > index ? 
      *(m_pvolumes.begin()+index) : 0 ;
  };
  
  inline virtual const IPVolume* operator[]
  ( const std::string&           name  ) const
  { 
    ILVolume::PVolumes::const_iterator pvi = 
      std::find_if( m_pvolumes.begin  () , 
                    m_pvolumes.end    () , 
                    IPVolume_byName( name ) ) ;
    return m_pvolumes.end() != pvi ? *pvi : 0 ;
  };
  
  virtual const IPVolume* pvolume   
  ( const ILVolume::ReplicaType& index ) const
  {
    return m_pvolumes.size() > index ? 
      *(m_pvolumes.begin()+index) : 0 ;
  };
  
  virtual const IPVolume* pvolume   
  ( const std::string&           name  ) const 
  { 
    ILVolume::PVolumes::const_iterator pvi = 
      std::find_if( m_pvolumes.begin  () , 
                    m_pvolumes.end    () , 
                    IPVolume_byName( name ) ) ;
    return m_pvolumes.end() != pvi ? *pvi : 0 ;
  };
  
  inline virtual ILVolume::PVolumes::iterator       pvBegin     ()
  { return m_pvolumes.begin () ;}
  
  inline virtual ILVolume::PVolumes::const_iterator pvBegin     () const
  { return m_pvolumes.begin () ;}
  
  inline virtual ILVolume::PVolumes::iterator       pvEnd       ()
  { return m_pvolumes.end ()  ;}
  
  inline virtual ILVolume::PVolumes::const_iterator pvEnd       () const 
  { return m_pvolumes.end () ;}
  
  virtual StatusCode traverse 
  ( ILVolume::ReplicaPath::const_iterator pathBegin,
    ILVolume::ReplicaPath::const_iterator pathEnd  ,
    ILVolume::PVolumePath&                pVolumePath ) const ;
  
  inline virtual StatusCode traverse 
  ( const ILVolume::ReplicaPath&  path,
    ILVolume::PVolumePath&        pVolumePath ) const
  { return traverse( path.begin() , path.end() , pVolumePath ); }
  
  inline virtual const std::string& sdName () const { return m_sdName; } ;
  
  inline virtual const std::string& mfName () const { return m_mfName; } ;
  
  inline virtual        Surfaces& surfaces()       { return m_surfaces ; }
  
  inline virtual  const Surfaces& surfaces() const { return m_surfaces ; }
  
  virtual std::ostream& printOut( std::ostream & os = std::cout ) const ;
  
  virtual MsgStream&    printOut( MsgStream    & os             ) const;
  
  inline virtual ILVolume* reset () 
  {
    std::for_each( m_pvolumes.begin ()         , 
                   m_pvolumes.end   ()         ,
                   std::mem_fun(&IPVolume::reset) ) ;
    return this;
  };
  
  virtual StatusCode 
  queryInterface( const InterfaceID& ID , void** ppI ) ;

  virtual unsigned long addRef  ();

  virtual unsigned long release ();

  IPVolume* createPVolume
  ( const std::string&    PVname                    , 
    const std::string&    LVnameForPV               ,
    const Gaudi::XYZPoint&     position = Gaudi::XYZPoint  () ,  
    const Gaudi::Rotation3D&    rotation = Gaudi::Rotation3D () ); 
  
  IPVolume* createPVolume
  ( const std::string&    PVname                    , 
    const std::string&    LVnameForPV               ,
    const Gaudi::Transform3D& Transform                 );
  
protected: 
  
  IPVolume* createPVolume();
  
  inline void Assert
  ( bool               assertion                       , 
    const std::string& name                            ,
    const StatusCode&  sc        = StatusCode::FAILURE ) const
  { if( !assertion ) { throw LogVolumeException( name, this , sc ); } };
  
  inline void Assert
  ( bool                  assertion , 
    const std::string&    name      ,
    const GaudiException& Exception , 
    const StatusCode&     sc        = StatusCode::FAILURE ) const  
  { 
    if( !assertion ) 
      { throw LogVolumeException( name, Exception , this , sc ); }
  };
  
  unsigned int intersectDaughters
  ( const Gaudi::XYZPoint&        Point              , 
    const Gaudi::XYZVector&       Vector             , 
    ILVolume::Intersections& childIntersections , 
    const ISolid::Tick     & tickMin            , 
    const ISolid::Tick     & tickMax            , 
    const double             Threshold          ) const ;  
  
  unsigned int  intersectDaughters
  ( const Gaudi::XYZPoint&        Point              , 
    const Gaudi::XYZVector&       Vector             , 
    ILVolume::Intersections& childIntersections , 
    const double             Threshold          ) const ;
  
  inline bool isInsideDaughter
  ( const Gaudi::XYZPoint& LocalPoint ) const
  { 
    return  
      m_pvolumes.end() != insideDaughter( LocalPoint );
  };
  
  inline ILVolume::PVolumes::const_iterator insideDaughter
  ( const Gaudi::XYZPoint& LocalPoint ) const
  { 
    return  
      std::find_if( m_pvolumes.begin () , 
                    m_pvolumes.end   () , 
                    IPVolume_isInside( LocalPoint ) ) ;
  };

protected: 
  
  // deduce the copy number of physical volume from its name 
  //  size_t   copyNumber ( const std::string& pvName ) const ;
  //  bool     copyExist  ( const size_t       copy   ) const ;

protected:
  
  IDataProviderSvc* dataSvc() const;

  IMessageSvc* msgSvc() const;

private: 
  
  LogVolBase            ( const LogVolBase& lvb );
  LogVolBase& operator= ( const LogVolBase& lvb );
  
private:
  
  PVolumes              m_pvolumes      ; 
  Surfaces              m_surfaces      ; 
  std::string           m_sdName        ;
  std::string           m_mfName        ;
  static  unsigned long s_volumeCounter ;
  DetDesc::Services* m_services;
};

// ============================================================================
// The End 
// ============================================================================
#endif  
// ============================================================================

---