DTGeometryBuilderFromCondDB.cc

Go to the documentation of this file.

/******* \class DTGeometryBuilderFromCondDB *******
 *
 * Description:
 *  
 *  detailed description
 *
 * \author : Stefano Lacaprara - INFN LNL <stefano.lacaprara@pd.infn.it>
 *
 * Modification:
 *
 *********************************/
 
/* This Class Header */
#include "Geometry/DTGeometryBuilder/src/DTGeometryBuilderFromCondDB.h"
 
/* Collaborating Class Header */
#include <CondFormats/GeometryObjects/interface/RecoIdealGeometry.h>
#include <Geometry/DTGeometry/interface/DTGeometry.h>
#include <DataFormats/MuonDetId/interface/DTChamberId.h>
#include <DataFormats/MuonDetId/interface/DTSuperLayerId.h>
#include <DataFormats/MuonDetId/interface/DTLayerId.h>
#include "DataFormats/Math/interface/GeantUnits.h"
#include <FWCore/MessageLogger/interface/MessageLogger.h>
 
/* C++ Headers */
#include <iostream>
using namespace std;
 
using namespace geant_units;
using namespace geant_units::operators;
 
/* ====================================================================== */
 
/* Constructor */
DTGeometryBuilderFromCondDB::DTGeometryBuilderFromCondDB() {}
 
/* Destructor */
DTGeometryBuilderFromCondDB::~DTGeometryBuilderFromCondDB() {}
 
/* Operations */
void DTGeometryBuilderFromCondDB::build(const std::shared_ptr<DTGeometry>& theGeometry, const RecoIdealGeometry& rig) {
  //  cout << "DTGeometryBuilderFromCondDB " << endl;
  const std::vector<DetId>& detids(rig.detIds());
  //  cout << "size " << detids.size() << endl;
 
  size_t idt = 0;
  DTChamber* chamber(nullptr);
  DTSuperLayer* sl(nullptr);
  while (idt < detids.size()) {
    //copy(par.begin(), par.end(), ostream_iterator<double>(std::cout," "));
    if (int(*(rig.shapeStart(idt))) == 0) {  // a Chamber
      // add the provious chamber which by now has been updated with SL and
      // layers
      if (chamber)
        theGeometry->add(chamber);
      // go for the actual one
      DTChamberId chid(detids[idt]);
      //cout << "CH: " <<  chid << endl;
      chamber = buildChamber(chid, rig, idt);
    } else if (int(*(rig.shapeStart(idt))) == 1) {  // a SL
      DTSuperLayerId slid(detids[idt]);
      //cout << "  SL: " <<  slid << endl;
      sl = buildSuperLayer(chamber, slid, rig, idt);
      theGeometry->add(sl);
    } else if (int(*(rig.shapeStart(idt))) == 2) {  // a Layer
      DTLayerId lid(detids[idt]);
      //cout << "    LAY: " <<  lid << endl;
      DTLayer* lay = buildLayer(sl, lid, rig, idt);
      theGeometry->add(lay);
    } else {
      cout << "What is this?" << endl;
    }
    ++idt;
  }
  if (chamber)
    theGeometry->add(chamber);  // add the last chamber
}
 
// Calling function has the responsibility to delete the allocated RectangularPlaneBounds object
RectangularPlaneBounds* dtGeometryBuilder::getRecPlaneBounds(const std::vector<double>::const_iterator& shapeStart) {
  float width = convertMmToCm(*(shapeStart));          // r-phi  dimension - different in different chambers
  float length = convertMmToCm(*(shapeStart + 1));     // z      dimension - constant
  float thickness = convertMmToCm(*(shapeStart + 2));  // radial thickness - almost constant
  return new RectangularPlaneBounds(width, length, thickness);
}
 
DTChamber* DTGeometryBuilderFromCondDB::buildChamber(const DetId& id, const RecoIdealGeometry& rig, size_t idt) const {
  DTChamberId detId(id);
 
  // width is along local X
  // length is along local Y
  // length z      dimension - constant 125.55 cm
  // thickness is along local Z
  // radial thickness - almost constant about 18 cm
  RCPPlane surf(
      plane(rig.tranStart(idt), rig.rotStart(idt), dtGeometryBuilder::getRecPlaneBounds(++rig.shapeStart(idt))));
 
  DTChamber* chamber = new DTChamber(detId, surf);
 
  return chamber;
}
 
DTSuperLayer* DTGeometryBuilderFromCondDB::buildSuperLayer(DTChamber* chamber,
                                                           const DetId& id,
                                                           const RecoIdealGeometry& rig,
                                                           size_t idt) const {
  DTSuperLayerId slId(id);
 
  // r-phi  dimension - different in different chambers
  // z      dimension - constant 126.8 cm
  // radial thickness - almost constant about 5 cm
 
  // Ok this is the slayer position...
  RCPPlane surf(
      plane(rig.tranStart(idt), rig.rotStart(idt), dtGeometryBuilder::getRecPlaneBounds(++rig.shapeStart(idt))));
 
  DTSuperLayer* slayer = new DTSuperLayer(slId, surf, chamber);
 
  // cout << "adding slayer " << slayer->id() << " to chamber "<<  chamber->id() << endl;
  assert(chamber);
  chamber->add(slayer);
  return slayer;
}
 
DTLayer* DTGeometryBuilderFromCondDB::buildLayer(DTSuperLayer* sl,
                                                 const DetId& id,
                                                 const RecoIdealGeometry& rig,
                                                 size_t idt) const {
  DTLayerId layId(id);
 
  // Layer specific parameter (size)
  // r-phi  dimension - different in different chambers
  // z      dimension - constant 126.8 cm
  // radial thickness - almost constant about 20 cm
 
  auto shapeStartPtr = rig.shapeStart(idt);
  RCPPlane surf(
      plane(rig.tranStart(idt), rig.rotStart(idt), dtGeometryBuilder::getRecPlaneBounds((shapeStartPtr + 1))));
 
  // Loop on wires
  int firstWire = static_cast<int>(*(shapeStartPtr + 4));       //par[4]);
  int WCounter = static_cast<int>(*(shapeStartPtr + 5));        //par[5]);
  double sensibleLength = convertMmToCm(*(shapeStartPtr + 6));  //par[6] in cm;
  DTTopology topology(firstWire, WCounter, sensibleLength);
 
  DTLayerType layerType;
 
  DTLayer* layer = new DTLayer(layId, surf, topology, layerType, sl);
  // cout << "adding layer " << layer->id() << " to sl "<<  sl->id() << endl;
 
  assert(sl);
  sl->add(layer);
  return layer;
}
 
DTGeometryBuilderFromCondDB::RCPPlane DTGeometryBuilderFromCondDB::plane(const vector<double>::const_iterator tranStart,
                                                                         const vector<double>::const_iterator rotStart,
                                                                         Bounds* bounds) const {
  // extract the position
  const Surface::PositionType posResult(*(tranStart), *(tranStart + 1), *(tranStart + 2));
  // now the rotation
  Surface::RotationType rotResult(*(rotStart + 0),
                                  *(rotStart + 1),
                                  *(rotStart + 2),
                                  *(rotStart + 3),
                                  *(rotStart + 4),
                                  *(rotStart + 5),
                                  *(rotStart + 6),
                                  *(rotStart + 7),
                                  *(rotStart + 8));
 
  return RCPPlane(new Plane(posResult, rotResult, bounds));
}