Geometry/plugins/calowriters.cc

0001 #include "Geometry/CaloEventSetup/interface/CaloGeometryDBEP.h"
0002 #include "Geometry/CaloEventSetup/interface/CaloGeometryDBWriter.h"
0003 #include "Geometry/EcalAlgo/interface/EcalBarrelGeometry.h"
0004 #include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h"
0005 #include "Geometry/EcalAlgo/interface/EcalPreshowerGeometry.h"
0006 #include "Geometry/HcalTowerAlgo/interface/HcalGeometry.h"
0007 #include "Geometry/HcalTowerAlgo/interface/CaloTowerGeometry.h"
0008 #include "Geometry/HcalTowerAlgo/interface/CaloGeometryDBHcal.h"
0009 #include "Geometry/HcalTowerAlgo/interface/CaloGeometryDBCaloTower.h"
0010 #include "Geometry/ForwardGeometry/interface/ZdcGeometry.h"
0011 #include "Geometry/ForwardGeometry/interface/ZdcTopology.h"
0012 #include "Geometry/ForwardGeometry/interface/CaloGeometryDBZdc.h"
0013 #include "Geometry/ForwardGeometry/interface/CastorGeometry.h"
0014 #include "Geometry/Records/interface/HcalRecNumberingRecord.h"
0015 #include "Geometry/HGCalGeometry/interface/HGCalGeometry.h"
0016 #include "Geometry/HGCalGeometry/interface/CaloGeometryDBHGCal.h"
0017
0018 template <>
0019 CaloGeometryDBEP<HcalGeometry, CaloGeometryDBWriter>::PtrType
0020 CaloGeometryDBEP<HcalGeometry, CaloGeometryDBWriter>::produceAligned(
0021     const typename HcalGeometry::AlignedRecord& iRecord) {
0022   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
0023
0024   TrVec tvec;
0025   DimVec dvec;
0026   IVec ivec;
0027   IVec dins;
0028
0029   const auto& pG = iRecord.get(geometryToken_);
0030
0031   pG.getSummary(tvec, ivec, dvec, dins);
0032
0033   CaloGeometryDBWriter::writeIndexed(tvec, dvec, ivec, dins, HcalGeometry::dbString());
0034   //*********************************************************************************************
0035
0036   const auto& hcalTopology = iRecord.get(additionalTokens_.topology);
0037
0038   // We know that the numer of shapes chanes with changing depth
0039   // so, this check is temporary disabled. We need to implement
0040   // a way either to store or calculate the number of shapes or be able
0041   // to deal with only max numer of shapes.
0042   assert(dvec.size() <= hcalTopology.getNumberOfShapes() * HcalGeometry::k_NumberOfParametersPerShape);
0043   HcalGeometry* hcalGeometry = new HcalGeometry(hcalTopology);
0044   PtrType ptr(hcalGeometry);
0045
0046   const unsigned int nTrParm(hcalGeometry->numberOfTransformParms());
0047
0048   ptr->fillDefaultNamedParameters();
0049   ptr->allocateCorners(hcalTopology.ncells() + hcalTopology.getHFSize());
0050   ptr->allocatePar(hcalGeometry->numberOfShapes(), HcalGeometry::k_NumberOfParametersPerShape);
0051
0052   for (unsigned int i(0); i < dins.size(); ++i) {
0053     const unsigned int nPerShape(HcalGeometry::k_NumberOfParametersPerShape);
0054     DimVec dims;
0055     dims.reserve(nPerShape);
0056
0057     const unsigned int indx(ivec.size() == 1 ? 0 : i);
0058
0059     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
0060
0061     for (unsigned int j(0); j != nPerShape; ++j) {
0062       dims.push_back(*dsrc);
0063       ++dsrc;
0064     }
0065
0066     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
0067
0068     const DetId id(hcalTopology.denseId2detId(dins[i]));
0069
0070     const unsigned int iGlob(nullptr == globalPtr ? 0 : HcalGeometry::alignmentTransformIndexGlobal(id));
0071
0072     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
0073
0074     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
0075
0076     assert(nullptr == gt || iGlob == HcalGeometry::alignmentTransformIndexGlobal(DetId(gt->rawId())));
0077
0078     const unsigned int iLoc(nullptr == alignPtr ? 0 : HcalGeometry::alignmentTransformIndexLocal(id));
0079
0080     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
0081
0082     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
0083
0084     assert(nullptr == at || (HcalGeometry::alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
0085
0086     Pt3D lRef;
0087     Pt3DVec lc(8, Pt3D(0, 0, 0));
0088     hcalGeometry->localCorners(lc, &dims.front(), dins[i], lRef);
0089
0090     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
0091     const Pt3D lCor(lc[0]);
0092
0093     //----------------------------------- create transform from 6 numbers ---
0094     const unsigned int jj(i * nTrParm);
0095
0096     Tr3D tr;
0097     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
0098     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
0099                                                   : ROOT::Math::EulerAngles());
0100     const ROOT::Math::Transform3D rt(ea, tl);
0101     double xx, xy, xz, dx;
0102     double yx, yy, yz, dy;
0103     double zx, zy, zz, dz;
0104     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
0105     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
0106
0107     // now prepend alignment(s) for final transform
0108     const Tr3D atr(nullptr == at ? tr
0109                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
0110     //--------------------------------- done making transform  ---------------
0111
0112     const Pt3D gRef(atr * lRef);
0113     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
0114     const Pt3D gBck(atr * lBck);
0115     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
0116     const Pt3D gCor(atr * lCor);
0117     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
0118
0119     assert(hcalTopology.detId2denseId(id) == dins[i]);
0120     ptr->newCell(fCtr, fBck, fCor, myParm, id);
0121   }
0122
0123   ptr->initializeParms();  // initializations; must happen after cells filled
0124
0125   return ptr;
0126 }
0127
0128 template <>
0129 CaloGeometryDBEP<CaloTowerGeometry, CaloGeometryDBWriter>::PtrType
0130 CaloGeometryDBEP<CaloTowerGeometry, CaloGeometryDBWriter>::produceAligned(
0131     const typename CaloTowerGeometry::AlignedRecord& iRecord) {
0132   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
0133
0134   TrVec tvec;
0135   DimVec dvec;
0136   IVec ivec;
0137   IVec dins;
0138
0139   const auto& pG = iRecord.get(geometryToken_);
0140
0141   pG.getSummary(tvec, ivec, dvec, dins);
0142
0143   CaloGeometryDBWriter::writeIndexed(tvec, dvec, ivec, dins, CaloTowerGeometry::dbString());
0144   //*********************************************************************************************
0145
0146   const auto& caloTopology = iRecord.get(additionalTokens_.topology);
0147
0148   CaloTowerGeometry* ctg = new CaloTowerGeometry(&caloTopology);
0149
0150   const unsigned int nTrParm(tvec.size() / ctg->numberOfCellsForCorners());
0151
0152   assert(dvec.size() == ctg->numberOfShapes() * CaloTowerGeometry::k_NumberOfParametersPerShape);
0153
0154   PtrType ptr(ctg);
0155
0156   ptr->fillDefaultNamedParameters();
0157
0158   ptr->allocateCorners(ctg->numberOfCellsForCorners());
0159
0160   ptr->allocatePar(dvec.size(), CaloTowerGeometry::k_NumberOfParametersPerShape);
0161
0162   for (unsigned int i(0); i < dins.size(); ++i) {
0163     const unsigned int nPerShape(ctg->numberOfParametersPerShape());
0164     DimVec dims;
0165     dims.reserve(nPerShape);
0166
0167     const unsigned int indx(ivec.size() == 1 ? 0 : i);
0168
0169     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
0170
0171     for (unsigned int j(0); j != nPerShape; ++j) {
0172       dims.push_back(*dsrc);
0173       ++dsrc;
0174     }
0175
0176     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
0177
0178     const DetId id(caloTopology.detIdFromDenseIndex(dins[i]));
0179
0180     const unsigned int iGlob(nullptr == globalPtr ? 0 : ctg->alignmentTransformIndexGlobal(id));
0181
0182     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
0183
0184     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
0185
0186     assert(nullptr == gt || iGlob == ctg->alignmentTransformIndexGlobal(DetId(gt->rawId())));
0187
0188     const unsigned int iLoc(nullptr == alignPtr ? 0 : ctg->alignmentTransformIndexLocal(id));
0189
0190     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
0191
0192     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
0193
0194     assert(nullptr == at || (ctg->alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
0195
0196     const CaloGenericDetId gId(id);
0197
0198     Pt3D lRef;
0199     Pt3DVec lc(8, Pt3D(0, 0, 0));
0200     ctg->localCorners(lc, &dims.front(), dins[i], lRef);
0201
0202     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
0203     const Pt3D lCor(lc[0]);
0204
0205     //----------------------------------- create transform from 6 numbers ---
0206     const unsigned int jj(i * nTrParm);
0207     Tr3D tr;
0208     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
0209     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
0210                                                   : ROOT::Math::EulerAngles());
0211     const ROOT::Math::Transform3D rt(ea, tl);
0212     double xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz;
0213     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
0214     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
0215
0216     // now prepend alignment(s) for final transform
0217     const Tr3D atr(nullptr == at ? tr
0218                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
0219     //--------------------------------- done making transform  ---------------
0220
0221     const Pt3D gRef(atr * lRef);
0222     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
0223     const Pt3D gBck(atr * lBck);
0224     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
0225     const Pt3D gCor(atr * lCor);
0226     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
0227
0228     assert(caloTopology.denseIndex(id) == dins[i]);
0229
0230     ptr->newCell(fCtr, fBck, fCor, myParm, id);
0231   }
0232
0233   ptr->initializeParms();  // initializations; must happen after cells filled
0234
0235   return ptr;
0236 }
0237
0238 template <>
0239 CaloGeometryDBEP<HGCalGeometry, CaloGeometryDBWriter>::PtrType
0240 CaloGeometryDBEP<HGCalGeometry, CaloGeometryDBWriter>::produceAligned(
0241     const typename HGCalGeometry::AlignedRecord& iRecord) {
0242   TrVec tvec;   // transformation
0243   DimVec dvec;  // parameters
0244   IVec ivec;    // layers
0245   IVec dins;    // valid geom ids
0246
0247   const auto& geom = iRecord.get(geometryToken_);
0248
0249   geom.getSummary(tvec, ivec, dvec, dins);
0250
0251   CaloGeometryDBWriter::writeIndexed(tvec, dvec, ivec, dins, HGCalGeometry::dbString());
0252   //*********************************************************************************************
0253
0254   const auto& topology = iRecord.get(additionalTokens_.topology);
0255
0256   assert(dvec.size() <= topology.totalGeomModules() * HGCalGeometry::k_NumberOfParametersPerShape);
0257   HGCalGeometry* hcg = new HGCalGeometry(topology);
0258   PtrType ptr(hcg);
0259
0260   ptr->allocateCorners(topology.ncells());
0261   ptr->allocatePar(HGCalGeometry::k_NumberOfShapes, HGCalGeometry::k_NumberOfParametersPerShape);
0262
0263   const unsigned int nTrParm(ptr->numberOfTransformParms());
0264   const unsigned int nPerShape(HGCalGeometry::k_NumberOfParametersPerShape);
0265
0266   for (auto it : dins) {
0267     DetId id = topology.encode(topology.geomDenseId2decId(it));
0268     // get layer
0269     int layer = ivec[it];
0270
0271     // get transformation
0272     const unsigned int jj(it * nTrParm);
0273     Tr3D tr;
0274     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
0275     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
0276                                                   : ROOT::Math::EulerAngles());
0277     const ROOT::Math::Transform3D rt(ea, tl);
0278     double xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz;
0279     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
0280     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
0281
0282     // get parameters
0283     DimVec dims;
0284     dims.reserve(nPerShape);
0285
0286     DimVec::const_iterator dsrc(dvec.begin() + layer * nPerShape);
0287     for (unsigned int j(0); j != nPerShape; ++j) {
0288       dims.push_back(*dsrc);
0289       ++dsrc;
0290     }
0291
0292     std::vector<GlobalPoint> corners(FlatHexagon::ncorner_);
0293
0294     FlatHexagon::createCorners(dims, tr, corners);
0295
0296     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
0297     GlobalPoint front(
0298         FlatHexagon::oneBySix_ *
0299             (corners[0].x() + corners[1].x() + corners[2].x() + corners[3].x() + corners[4].x() + corners[5].x()),
0300         FlatHexagon::oneBySix_ *
0301             (corners[0].y() + corners[1].y() + corners[2].y() + corners[3].y() + corners[4].y() + corners[5].y()),
0302         FlatHexagon::oneBySix_ *
0303             (corners[0].z() + corners[1].z() + corners[2].z() + corners[3].z() + corners[4].z() + corners[5].z()));
0304
0305     GlobalPoint back(
0306         FlatHexagon::oneBySix_ *
0307             (corners[6].x() + corners[7].x() + corners[8].x() + corners[9].x() + corners[10].x() + corners[11].x()),
0308         FlatHexagon::oneBySix_ *
0309             (corners[6].y() + corners[7].y() + corners[8].y() + corners[9].y() + corners[10].y() + corners[11].y()),
0310         FlatHexagon::oneBySix_ *
0311             (corners[6].z() + corners[7].z() + corners[8].z() + corners[9].z() + corners[10].z() + corners[11].z()));
0312
0313     if (front.mag2() > back.mag2()) {  // front should always point to the center, so swap front and back
0314       std::swap(front, back);
0315       std::swap_ranges(
0316           corners.begin(), corners.begin() + FlatHexagon::ncornerBy2_, corners.begin() + FlatHexagon::ncornerBy2_);
0317     }
0318
0319     ptr->newCell(front, back, corners[0], myParm, id);
0320   }
0321
0322   ptr->initializeParms();  // initializations; must happen after cells filled
0323
0324   return ptr;
0325 }
0326
0327 template <>
0328 CaloGeometryDBEP<ZdcGeometry, CaloGeometryDBWriter>::PtrType
0329 CaloGeometryDBEP<ZdcGeometry, CaloGeometryDBWriter>::produceAligned(const typename ZdcGeometry::AlignedRecord& iRecord) {
0330   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
0331
0332   TrVec tvec;
0333   DimVec dvec;
0334   IVec ivec;
0335   IVec dins;
0336
0337   const auto& pG = iRecord.get(geometryToken_);
0338
0339   pG.getSummary(tvec, ivec, dvec, dins);
0340
0341   CaloGeometryDBWriter::writeIndexed(tvec, dvec, ivec, dins, ZdcGeometry::dbString());
0342   //*********************************************************************************************
0343
0344   const auto& zdcTopology = iRecord.get(additionalTokens_.topology);
0345
0346   // We know that the numer of shapes chanes with changing depth
0347   // so, this check is temporary disabled. We need to implement
0348   // a way either to store or calculate the number of shapes or be able
0349   // to deal with only max numer of shapes.
0350   assert(dvec.size() <= ZdcGeometry::k_NumberOfShapes * ZdcGeometry::k_NumberOfParametersPerShape);
0351   ZdcGeometry* zdcGeometry = new ZdcGeometry(&zdcTopology);
0352   PtrType ptr(zdcGeometry);
0353
0354   const unsigned int nTrParm(tvec.size() / zdcTopology.kSizeForDenseIndexing());
0355
0356   ptr->fillDefaultNamedParameters();
0357   ptr->allocateCorners(zdcTopology.kSizeForDenseIndexing());
0358   ptr->allocatePar(zdcGeometry->numberOfShapes(), ZdcGeometry::k_NumberOfParametersPerShape);
0359
0360   for (unsigned int i(0); i < dins.size(); ++i) {
0361     const unsigned int nPerShape(ZdcGeometry::k_NumberOfParametersPerShape);
0362     DimVec dims;
0363     dims.reserve(nPerShape);
0364
0365     const unsigned int indx(ivec.size() == 1 ? 0 : i);
0366
0367     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
0368
0369     for (unsigned int j(0); j != nPerShape; ++j) {
0370       dims.push_back(*dsrc);
0371       ++dsrc;
0372     }
0373
0374     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
0375
0376     const DetId id(zdcTopology.denseId2detId(dins[i]));
0377
0378     const unsigned int iGlob(nullptr == globalPtr ? 0 : ZdcGeometry::alignmentTransformIndexGlobal(id));
0379
0380     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
0381
0382     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
0383
0384     assert(nullptr == gt || iGlob == ZdcGeometry::alignmentTransformIndexGlobal(DetId(gt->rawId())));
0385
0386     const unsigned int iLoc(nullptr == alignPtr ? 0 : ZdcGeometry::alignmentTransformIndexLocal(id));
0387
0388     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
0389
0390     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
0391
0392     assert(nullptr == at || (ZdcGeometry::alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
0393
0394     Pt3D lRef;
0395     Pt3DVec lc(8, Pt3D(0, 0, 0));
0396     zdcGeometry->localCorners(lc, &dims.front(), dins[i], lRef);
0397
0398     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
0399     const Pt3D lCor(lc[0]);
0400
0401     //----------------------------------- create transform from 6 numbers ---
0402     const unsigned int jj(i * nTrParm);
0403     Tr3D tr;
0404     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
0405     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
0406                                                   : ROOT::Math::EulerAngles());
0407     const ROOT::Math::Transform3D rt(ea, tl);
0408     double xx, xy, xz, dx;
0409     double yx, yy, yz, dy;
0410     double zx, zy, zz, dz;
0411     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
0412     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
0413
0414     // now prepend alignment(s) for final transform
0415     const Tr3D atr(nullptr == at ? tr
0416                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
0417     //--------------------------------- done making transform  ---------------
0418
0419     const Pt3D gRef(atr * lRef);
0420     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
0421     const Pt3D gBck(atr * lBck);
0422     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
0423     const Pt3D gCor(atr * lCor);
0424     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
0425
0426     assert(zdcTopology.detId2denseId(id) == dins[i]);
0427     ptr->newCell(fCtr, fBck, fCor, myParm, id);
0428   }
0429
0430   ptr->initializeParms();  // initializations; must happen after cells filled
0431
0432   return ptr;
0433 }
0434
0435 template class CaloGeometryDBEP<EcalBarrelGeometry, CaloGeometryDBWriter>;
0436 template class CaloGeometryDBEP<EcalEndcapGeometry, CaloGeometryDBWriter>;
0437 template class CaloGeometryDBEP<EcalPreshowerGeometry, CaloGeometryDBWriter>;
0438
0439 template class CaloGeometryDBEP<HcalGeometry, CaloGeometryDBWriter>;
0440 template class CaloGeometryDBEP<CaloTowerGeometry, CaloGeometryDBWriter>;
0441 template class CaloGeometryDBEP<ZdcGeometry, CaloGeometryDBWriter>;
0442 template class CaloGeometryDBEP<CastorGeometry, CaloGeometryDBWriter>;
0443
0444 typedef CaloGeometryDBEP<EcalBarrelGeometry, CaloGeometryDBWriter> EcalBarrelGeometryToDBEP;
0445
0446 DEFINE_FWK_EVENTSETUP_MODULE(EcalBarrelGeometryToDBEP);
0447
0448 typedef CaloGeometryDBEP<EcalEndcapGeometry, CaloGeometryDBWriter> EcalEndcapGeometryToDBEP;
0449
0450 DEFINE_FWK_EVENTSETUP_MODULE(EcalEndcapGeometryToDBEP);
0451
0452 typedef CaloGeometryDBEP<EcalPreshowerGeometry, CaloGeometryDBWriter> EcalPreshowerGeometryToDBEP;
0453
0454 DEFINE_FWK_EVENTSETUP_MODULE(EcalPreshowerGeometryToDBEP);
0455
0456 typedef CaloGeometryDBEP<HcalGeometry, CaloGeometryDBWriter> HcalGeometryToDBEP;
0457
0458 DEFINE_FWK_EVENTSETUP_MODULE(HcalGeometryToDBEP);
0459
0460 typedef CaloGeometryDBEP<CaloTowerGeometry, CaloGeometryDBWriter> CaloTowerGeometryToDBEP;
0461
0462 DEFINE_FWK_EVENTSETUP_MODULE(CaloTowerGeometryToDBEP);
0463
0464 typedef CaloGeometryDBEP<ZdcGeometry, CaloGeometryDBWriter> ZdcGeometryToDBEP;
0465
0466 DEFINE_FWK_EVENTSETUP_MODULE(ZdcGeometryToDBEP);
0467
0468 typedef CaloGeometryDBEP<CastorGeometry, CaloGeometryDBWriter> CastorGeometryToDBEP;
0469
0470 DEFINE_FWK_EVENTSETUP_MODULE(CastorGeometryToDBEP);
0471
0472 typedef CaloGeometryDBEP<HGCalGeometry, CaloGeometryDBWriter> HGCalGeometryToDBEP;
0473
0474 DEFINE_FWK_EVENTSETUP_MODULE(HGCalGeometryToDBEP);