FastTimeGeometryLoader Class Reference

#include <FastTimeGeometryLoader.h>

Public Types
typedef CaloCellGeometry::CCGFloat	CCGFloat
typedef std::vector< float >	ParmVec

Public Member Functions
FastTimeGeometry *	build (const FastTimeTopology &)
	FastTimeGeometryLoader ()
	~FastTimeGeometryLoader ()

Private Member Functions
void	buildGeom (const ParmVec &, const HepGeom::Transform3D &, const DetId &, const FastTimeTopology &, FastTimeGeometry *)

Detailed Description

Definition at line 8 of file FastTimeGeometryLoader.h.

Member Typedef Documentation

CCGFloat

typedef CaloCellGeometry::CCGFloat FastTimeGeometryLoader::CCGFloat

Definition at line 10 of file FastTimeGeometryLoader.h.

ParmVec

typedef std::vector<float> FastTimeGeometryLoader::ParmVec

Definition at line 11 of file FastTimeGeometryLoader.h.

Constructor & Destructor Documentation

FastTimeGeometryLoader()

FastTimeGeometryLoader::FastTimeGeometryLoader

(

)

Definition at line 16 of file FastTimeGeometryLoader.cc.

{}

~FastTimeGeometryLoader()

FastTimeGeometryLoader::~FastTimeGeometryLoader

(

)

Definition at line 17 of file FastTimeGeometryLoader.cc.

{}

Member Function Documentation

build()

FastTimeGeometry * FastTimeGeometryLoader::build

(

const FastTimeTopology &

topology

)

Definition at line 19 of file FastTimeGeometryLoader.cc.

References cms::cuda::assert(), buildGeom(), counter, FastTimeTopology::dddConstants(), FastTimeTopology::detectorType(), relativeConstraints::geom, FastTimeDDDConstants::getRin(), FastTimeDDDConstants::getRout(), FastTimeDDDConstants::getZHalf(), FastTimeDDDConstants::getZPos(), FastTimeGeometry::k_NumberOfParametersPerShape, FastTimeGeometry::k_NumberOfShapes, submitPVValidationJobs::params, idealTransformation::rotation, FastTimeTopology::subDetector(), FastTimeTopology::totalGeomModules(), ecaldqm::zside(), and gpuVertexFinder::zv.

Referenced by FastTimeGeometryESProducer::produce().

                                                                                {
  // allocate geometry
  FastTimeGeometry* geom = new FastTimeGeometry(topology);
  unsigned int numberOfCells = topology.totalGeomModules();  // both sides
  int detType = topology.detectorType();
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("FastTimeGeom") << "Number of Cells " << numberOfCells << " for type " << detType
                                   << " of sub-detector " << topology.subDetector() << " Shape parameters "
                                   << FastTimeGeometry::k_NumberOfShapes << ":"
                                   << FastTimeGeometry::k_NumberOfParametersPerShape;
#endif
  geom->allocateCorners(numberOfCells);
  geom->allocatePar(FastTimeGeometry::k_NumberOfShapes, FastTimeGeometry::k_NumberOfParametersPerShape);

  // loop over modules
  ParmVec params(FastTimeGeometry::k_NumberOfParametersPerShape, 0);
  unsigned int counter(0);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("FastTimeGeom") << "FastTimeGeometryLoader with # of transformation matrices " << numberOfCells;
#endif
  for (unsigned itr = 0; itr < numberOfCells; ++itr) {
    int zside = (itr == 0) ? 1 : -1;
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("FastTimeGeom") << "FastTimeGeometryLoader:: Z:Layer:Type " << zside << ":" << detType;
#endif
    double zv = zside * (topology.dddConstants().getZPos(detType));
    const CLHEP::HepRep3x3 rotation =
        (zside > 0) ? CLHEP::HepRep3x3(1, 0, 0, 0, 1, 0, 0, 0, 1) : CLHEP::HepRep3x3(-1, 0, 0, 0, 1, 0, 0, 0, -1);
    const CLHEP::HepRotation hr(rotation);
    const CLHEP::Hep3Vector h3v(0, 0, zv);
    const HepGeom::Transform3D ht3d(hr, h3v);
    DetId detId = (DetId)(FastTimeDetId(detType, 0, 0, zside));
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("FastTimeGeom") << "FastTimeGeometryLoader:: transf " << ht3d.getTranslation() << " and "
                                     << ht3d.getRotation();
#endif
    params[0] = topology.dddConstants().getZHalf(detType);
    params[1] = params[2] = 0;
    params[3] = params[7] = topology.dddConstants().getRin(detType);
    params[4] = params[8] = topology.dddConstants().getRout(detType);
    params[5] = params[9] = topology.dddConstants().getRout(detType);
    params[6] = params[10] = 0;
    params[11] = zside;
    buildGeom(params, ht3d, detId, topology, geom);
    counter++;
  }

  geom->sortDetIds();

  if (counter != numberOfCells) {
    edm::LogWarning("FastTimeGeom") << "inconsistent # of cells: expected " << numberOfCells << " , inited " << counter;
    assert(counter == numberOfCells);
  }

  return geom;
}

buildGeom()

void FastTimeGeometryLoader::buildGeom ( const ParmVec &  params, const HepGeom::Transform3D &  ht3d, const DetId &  detId, const FastTimeTopology &  topology, FastTimeGeometry *  geom  )

private

Definition at line 76 of file FastTimeGeometryLoader.cc.

References FlatTrd::createCorners(), FastTimeTopology::dddConstants(), relativeConstraints::geom, FastTimeDDDConstants::getCorners(), CaloCellGeometry::getParmPtr(), mps_fire::i, PV3DBase< T, PVType, FrameType >::mag2(), submitPVValidationJobs::params, std::swap(), x, y, z, and ecaldqm::zside().

Referenced by build().

                                                               {
#ifdef EDM_ML_DEBUG
  std::ostringstream st1;
  st1 << "Volume Parameters";
  for (unsigned int i = 0; i < 12; ++i)
    st1 << " : " << params[i];
  edm::LogVerbatim("FastTimeGeom") << st1.str();
#endif
  FastTimeDetId id = FastTimeDetId(detId);
  std::vector<GlobalPoint> corners = topology.dddConstants().getCorners(id.type(), 1, 1, id.zside());

  FlatTrd::createCorners(params, ht3d, corners);

  const CCGFloat* parmPtr(CaloCellGeometry::getParmPtr(params, geom->parMgr(), geom->parVecVec()));

  GlobalPoint front(0.25 * (corners[0].x() + corners[1].x() + corners[2].x() + corners[3].x()),
                    0.25 * (corners[0].y() + corners[1].y() + corners[2].y() + corners[3].y()),
                    0.25 * (corners[0].z() + corners[1].z() + corners[2].z() + corners[3].z()));

  GlobalPoint back(0.25 * (corners[4].x() + corners[5].x() + corners[6].x() + corners[7].x()),
                   0.25 * (corners[4].y() + corners[5].y() + corners[6].y() + corners[7].y()),
                   0.25 * (corners[4].z() + corners[5].z() + corners[6].z() + corners[7].z()));

  if (front.mag2() > back.mag2()) {  // front should always point to the center, so swap front and back
    std::swap(front, back);
    std::swap_ranges(corners.begin(), corners.begin() + 4, corners.begin() + 4);
  }

  geom->newCell(front, back, corners[0], parmPtr, detId);
}