RodPlaneBuilderFromDet Class Reference

#include <RodPlaneBuilderFromDet.h>

Public Types
typedef GeomDet	Det

Public Member Functions
std::pair< RectangularPlaneBounds *, GlobalVector >	computeBounds (const std::vector< const Det *> &dets, const Plane &plane) const
Surface::RotationType	computeRotation (const std::vector< const Det *> &dets, const Surface::PositionType &meanPos) const
Plane *	operator() (const std::vector< const Det *> &dets) const

Detailed Description

Builds the minimal rectangular box that contains all input Dets fully.

Definition at line 15 of file RodPlaneBuilderFromDet.h.

Member Typedef Documentation

Det

typedef GeomDet RodPlaneBuilderFromDet::Det

Definition at line 17 of file RodPlaneBuilderFromDet.h.

Member Function Documentation

computeBounds()

pair< RectangularPlaneBounds *, GlobalVector > RodPlaneBuilderFromDet::computeBounds	(	const std::vector< const Det *> &	dets,
		const Plane &	plane
	)		const

Definition at line 33 of file RodPlaneBuilderFromDet.cc.

References BoundingBox::corners(), mps_fire::i, hltrates_dqm_sourceclient-live_cfg::offset, AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, Surface::toGlobal(), GloballyPositioned< T >::toLocal(), TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, L1TOccupancyClient_cfi::ymax, L1TOccupancyClient_cfi::ymin, SiStripMonitorCluster_cfi::zmax, and SiStripMonitorCluster_cfi::zmin.

                                                                                                            {
  // go over all corners and compute maximum deviations from mean pos.
  vector<GlobalPoint> corners;
  for (vector<const Det*>::const_iterator idet = dets.begin(); idet != dets.end(); idet++) {
    /* ---- original implementation. Is it obsolete?
    vector<const DetUnit*> detUnits = (**idet).basicComponents();
    for (vector<const DetUnit*>::const_iterator detu=detUnits.begin();
     detu!=detUnits.end(); detu++) {
      vector<GlobalPoint> dc = 
    BoundingBox().corners((**detu).specificSurface());
      corners.insert( corners.end(), dc.begin(), dc.end());
    }
    ---- */

    // temporary implementation (May be the final one if the GluedDet surface
    // really contains both the mono and the stereo surfaces
    vector<GlobalPoint> dc = BoundingBox().corners((**idet).specificSurface());
    corners.insert(corners.end(), dc.begin(), dc.end());
  }

  float xmin(0), xmax(0), ymin(0), ymax(0), zmin(0), zmax(0);
  for (vector<GlobalPoint>::const_iterator i = corners.begin(); i != corners.end(); i++) {
    LocalPoint p = plane.toLocal(*i);
    if (p.x() < xmin)
      xmin = p.x();
    if (p.x() > xmax)
      xmax = p.x();
    if (p.y() < ymin)
      ymin = p.y();
    if (p.y() > ymax)
      ymax = p.y();
    if (p.z() < zmin)
      zmin = p.z();
    if (p.z() > zmax)
      zmax = p.z();
  }

  LocalVector localOffset((xmin + xmax) / 2., (ymin + ymax) / 2., (zmin + zmax) / 2.);
  GlobalVector offset(plane.toGlobal(localOffset));

  pair<RectangularPlaneBounds*, GlobalVector> result(
      new RectangularPlaneBounds((xmax - xmin) / 2, (ymax - ymin) / 2, (zmax - zmin) / 2), offset);

  return result;
}

computeRotation()

Surface::RotationType RodPlaneBuilderFromDet::computeRotation	(	const std::vector< const Det *> &	dets,
		const Surface::PositionType &	meanPos
	)		const

Definition at line 80 of file RodPlaneBuilderFromDet.cc.

References Vector3DBase< T, FrameTag >::cross(), dqmiodumpmetadata::n, Surface::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), HLT_2024v14_cff::xAxis, PV3DBase< T, PVType, FrameType >::y(), HLT_2024v14_cff::yAxis, and PV3DBase< T, PVType, FrameType >::z().

                                                                                                        {
  // choose first mono out-pointing rotation
  // the rotations of GluedDets coincide with the mono part
  // Simply take the x,y of the first Det if z points out,
  // or -x, y if it doesn't
  const Plane& plane = dynamic_cast<const Plane&>(dets.front()->surface());
  //GlobalVector n = plane.normalVector();

  GlobalVector xAxis;
  GlobalVector yAxis;
  GlobalVector planeYAxis = plane.toGlobal(LocalVector(0, 1, 0));
  if (planeYAxis.z() < 0)
    yAxis = -planeYAxis;
  else
    yAxis = planeYAxis;

  GlobalVector planeXAxis = plane.toGlobal(LocalVector(1, 0, 0));
  GlobalVector n = planeXAxis.cross(planeYAxis);

  if (n.x() * meanPos.x() + n.y() * meanPos.y() > 0) {
    xAxis = planeXAxis;
  } else {
    xAxis = -planeXAxis;
  }

  //   LogDebug("DetLayers") << "Creating rotation with x,y axis "
  //        << xAxis << ", " << yAxis ;

  return Surface::RotationType(xAxis, yAxis);
}

operator()()

Plane * RodPlaneBuilderFromDet::operator()

(

const std::vector< const Det *> &

dets

)

const

Warning, remember to assign this pointer to a ReferenceCountingPointer! Should be changed to return a ReferenceCountingPointer<Plane>

Definition at line 10 of file RodPlaneBuilderFromDet.cc.

References mps_fire::i, and idealTransformation::rotation.

                                                                              {
  // find mean position
  typedef Surface::PositionType::BasicVectorType Vector;
  Vector posSum(0, 0, 0);
  for (vector<const Det*>::const_iterator i = dets.begin(); i != dets.end(); i++) {
    posSum += (**i).surface().position().basicVector();
  }
  Surface::PositionType meanPos(posSum / float(dets.size()));

  // temporary plane - for the computation of bounds
  Surface::RotationType rotation = computeRotation(dets, meanPos);
  Plane tmpPlane(meanPos, rotation);
  auto bo = computeBounds(dets, tmpPlane);

  //   LogDebug("DetLayers") << "Creating plane at position " << meanPos
  //        << " displaced by " << bo.second ;
  //   LogDebug("DetLayers") << "Bounds are (wid/len/thick) " << bo.first.width()
  //        << " / " <<  bo.first.length()
  //        << " / " <<  bo.first.thickness() ;

  return new Plane(meanPos + bo.second, rotation, bo.first);
}