In This Package:

GeometryInfoPlus.h

Go to the documentation of this file.

// $Id: GeometryInfoPlus.h,v 1.13 2009/02/02 12:20:22 marcocle Exp $
#ifndef LIB_GEOMETRYINFOPLUS_H 
#define LIB_GEOMETRYINFOPLUS_H 1

// Include files
#include <iostream>
#include <string>
#include <functional>
#include <algorithm> 
/* GaudiKernel includes */
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/StatusCode.h"
#include "DetDesc/Services.h"
#include "DetDesc/ILVolume.h"
#include "DetDesc/IPVolume.h"
#include "DetDesc/IGeometryInfo.h" 
#include "DetDesc/IDetectorElement.h" 
#include "GeometryInfoException.h"

class GaudiException   ;
class IDataProviderSvc ;
class ISvcLocator;
class IUpdateManagerSvc;
class AlignmentCondition;

class GeometryInfoPlus :   public IGeometryInfo {

  friend class DetectorElement;

public: 

  typedef std::vector<std::string>     ChildName;

  typedef std::vector<Gaudi::Transform3D>::const_iterator matrix_iterator;

  typedef std::vector<IGeometryInfo*> IGIChildren;
  typedef IGeometryInfo::IGIChildrens::iterator iGInfo_iterator;

  GeometryInfoPlus( IDetectorElement* de ); 
  
  GeometryInfoPlus( IDetectorElement*   de     ,
                    const std::string&  LogVol ); 
  
  GeometryInfoPlus( IDetectorElement*            de,
                    const std::string&           LogVol, 
                    const std::string&           Support,
                    const ILVolume::ReplicaPath& ReplicaPath,
                    const std::string& alignmentPath="");
  
  GeometryInfoPlus( IDetectorElement*  de,
                    const std::string& LogVol, 
                    const std::string& Support,
                    const std::string& ReplicaNamePath,
                    const std::string& alignmentPath="");
  
  virtual ~GeometryInfoPlus( ); 

public:

  StatusCode initialize();

  StatusCode cache();

  StatusCode updateChildren();

  bool hasLVolume() const;

  bool hasSupport() const;

  const AlignmentCondition* alignmentCondition() const ;
  
  const Gaudi::Transform3D&  toLocalMatrix() const;
  
  const Gaudi::Transform3D&  toGlobalMatrix() const;

  const Gaudi::Transform3D& toLocalMatrixNominal() const;

  const Gaudi::Transform3D&  toGlobalMatrixNominal() const;

  const Gaudi::Transform3D& ownToLocalMatrixNominal() const;

  const Gaudi::Transform3D& ownToNominalMatrix() const;

  Gaudi::Transform3D ownToOffNominalMatrix() const;

  Gaudi::Transform3D  ownMatrix() const;
  
  StatusCode ownToOffNominalMatrix(const Gaudi::Transform3D&);

  StatusCode ownToOffNominalParams(const std::vector<double>& trans,
                                   const std::vector<double>& rot,
                                   const std::vector<double>& pivot =
                                   std::vector<double>(3) );

  Gaudi::XYZPoint toLocal( const Gaudi::XYZPoint& globalPoint ) const;

  Gaudi::XYZPoint toGlobal( const Gaudi::XYZPoint& localPoint  ) const;
  
  Gaudi::XYZVector toLocal( const Gaudi::XYZVector& globalDirection ) const;

  Gaudi::XYZVector toGlobal( const Gaudi::XYZVector& localDirection  ) const;

  bool isInside( const Gaudi::XYZPoint& globalPoint ) const ;

  std::string belongsToPath( const Gaudi::XYZPoint& globalPoint );      
  
  IGeometryInfo* belongsTo( const Gaudi::XYZPoint& globalPoint );    
  
  std::string belongsToPath( const Gaudi::XYZPoint& globalPoint ,       
                             const int         level       );       

  IGeometryInfo* belongsTo( const Gaudi::XYZPoint& globalPoint ,        
                            const int         level       );      

  StatusCode fullGeoInfoForPoint( const Gaudi::XYZPoint&        point      , 
                                  const int                level      , 
                                  IGeometryInfo*&          start      , 
                                  ILVolume::PVolumePath&   volumePath );

  StatusCode fullGeoInfoForPoint( const Gaudi::XYZPoint&        point      , 
                                  const int                level      , 
                                  IGeometryInfo*&          start      , 
                                  ILVolume::ReplicaPath&   volumePath );

