In This Package:

SolidTicks.h

Go to the documentation of this file.

// $Id: SolidTicks.h,v 1.14 2007/09/20 15:41:06 wouter Exp $ 
// ===========================================================================
#ifndef     DETDESC_SOLIDTICKS_H
#define     DETDESC_SOLIDTICKS_H 1 
#include <cmath>
#include <functional>
#include <algorithm>
// Geometry includes 
#include "GaudiKernel/Point3DTypes.h"
#include "GaudiKernel/Vector3DTypes.h"
#include "GaudiKernel/Plane3DTypes.h"
// DetDesc includes 
#include "DetDesc/ISolid.h" 
#include "DetDesc/SolidMath.h" 

namespace SolidTicks
{
  
  template <class SOLID, class aPoint, class aVector>
  inline unsigned int  
  RemoveAdjancent
  ( ISolid::Ticks     & ticks , 
    const aPoint      & point , 
    const aVector     & vect  , 
    const SOLID       & solid )
  {
    // local typedefs 
    typedef std::vector<size_t>     Indexes  ; 
    typedef ISolid::Tick            Tick     ; 
    typedef ISolid::Ticks::iterator iterator ;
    // no abjancent ?
    if     ( ticks.size() <  2 ) { ticks.clear() ;    return 0 ; }    // RETURN
    else if( ticks.size() == 2 ) 
      {
        Tick tick1 = ticks.front () ;           // first tick
        Tick tick2 = ticks.back  () ;           // last  tick 
        Tick tick  = 0.5 * ( tick1 + tick2 ) ;  // middle tick
        if( solid.isInside( point + vect * tick ) ) { return 2 ; } // RETURN 
        else                        { ticks.clear() ; return 0 ; } // RETURN 
      }  
    // perform removing of adjancent  ticks
    Indexes tmp              ; 
    Tick    tickNext = 0.0   ;
    Tick    tickPrev = 0.0   ; 
    bool    boolPrev = true  ; 
    bool    boolNext = true  ; 
    for ( iterator it = ticks.begin() ; it != ticks.end() ; ++it ) 
      {
        // the last point is to be treated in a specific way
        if     ( ticks.end   () != it + 1 ) 
          { tickNext = 0.5 * ( (*it) + *(it+1) ) ; 
          boolNext = solid.isInside( point + vect * tickNext );  }  
        // get the index 
        unsigned int index = it - ticks.begin();                       
        if      ( ticks.end  () == it + 1 ) 
          { if( !boolPrev             ) { tmp.push_back( index ) ; } }
        else if ( ticks.begin() == it     ) 
          { if( !boolNext             ) { tmp.push_back( index ) ; } }
        else                                
          { if(  boolPrev == boolNext ) { tmp.push_back( index ) ; } }
        boolPrev = boolNext; 
        tickPrev = tickNext;
      }
    // remove ticks (from the end!)
    Indexes::reverse_iterator cri = tmp.rbegin();
    while( cri != tmp.rend() ) { ticks.erase( ticks.begin() + *cri++ );  }  
    // get the final answer 
    return ticks.size();
  };
  
  template <class SOLID, class aPoint, class aVector>
  inline unsigned int  
  RemoveAdjancentTicks
  ( ISolid::Ticks     & ticks , 
    const aPoint  & point , 
    const aVector & vect  , 
    const SOLID       & solid )
  {
    //     useful local typedefs 
    typedef ISolid::Tick            Tick     ; 
    typedef ISolid::Ticks::iterator iterator ;
    // (1) sort container  
    std::sort( ticks.begin() , ticks.end() ) ; 
    // (2) eliminate duplicates and (3) shrink container 
    ticks.erase( std::unique( ticks.begin() , ticks.end() )  , ticks.end() ); 
    // remove adjancent 
    return RemoveAdjancent( ticks , point , vect , solid );
  };


  template <class SOLID, class aPoint, class aVector>
  inline unsigned int  
  RemoveAdjancentTicks
  ( ISolid::Ticks      & ticks   ,
    const aPoint   & point   , 
    const aVector  & vect    , 
    const ISolid::Tick & tickMin , 
    const ISolid::Tick & tickMax , 
    const SOLID        & solid   )
  {
    // useful local typedefs 
    typedef ISolid::Tick            Tick     ; 
    typedef ISolid::Ticks::iterator iterator ;
    // valid arguments? 
    if( tickMin >= tickMax ) { ticks.clear();            return 0 ; } // RETURN
    // remove all garbage what is  less than 'tickMin' 
    iterator itMin = 
      std::remove_if( ticks.begin () ,
                      ticks.end   () ,  
                      std::bind2nd( std::less<Tick>    () , tickMin ) );
    // remove all garbage what is  larger than 'tickMax' 
    iterator itMax = 
      std::remove_if( ticks.begin () , 
                      itMin          , 
                      std::bind2nd( std::greater<Tick> () , tickMax ) );
    ticks.erase  ( itMax , ticks.end() ) ;
    
    // empty ticks! 
    if( ticks.empty() )
      {
        const Tick middle = 0.5 * ( tickMin + tickMax ) ;
        if( solid.isInside(  point  + middle * vect ) ) 
          {
            ticks.push_back( tickMin ) ; 
            ticks.push_back( tickMax ) ; 
          }
        return ticks.size() ;
      }
    
    // first tick 
    if( ticks.front () != tickMin ) 
      { 
        const Tick middle  = 0.5 * ( tickMin      + ticks.front() ) ;
        if( solid.isInside   ( point + middle * vect ) )
          { ticks.insert     ( ticks.begin() , tickMin ) ; }
      }
    
    // last tick 
    if( ticks.back  () != tickMax ) 
      { 
        const Tick middle  = 0.5 * ( ticks.back() +  tickMax ) ;
        if( solid.isInside   ( point + middle * vect ) )
          { ticks.push_back  (                 tickMax ) ; }
      }
    // adjancent are already removed 
    return ticks.size () ;
  };
  
  template <class SOLID, class aPoint, class aVector, class TickContainer>
  inline unsigned int RemoveAdjacentTicksFast ( TickContainer & ticks , 
                                                const aPoint  & point , 
                                                const aVector & vect  , 
                                                const SOLID   & solid )
  {
    // only call the expensive method if we find that something is wrong:
    typename TickContainer::iterator newend  = std::unique( ticks.begin() , ticks.end() ) ;
    if( newend != ticks.end() || ticks.size()%2 != 0 ) {
      ticks.erase( newend, ticks.end()) ;
      RemoveAdjancent( ticks , point , vect , solid );
    }
    return ticks.size() ;
  } ;

  template <class TickContainer>
  unsigned int adjustToTickRange( TickContainer& ticks, const ISolid::Tick & tickMin, const ISolid::Tick & tickMax ) 
  {
    // useful local typedefs 
    typedef ISolid::Tick            Tick     ; 
    typedef ISolid::Ticks::iterator iterator ;
    if( !ticks.empty() ) {
      static ISolid::Ticks validticks ; validticks.clear() ;
      // explicitely use that ticks come in pairs
      for( typename TickContainer::const_iterator it = ticks.begin() ; it+1 < ticks.end(); it +=2) 
        if( *it <= tickMax && *(it+1) >= tickMin ) {
          validticks.push_back( std::max( tickMin, *it) ) ;
          validticks.push_back( std::min( tickMax, *(it+1)) ) ;
        }
      ticks.swap(validticks) ;
    }
    return ticks.size () ;
  };

}; 

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

---