ISurface.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : F.Gaede
//
//==========================================================================
#ifndef DDREC_ISURFACE_H
#define DDREC_ISURFACE_H
 
 
#include "DDRec/IMaterial.h"
#include "DDRec/Vector2D.h"
#include "DDRec/Vector3D.h"
 
#include <bitset>
#include <cmath>
 
namespace dd4hep { namespace rec {
  
  class SurfaceType ;
 
  typedef long long int long64 ;
 
 
  class ISurface {
    
  public:
    virtual ~ISurface() {}
    
    virtual const SurfaceType& type() const =0 ;
    
    virtual long64 id() const =0 ;
 
    virtual bool insideBounds(const Vector3D& point, double epsilon=1.e-4) const =0 ;
    
    virtual Vector3D u( const Vector3D& point = Vector3D() ) const =0 ;
    
    virtual Vector3D v(const Vector3D& point = Vector3D() ) const =0 ;
    
    virtual Vector3D normal(const Vector3D& point = Vector3D() ) const =0 ;
    
    virtual Vector2D globalToLocal( const Vector3D& point) const=0 ;
 
    virtual Vector3D localToGlobal( const Vector2D& point) const=0 ;
 
    virtual const Vector3D& origin() const =0 ;
    
    virtual const IMaterial& innerMaterial() const =0 ;
    
    virtual const IMaterial& outerMaterial() const =0 ;
    
    virtual double innerThickness() const =0 ;
    
    virtual double outerThickness() const =0 ;
    
    virtual double distance(const Vector3D& point ) const =0 ;
    
    virtual double length_along_u() const=0 ;
    
    virtual double length_along_v() const=0 ;
 
  } ;
  
  //==============================================================================================
  class ICylinder {
    
  public:
    virtual ~ICylinder() {}
    virtual double radius() const=0 ;
    virtual Vector3D center() const=0 ;
  };
  //==============================================================================================
  class ICone {
    
  public:
    virtual ~ICone() {}
    virtual double radius0() const=0 ;
    virtual double radius1() const=0 ;
    virtual double z0() const=0 ;
    virtual double z1() const=0 ;
    virtual Vector3D center() const=0 ;
  };
  
  //==============================================================================================
  
  class SurfaceType{
  
  public:
    enum SurfaceTypes {
      Cylinder = 0,
      Plane,
      Sensitive,
      Helper,
      ParallelToZ,
      OrthogonalToZ,
      Invisible,
      Measurement1D,
      Cone,
      Unbounded
    } ;
    
    SurfaceType() : _bits(0) {}
 
    // c'tor that sets one property
    SurfaceType( unsigned prop0 ) : _bits(0) { 
      _bits.set( prop0 ) ;
    } 
    
    // c'tor that sets two properties
    SurfaceType( unsigned prop0 , unsigned prop1 ) : _bits(0) { 
      _bits.set( prop0 ) ;
      _bits.set( prop1 ) ;
    } 
    
    // c'tor that sets three properties
    SurfaceType( unsigned prop0 , unsigned prop1 , unsigned prop2 ) : _bits(0) { 
      _bits.set( prop0 ) ;
      _bits.set( prop1 ) ;
      _bits.set( prop2 ) ;
    } 
    
    // c'tor that sets four properties
    SurfaceType( unsigned prop0 , unsigned prop1 , unsigned prop2, unsigned prop3 ) : _bits(0) { 
      _bits.set( prop0 ) ;
      _bits.set( prop1 ) ;
      _bits.set( prop2 ) ;
      _bits.set( prop3 ) ;
    } 
 
   // c'tor that sets five properties
    SurfaceType( unsigned prop0 , unsigned prop1 , unsigned prop2, unsigned prop3, unsigned prop4 ) : _bits(0) { 
      _bits.set( prop0 ) ;
      _bits.set( prop1 ) ;
      _bits.set( prop2 ) ;
      _bits.set( prop3 ) ;
      _bits.set( prop4 ) ;
    } 
    
    void setProperty( unsigned prop , bool val = true ) { _bits.set( prop , val ) ;  } 
    
    bool isSensitive() const { return _bits[ SurfaceType::Sensitive ] ; }
    
    bool isHelper() const  { return _bits[ SurfaceType::Helper ] ; }
    
    bool isPlane() const { return _bits[ SurfaceType::Plane ] ; } 
    
    bool isCylinder() const { return _bits[ SurfaceType::Cylinder ] ; } 
 
    bool isCone() const { return _bits[ SurfaceType::Cone ] ; } 
 
    bool isParallelToZ() const { return _bits[ SurfaceType::ParallelToZ ] ; } 
 
    bool isOrthogonalToZ() const { return _bits[ SurfaceType::OrthogonalToZ ] ; } 
   
    bool isVisible() const { return ! _bits[ SurfaceType::Invisible ] ; } 
 
    bool isZCylinder() const  { return ( _bits[ SurfaceType::Cylinder ] &&  _bits[ SurfaceType::ParallelToZ ] ) ; } 
 
