TrackerShapeToBounds Class Reference

#include <TrackerShapeToBounds.h>

Public Member Functions
Bounds *	buildBounds (const cms::DDSolidShape &, const std::vector< double > &) const

Private Member Functions
Bounds *	buildBox (const std::vector< double > &) const
Bounds *	buildOpen () const
Bounds *	buildTrap (const std::vector< double > &) const

Detailed Description

Converts DDSolid volumes to Bounds

Definition at line 11 of file TrackerShapeToBounds.h.

Member Function Documentation

Bounds * TrackerShapeToBounds::buildBounds	(	const cms::DDSolidShape &	shape,
		const std::vector< double > &	par
	)		const

buildBounds() return the Bounds.

Definition at line 32 of file TrackerShapeToBounds.cc.

References buildBox(), buildOpen(), buildTrap(), gather_cfg::cout, cms::ddbox, cms::ddpolycone, cms::DDSolidShapeMap, cms::ddsubtraction, cms::ddtrap, cms::ddtubs, and cms::dd::name().

Referenced by GeometricDet::bounds(), and GeometricTimingDet::bounds().

                                                                                                          {
  switch (shape) {
    case cms::DDSolidShape::ddbox:
      return buildBox(par);
      break;
    case cms::DDSolidShape::ddtrap:
      return buildTrap(par);
      break;
    case cms::DDSolidShape::ddtubs:
    case cms::DDSolidShape::ddpolycone:
    case cms::DDSolidShape::ddsubtraction:
      return buildOpen();
      break;
    default:
      std::cout << "Wrong DDshape to build...." << cms::dd::name(cms::DDSolidShapeMap, shape) << std::endl;
      Bounds* bounds = nullptr;
      return bounds;
  }
}

Bounds * TrackerShapeToBounds::buildBox ( const std::vector< double > &  paras ) const

private

Definition at line 52 of file TrackerShapeToBounds.cc.

Referenced by buildBounds().

                                                                           {
  int indexX = 0;
  int indexY = 1;
  int indexZ = 2;
  Bounds* bounds = nullptr;

  if (paras[1] < paras[0] && paras[0] < paras[2]) {
    indexX = 0;
    indexY = 2;
    indexZ = 1;
  }

  bounds = new RectangularPlaneBounds(paras[indexX] / cm,   // width - shorter side
                                      paras[indexY] / cm,   // length - longer side
                                      paras[indexZ] / cm);  // thickness
  return bounds;
}

Bounds * TrackerShapeToBounds::buildOpen ( ) const

private

Definition at line 105 of file TrackerShapeToBounds.cc.

Referenced by buildBounds().

                                              {
  OpenBounds* bounds = new OpenBounds();
  return bounds;
}

Bounds * TrackerShapeToBounds::buildTrap ( const std::vector< double > &  paras ) const

private

Definition at line 70 of file TrackerShapeToBounds.cc.

Referenced by buildBounds().

                                                                            {
  Bounds* bounds = nullptr;
  /*
    TrapezoidalPlaneBounds (float be, float te, float a, float t)
    constructed from:
    half bottom edge (smaller side width)
    half top edge (larger side width)
    half apothem (distance from top to bottom sides, measured perpendicularly to them)
    half thickness.
    
    if  we have indexX=0, indexY=1 and indeZ=2
    4 = be (ORCA x)
    9 = te (ORCA x)
    0 = a (ORCA y)
    3 = t (ORCA z)

    if  we have indexX=0, indexY=2 and indeZ=1
    4 = be (ORCA x)
    9 = te (ORCA x)
    3 = a (ORCA y)
    0 = t (ORCA z)

    so, so we have the indexes:
    if indexX==0, indexY==1, indexZ==2, then everything is ok and
    the following orcaCorrection-rotation will be a unit-matrix.
  */

  if (paras[0] < 5) {
    bounds = new TrapezoidalPlaneBounds(paras[4] / cm, paras[9] / cm, paras[3] / cm, paras[0] / cm);
  } else if (paras[0] > paras[3]) {
    bounds = new TrapezoidalPlaneBounds(paras[4] / cm, paras[9] / cm, paras[0] / cm, paras[3] / cm);
  }
  return bounds;
}