  StatusCode fullGeoInfoForPoint( const Gaudi::XYZPoint&        point      , 
                                  const int                level      , 
                                  std::string&             start      , 
                                  ILVolume::PVolumePath&   volumePath );

  StatusCode fullGeoInfoForPoint( const Gaudi::XYZPoint&        point      , 
                                  const int                level      , 
                                  std::string&             start      , 
                                  ILVolume::ReplicaPath&   volumePath );

  inline const std::string& lvolumeName() const  { return m_gi_lvolumeName; }
  

  const ILVolume* lvolume() const ;
  
  StatusCode location( IGeometryInfo*&              start , 
                       ILVolume::ReplicaPath&       replicaPath ) const ;

  StatusCode location( std::string&                 start , 
                       ILVolume::ReplicaPath&       replicaPath ) const ;

  IGeometryInfo* supportIGeometryInfo() const;
  

  std::string lvolumePath( const std::string&           start       , 
                           const ILVolume::ReplicaPath& replicaPath );

  const ILVolume* lvolume( const std::string&           start       , 
                           const ILVolume::ReplicaPath& replicaPath );
  
  std::string lvolumePath( IGeometryInfo*               start       , 
                           const ILVolume::ReplicaPath& replicaPath );

  const ILVolume* lvolume( IGeometryInfo*               start       , 
                           const ILVolume::ReplicaPath& replicaPath );

  const ILVolume::ReplicaPath& supportPath() const ;


  IGeometryInfo* parentIGeometryInfo();

  const IGeometryInfo* parentIGeometryInfo() const;

  inline IGeometryInfo::IGIChildrens& childIGeometryInfos() 
  {
    if( !m_gi_childLoaded ) loadChildren(); 
    return m_gi_childrens; 
  }
  inline const IGeometryInfo::IGIChildrens& childIGeometryInfos() const 
  {
    if( !m_gi_childLoaded ) loadChildren();
    return m_gi_childrens; 
  }
  inline IGeometryInfo::IGIChildrens::const_iterator childBegin() const
  {
     if( !m_gi_childLoaded ) {  
       try{ loadChildren(); }
       catch(...) { return m_gi_childrens.end(); }
     }
     return m_gi_childrens.begin();
  }
  

  inline IGeometryInfo::IGIChildrens::iterator childBegin()
  {  
    if( !m_gi_childLoaded ) 
    {  try{ loadChildren(); } catch(...){ return m_gi_childrens.end(); }  }
    return m_gi_childrens.begin(); 
  }
  
  inline IGeometryInfo::IGIChildrens::iterator childEnd() 
  {
    if( !m_gi_childLoaded ) 
    {  try{ loadChildren(); } catch(...){ return m_gi_childrens.end(); }  }
    return m_gi_childrens.end(); 
  }
  

  inline IGeometryInfo::IGIChildrens::const_iterator childEnd() const 
  {
    if( !m_gi_childLoaded ) 
    {  try{ loadChildren(); } catch(...){ return m_gi_childrens.end(); }  }
    return m_gi_childrens.end(); 
  }
  
  std::ostream& printOut   ( std::ostream& ) const;
  MsgStream&    printOut   ( MsgStream&    ) const;
  IGeometryInfo*  reset();

  StatusCode queryInterface( const InterfaceID& ID , void** ppI ) ;
  unsigned long addRef() 
  {
    return 0;
  }
  
  unsigned long release() 
  {
    return 0;
  }
  
  


protected:


private:

  inline IMessageSvc*       msgSvc() const {
    return m_services->msgSvc();
  }
  inline IDataProviderSvc*  dataSvc() const {
    return m_services->detSvc();
  }
  inline ISvcLocator*       svcLocator() const {
    return m_services->svcLocator();
  }
  inline IUpdateManagerSvc* updMgrSvc(bool create = false) const {
    return m_services->updMgrSvc(create);
  }

  inline MsgStream& log() const  { return *m_log; }

  inline bool isInsideDaughter( const Gaudi::XYZPoint& globalPoint ) const 
  {
    if( !childLoaded() || loadChildren().isFailure() )  return false;
    IGeometryInfo::IGIChildrens::const_iterator it = 
      std::find_if( childBegin() , childEnd  () , 
                    IGeometryInfo_isInside( globalPoint ) ) ;  
    return ( ( childEnd() == it ) ? false : true );
  }
  
  inline bool childLoaded() const { return m_gi_childLoaded ; }

  StatusCode registerSupportGI();

  StatusCode calculateMatrices();