    bool isZCone() const  { return ( _bits[ SurfaceType::Cone ] &&  _bits[ SurfaceType::ParallelToZ ] ) ; } 
 
    bool isZPlane() const  { return ( _bits[ SurfaceType::Plane ] &&  _bits[ SurfaceType::ParallelToZ ] ) ; 
    } 
    
    bool isZDisk() const  { return ( _bits[ SurfaceType::Plane ] &&  _bits[ SurfaceType::OrthogonalToZ ] ) ; } 
 
    bool isMeasurement1D() const { return _bits[ SurfaceType::Measurement1D ] ; } 
 
 
    bool isUnbounded() const { return  _bits[ SurfaceType::Unbounded ] ; } 
 
    bool isSimilar( const SurfaceType& otherType) const {
      unsigned long otherBits = otherType._bits.to_ulong() ;
      unsigned long theseBits = _bits.to_ulong() ;
            //      std::cout << " ** isSimilar : " << otherType._bits.to_string() << " - " << _bits.to_string() << " : " <<  ((  otherBits & theseBits ) == otherBits) << std::endl ;
      return (  otherBits & theseBits ) == otherBits ;
    }
 
 
    bool checkParallelToZ( const ISurface& surf , double epsilon=1.e-6 ) const { 
      
      // if ( _bits[ SurfaceType::ParallelToZ ] ) // set in specific implementation
      //    return true ;
 
      double proj = std::fabs( surf.normal() * Vector3D(0.,0.,1.) )  ;
      
      _bits.set(  SurfaceType::ParallelToZ , ( proj < epsilon )  ) ;
      
      // std::cout << " ** checkParallelToZ() - normal : " <<  surf.normal() << " pojection : " << proj 
      //        << " _bits[ SurfaceType::ParallelToZ ] = " <<  bool( _bits[ SurfaceType::ParallelToZ ] )
      //        << "  ( std::fabs( proj - 1. ) < epsilon )  ) = " <<   ( proj < epsilon ) << std::endl ;
 
      return  _bits[ SurfaceType::ParallelToZ ] ;
    }
 
    bool checkOrthogonalToZ( const ISurface& surf , double epsilon=1.e-6 ) const { 
      
     // if ( _bits[ SurfaceType::OrthogonalToZ ] ) // set in specific implementation
     //     return true ;
 
      double proj = std::fabs( surf.normal() * Vector3D(0.,0.,1.) )  ;
      
      _bits.set(  SurfaceType::OrthogonalToZ , ( std::fabs( proj - 1. ) < epsilon )  ) ;
      
      // std::cout << " ** checkOrthogonalToZ() - normal : " <<  surf.normal() << " pojection : " << proj 
      //        << " _bits[ SurfaceType::OrthogonalToZ ] = " << bool( _bits[ SurfaceType::OrthogonalToZ ] ) 
      //        << "  ( std::fabs( proj - 1. ) < epsilon )  ) = " <<  ( std::fabs( proj - 1. ) < epsilon ) << std::endl ;
 
 
      return  _bits[ SurfaceType::OrthogonalToZ ] ;
    }
 
 
  protected:
 
    mutable std::bitset<32> _bits ;
  } ;
 
  inline std::ostream& operator<<( std::ostream& os , const SurfaceType& t ) {
 
    os << "sensitive["       << t.isSensitive() 
       << "] helper["        << t.isHelper() 
       << "] plane["         << t.isPlane()  
       << "] cylinder["      << t.isCylinder()  
       << "] cone["          << t.isCone()  
       << "] parallelToZ["   << t.isParallelToZ()  
       << "] orthogonalToZ[" << t.isOrthogonalToZ()  
       << "] zCylinder["     << t.isZCylinder() 
       << "] zCone["         << t.isZCone() 
       << "] zPlane["        << t.isZPlane()  
       << "] zDisk["         << t.isZDisk()
       << "] unbounded["     << t.isUnbounded()
       << "]"  ; 
 
    return os ;
  }
 
 
 
  inline std::ostream& operator<<( std::ostream& os , const ISurface& s ) {
    
    os <<  "   id: " << std::hex << s.id() << std::dec << " type : " << s.type() << std::endl  
       <<  "   u : " << s.u() << " v : " << s.v() << " normal : " << s.normal() << " origin : " << s.origin() << std::endl   ;
    os <<  "   inner material : " << s.innerMaterial() << "  thickness: " <<  s.innerThickness()  << std::endl  
       <<  "   outerMaterial :  " << s.outerMaterial() << "  thickness: " <<  s.outerThickness()  << std::endl   ;
 
    const ICylinder* cyl = dynamic_cast< const ICylinder* > ( &s ) ;
    if( cyl )
      os << "   cylinder radius : " << cyl->radius() <<  std::endl   ;
 
    const ICone* cone = dynamic_cast< const ICone* > ( &s ) ;
    if( cone )
      os << "   cone radius0: " << cone->radius0() << "   cone radius1: " << cone->radius1()  <<  std::endl   ;
 
    return os ;
  }
 
 
} } /* namespace rec */
 
 
 
#endif // DDREC_ISURFACE_H