File indexing completed on 2024-09-18 05:06:43
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
0039
0040
0041
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]));
0091 const Pt3D lCor(lc[0]);
0092
0093
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
0108 const Tr3D atr(nullptr == at ? tr
0109 : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
0110
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();
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]));
0203 const Pt3D lCor(lc[0]);
0204
0205
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
0217 const Tr3D atr(nullptr == at ? tr
0218 : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
0219
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();
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;
0243 DimVec dvec;
0244 IVec ivec;
0245 IVec dins;
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
0269 int layer = ivec[it];
0270
0271
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
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()) {
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();
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
0347
0348
0349
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]));
0399 const Pt3D lCor(lc[0]);
0400
0401
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
0415 const Tr3D atr(nullptr == at ? tr
0416 : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
0417
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();
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);