  StatusCode combineMatrices(matrix_iterator deltaFirst,
                             matrix_iterator deltaEnd,
                             matrix_iterator pvFirst,
                             matrix_iterator pvEnd);
  
  StatusCode calculateFullMatrices(matrix_iterator deltaFirst,
                                   matrix_iterator deltaEnd,
                                   matrix_iterator pvFirst);

  void calculateIdealMatrix(matrix_iterator pvFirst,
                            matrix_iterator pvEnd);

  StatusCode setLocalOffNominalDeltaMatrix(const Gaudi::Transform3D& 
                                           newDelta);
  

  StatusCode getAlignmentCondition();

  StatusCode registerCondition();

  void clearMatrices();

  inline bool needsAlignmentCondition() const
  {
    return m_hasAlignmentPath;
  }

  inline void needsAlignmentCondition(const bool& needsAlignment)
  {
    m_hasAlignmentPath = needsAlignment;
  }

  inline bool hasAlignmentCondition() const
  {
    return m_hasAlignment;
  }

  inline void hasAlignmentCondition(const bool& hasAlignment) 
  {
    m_hasAlignment = hasAlignment;
  }

  inline AlignmentCondition* myAlignmentCondition() const 
  {
    return m_alignmentCondition;
  }  

  IDetectorElement* parentIDetectorElement(IDetectorElement* iDetElem) 
  {
    return (0!=iDetElem) ? iDetElem->parentIDetectorElement() : 0; 
  }

  IGeometryInfo* geoByName ( const std::string& name ) const ;

  ILVolume* findLogical() const ; 
  StatusCode loadChildren() const ; 

  inline IDetectorElement* detElem() const { 
    return m_gi_iDetectorElement ;
  }

  inline void Assert( bool assertion, 
                      const std::string& name ) const {
    if( !assertion ) { throw GeometryInfoException( name , this ); }
  }; 
  
  inline void Assert( bool assertion, const std::string& name,
                      const GaudiException& ge ) const {
    if( !assertion ) { throw GeometryInfoException( name , ge , this ); }
  };

  Gaudi::Transform3D* accumulateMatrices(const ILVolume::PVolumePath& volumePath) const;
  


  bool idealMatrixLoaded() { return (0!= m_idealMatrix); }
  
private:

  MsgStream* m_log;

  bool                                 m_gi_has_logical     ;    
  std::string                          m_gi_lvolumeName     ;  
  mutable ILVolume*                    m_gi_lvolume; 

  bool m_hasAlignment;

  std::string m_alignmentPath;

  bool m_hasAlignmentPath;

  AlignmentCondition* m_alignmentCondition;

  mutable Gaudi::Transform3D*              m_matrix;

  mutable Gaudi::Transform3D*              m_idealMatrix;

  mutable Gaudi::Transform3D*              m_localIdealMatrix;
  mutable Gaudi::Transform3D*              m_localDeltaMatrix;

  mutable Gaudi::Transform3D*              m_matrixInv;
  mutable Gaudi::Transform3D*              m_idealMatrixInv;

  bool                                 m_gi_has_support     ; 
  std::string                          m_gi_supportName     ;   
  mutable IGeometryInfo*               m_gi_support         ;  
  mutable ILVolume::ReplicaPath        m_gi_supportPath     ;   
  std::string                          m_gi_supportNamePath ;   
  //
  mutable IDetectorElement*            m_gi_iDetectorElement ;

  mutable bool                         m_gi_parentLoaded   ;
  mutable IGeometryInfo*               m_gi_parent         ; 
  mutable bool                         m_gi_childLoaded    ;
  mutable IGeometryInfo::IGIChildrens  m_gi_childrens      ;
  mutable GeometryInfoPlus::ChildName      m_gi_childrensNames ;
  
  static unsigned long m_count;
  
  DetDesc::Services* m_services;

  std::vector<Gaudi::Transform3D> m_pvMatrices;
  std::vector<Gaudi::Transform3D> m_deltaMatrices;

  
  bool                                 m_has_condition     ; 
  std::string                          m_gi_condPath     ;


  inline matrix_iterator idealBegin() const
  {
    return m_pvMatrices.begin();
  }
  
  inline matrix_iterator idealEnd() const
  {
    return m_pvMatrices.end();
  }

  inline matrix_iterator deltaBegin() const
  {
    return m_deltaMatrices.begin();
  }
  
  inline matrix_iterator deltaEnd() const
  {
    return m_deltaMatrices.end();
  }
};
#endif // LIB_GEOMETRYINFOPLUS_H

---