BevelledCylinderVolumeBounds.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/

// BevelledCylinderVolumeBounds.h, (c) ATLAS Detector software
 
#ifndef TRKVOLUMES_BEVELLEDCYLINDERVOLUMESBOUNDS_H
#define TRKVOLUMES_BEVELLEDCYLINDERVOLUMESBOUNDS_H
 
// Trk
#include "TrkVolumes/VolumeBounds.h"
#include "TrkVolumes/BevelledCylinderVolumeBoundaryAccessors.h"
// Eigen
#include "GeoPrimitives/GeoPrimitives.h"
#include "CxxUtils/CachedUniquePtr.h"
 
class MsgStream;
 
 
namespace Trk {

   struct BevelledBoundaryIntersector {
 
   double yOfX;            
   double segLength;      
 
    BevelledBoundaryIntersector(double px, double py, double k, double xprime) {
      double deltax = xprime-px;
      yOfX = py + k*(deltax);
      double deltay = yOfX-py;
      segLength = sqrt(deltax*deltax+deltay*deltay);
    }
 
   };
 
   class Surface;
   class EllipseBounds;
   class TrapezoidBounds;
   class RectangleBounds;
   class CylinderBounds;
   class DiscBounds;

 
 class BevelledCylinderVolumeBounds final : public VolumeBounds {
 
  public:
    BevelledCylinderVolumeBounds();

    BevelledCylinderVolumeBounds(double rinner, double router, double halfPhiSector, double halez, int type);

    BevelledCylinderVolumeBounds(const BevelledCylinderVolumeBounds& cylbo);

    virtual ~BevelledCylinderVolumeBounds();

    BevelledCylinderVolumeBounds& operator=(const BevelledCylinderVolumeBounds& cylbo);

    BevelledCylinderVolumeBounds* clone() const override;

    bool inside(const Amg::Vector3D& , double tol=0.) const override;

    virtual std::vector<std::unique_ptr<Trk::Surface>> decomposeToSurfaces (const Amg::Transform3D& transform) override;

    ObjectAccessor boundarySurfaceAccessor(const Amg::Vector3D& gp,
                                           const Amg::Vector3D& dir,
                                           bool forceInside=false) const override;

    double innerRadius() const;

    double outerRadius() const;

    double mediumRadius() const;

    double deltaRadius() const;

    double halfPhiSector() const;

    double halflengthZ() const;

    double thetaMinus() const;

    double thetaPlus() const;

    int type() const;

    MsgStream& dump(MsgStream& sl) const override;

    std::ostream& dump(std::ostream& sl) const override;
 
  private:
    std::shared_ptr<CylinderBounds> innerBevelledCylinderBounds() const;
    std::shared_ptr<CylinderBounds> outerBevelledCylinderBounds() const;
    std::shared_ptr<RectangleBounds> innerBevelledPlaneBounds() const;
    std::shared_ptr<RectangleBounds> outerBevelledPlaneBounds() const;
    std::shared_ptr<EllipseBounds> bottomEllipseBounds() const;
    std::shared_ptr<EllipseBounds> topEllipseBounds() const;
    std::shared_ptr<CylinderBounds> innerCylinderBounds() const;
    std::shared_ptr<CylinderBounds> outerCylinderBounds() const;
    std::shared_ptr<DiscBounds> discBounds() const;
    Volume* subtractedVolume() const;
    std::shared_ptr<TrapezoidBounds> sectorTrdBounds() const;
    std::shared_ptr<RectangleBounds> sectorPlaneBounds() const;
    void createBoundarySurfaceAccessors();
 
#ifdef TRKDETDESCR_USEFLOATPRECISON
#define double float
#endif
    double m_innerRadius;
    double m_outerRadius;
    double m_halfPhiSector;
    double m_halfZ;
    double m_thetaMinus;
    double m_thetaPlus;
    int    m_type;
#ifdef TRKDETDESCR_USEFLOATPRECISON
#undef double
#endif

    BevelledCylinderVolumeBoundaryAccessors            m_boundaryAccessors;

    static const double s_numericalStable;
 
    CxxUtils::CachedUniquePtr<Trk::Volume> m_subtractedVolume;
 };
 
 inline BevelledCylinderVolumeBounds* BevelledCylinderVolumeBounds::clone() const
 { return new BevelledCylinderVolumeBounds(*this); }
 
 inline bool BevelledCylinderVolumeBounds::inside(const Amg::Vector3D &pos, double tol) const
 {
   double ros = pos.perp();
   bool insidePhi =  fabs(pos.phi()) <= m_halfPhiSector + tol;
   double cphi = cos(pos.phi());
   bool insideR = insidePhi;
   if (m_type < 1)  insideR  = insidePhi ? ((ros >=  m_innerRadius - tol ) && (ros <= m_outerRadius + tol)) : false;
   else if (m_type == 1 ) insideR = insidePhi ? ((ros>= m_innerRadius/cphi-tol)&&(ros<=m_outerRadius+tol)):false;
   else if (m_type == 2 ) insideR = insidePhi ? ((ros>= m_innerRadius-tol)&&(ros<=m_outerRadius/cphi+tol)):false;
   else if (m_type == 3 ) insideR = insidePhi ? ((ros>= m_innerRadius/cphi-tol)&&(ros<=m_outerRadius/cphi+tol)):false;
//   bool insideZ = insideR ? (fabs(pos.z()) <= m_halfZ + tol ) : false ;
   bool insideZ = insideR ? ((pos.z()<=m_halfZ-(pos.x()+m_outerRadius)*tan(m_thetaPlus) + tol)
                 && ( pos.z()>=-m_halfZ+(pos.x()+m_outerRadius)*tan(m_thetaMinus) - tol)) : false ;
 
   return insideZ;
 }
 
 inline double BevelledCylinderVolumeBounds::innerRadius() const { return m_innerRadius; }
 inline double BevelledCylinderVolumeBounds::outerRadius() const { return m_outerRadius; }
 inline double BevelledCylinderVolumeBounds::mediumRadius() const { return 0.5*(m_innerRadius+m_outerRadius); }
 inline double BevelledCylinderVolumeBounds::deltaRadius() const { return (m_outerRadius-m_innerRadius); }
 inline double BevelledCylinderVolumeBounds::halfPhiSector() const { return m_halfPhiSector; }
 inline double BevelledCylinderVolumeBounds::halflengthZ() const { return m_halfZ; }
 inline double BevelledCylinderVolumeBounds::thetaMinus() const { return m_thetaMinus; }
 inline double BevelledCylinderVolumeBounds::thetaPlus() const { return m_thetaPlus; }
 inline int BevelledCylinderVolumeBounds::type() const { return m_type; }
 
 
}
 
 
#endif // TRKVOLUMES_BEVELLEDCYLINDERVOLUMESBOUNDS_H