Core/src/DDSolid.cc

0001 #include "DetectorDescription/Core/interface/DDSolid.h"
0002 #include "DetectorDescription/Core/interface/DDSolidShapes.h"
0003
0004 #include <ostream>
0005 #include <string>
0006 #include <array>
0007
0008 #include "DetectorDescription/Core/interface/Assembly.h"
0009 #include "DetectorDescription/Core/interface/Boolean.h"
0010 #include "DetectorDescription/Core/interface/Box.h"
0011 #include "DetectorDescription/Core/interface/Cons.h"
0012 #include "DetectorDescription/Core/interface/EllipticalTube.h"
0013 #include "DetectorDescription/Core/interface/ExtrudedPolygon.h"
0014 #include "DetectorDescription/Core/interface/Polycone.h"
0015 #include "DetectorDescription/Core/interface/Polyhedra.h"
0016 #include "DetectorDescription/Core/interface/PseudoTrap.h"
0017 #include "DetectorDescription/Core/src/Shapeless.h"
0018 #include "DetectorDescription/Core/interface/Solid.h"
0019 #include "DetectorDescription/Core/interface/Sphere.h"
0020 #include "DetectorDescription/Core/interface/Torus.h"
0021 #include "DetectorDescription/Core/interface/Trap.h"
0022 #include "DetectorDescription/Core/interface/TruncTubs.h"
0023 #include "DetectorDescription/Core/interface/Tubs.h"
0024 #include "DetectorDescription/Core/interface/CutTubs.h"
0025 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0026 #include "FWCore/Utilities/interface/Exception.h"
0027
0028 using DDI::Solid;
0029
0030 std::ostream& operator<<(std::ostream& os, const DDSolidShape s) {
0031   return os << "DDSolidShape index:" << static_cast<int>(s) << ", name: " << DDSolidShapesName::name(s);
0032 }
0033
0034 std::ostream& operator<<(std::ostream& os, const DDSolid& solid) {
0035   DDBase<DDName, DDI::Solid*>::def_type defined(solid.isDefined());
0036   if (defined.first) {
0037     os << *(defined.first) << " ";
0038     if (defined.second) {
0039       os << "  " << DDSolidShapesName::name(solid.shape()) << ": ";
0040       solid.rep().stream(os);
0041     } else {
0042       os << "* solid not defined * ";
0043     }
0044   } else {
0045     os << "* solid not declared * ";
0046   }
0047   return os;
0048 }
0049
0050 DDSolid::DDSolid() : DDBase<DDName, std::unique_ptr<Solid>>() {}
0051
0052 DDSolid::DDSolid(const DDName& name) : DDBase<DDName, std::unique_ptr<Solid>>() { create(name); }
0053
0054 DDSolid::DDSolid(const DDName& name, std::unique_ptr<Solid> solid) : DDBase<DDName, std::unique_ptr<Solid>>() {
0055   create(name, std::move(solid));
0056 }
0057
0058 DDSolid::DDSolid(const DDName& name, DDSolidShape shape, const std::vector<double>& pars) {
0059   std::unique_ptr<DDI::Solid> solid(nullptr);
0060   std::vector<double> dummy;
0061   switch (shape) {
0062     case DDSolidShape::ddbox:
0063       solid = std::make_unique<DDI::Box>(0, 0, 0);
0064       break;
0065     case DDSolidShape::ddtubs:
0066       solid = std::make_unique<DDI::Tubs>(0, 0, 0, 0, 0);
0067       break;
0068     case DDSolidShape::ddcons:
0069       solid = std::make_unique<DDI::Cons>(0, 0, 0, 0, 0, 0, 0);
0070       break;
0071     case DDSolidShape::ddpseudotrap:
0072       solid = std::make_unique<DDI::PseudoTrap>(0, 0, 0, 0, 0, 0, false);
0073       break;
0074     case DDSolidShape::ddshapeless:
0075       solid = std::make_unique<DDI::Shapeless>();
0076       break;
0077     case DDSolidShape::ddtrap:
0078       solid = std::make_unique<DDI::Trap>(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
0079       break;
0080     case DDSolidShape::ddpolyhedra_rz:
0081       solid = std::make_unique<DDI::Polyhedra>(0, 0, 0, dummy, dummy);
0082       break;
0083     case DDSolidShape::ddpolyhedra_rrz:
0084       solid = std::make_unique<DDI::Polyhedra>(0, 0, 0, dummy, dummy, dummy);
0085       break;
0086     case DDSolidShape::ddpolycone_rz:
0087       solid = std::make_unique<DDI::Polycone>(0, 0, dummy, dummy);
0088       break;
0089     case DDSolidShape::ddpolycone_rrz:
0090       solid = std::make_unique<DDI::Polycone>(0, 0, dummy, dummy, dummy);
0091       break;
0092     case DDSolidShape::ddtrunctubs:
0093       solid = std::make_unique<DDI::TruncTubs>(0, 0, 0, 0, 0, 0, 0, false);
0094       break;
0095     case DDSolidShape::ddtorus:
0096       solid = std::make_unique<DDI::Torus>(0, 0, 0, 0, 0);
0097       break;
0098     case DDSolidShape::ddsphere:
0099       solid = std::make_unique<DDI::Sphere>(0, 0, 0, 0, 0, 0);
0100       break;
0101     case DDSolidShape::ddellipticaltube:
0102       solid = std::make_unique<DDI::EllipticalTube>(0, 0, 0);
0103       break;
0104     case DDSolidShape::ddcuttubs:
0105       solid = std::make_unique<DDI::CutTubs>(0., 0., 0., 0., 0., 0., 0., 1., 0., 0., -1.);
0106       break;
0107     case DDSolidShape::ddextrudedpolygon:
0108       solid = std::make_unique<DDI::ExtrudedPolygon>(dummy, dummy, dummy, dummy, dummy, dummy);
0109       break;
0110     case DDSolidShape::ddassembly:
0111       solid = std::make_unique<DDI::Assembly>();
0112       break;
0113     default:
0114       throw cms::Exception("DDException")
0115           << "DDSolid::DDSolid( DDName, DDSolidShape, std::vector<double> ): wrong shape.";
0116   }
0117   solid->setParameters(pars);
0118   create(name, std::move(solid));
0119 }
0120
0121 double DDSolid::volume() const { return rep().volume(); }
0122
0123 DDSolidShape DDSolid::shape() const { return rep().shape(); }
0124
0125 const std::vector<double>& DDSolid::parameters() const { return rep().parameters(); }
0126
0127 DDTrap::DDTrap(const DDSolid& s) : DDSolid(s) {
0128   if (s.shape() != DDSolidShape::ddtrap) {
0129     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is no DDTrap.\n";
0130     ex = ex + "Use a different solid interface!";
0131     throw cms::Exception("DDException") << ex;
0132   }
0133 }
0134
0135 double DDTrap::halfZ() const { return rep().parameters()[0]; }
0136
0137 double DDTrap::theta() const { return rep().parameters()[1]; }
0138
0139 double DDTrap::phi() const { return rep().parameters()[2]; }
0140
0141 double DDTrap::y1() const { return rep().parameters()[3]; }
0142
0143 double DDTrap::x1() const { return rep().parameters()[4]; }
0144
0145 double DDTrap::x2() const { return rep().parameters()[5]; }
0146
0147 double DDTrap::alpha1() const { return rep().parameters()[6]; }
0148
0149 double DDTrap::y2() const { return rep().parameters()[7]; }
0150
0151 double DDTrap::x3() const { return rep().parameters()[8]; }
0152
0153 double DDTrap::x4() const { return rep().parameters()[9]; }
0154
0155 double DDTrap::alpha2() const { return rep().parameters()[10]; }
0156
0157 DDTruncTubs::DDTruncTubs(const DDSolid& s) : DDSolid(s) {
0158   if (s.shape() != DDSolidShape::ddtrunctubs) {
0159     edm::LogError("DDSolid") << "s.shape()=" << s.shape() << "  " << s.name() << std::endl;
0160     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is no DDTruncTubs\n";
0161     ex = ex + "Use a different solid interface!";
0162     throw cms::Exception("DDException") << ex;
0163   }
0164 }
0165
0166 double DDTruncTubs::zHalf() const { return rep().parameters()[0]; }
0167
0168 double DDTruncTubs::rIn() const { return rep().parameters()[1]; }
0169
0170 double DDTruncTubs::rOut() const { return rep().parameters()[2]; }
0171
0172 double DDTruncTubs::startPhi() const { return rep().parameters()[3]; }
0173
0174 double DDTruncTubs::deltaPhi() const { return rep().parameters()[4]; }
0175
0176 double DDTruncTubs::cutAtStart() const { return rep().parameters()[5]; }
0177
0178 double DDTruncTubs::cutAtDelta() const { return rep().parameters()[6]; }
0179
0180 bool DDTruncTubs::cutInside() const { return bool(rep().parameters()[7]); }
0181
0182 DDPseudoTrap::DDPseudoTrap(const DDSolid& s) : DDSolid(s) {
0183   if (s.shape() != DDSolidShape::ddpseudotrap) {
0184     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is no DDPseudoTrap\n";
0185     ex = ex + "Use a different solid interface!";
0186     throw cms::Exception("DDException") << ex;
0187   }
0188 }
0189
0190 double DDPseudoTrap::halfZ() const { return rep().parameters()[4]; }
0191
0192 double DDPseudoTrap::x1() const { return rep().parameters()[0]; }
0193
0194 double DDPseudoTrap::x2() const { return rep().parameters()[1]; }
0195
0196 double DDPseudoTrap::y1() const { return rep().parameters()[2]; }
0197
0198 double DDPseudoTrap::y2() const { return rep().parameters()[3]; }
0199
0200 double DDPseudoTrap::radius() const { return rep().parameters()[5]; }
0201
0202 bool DDPseudoTrap::atMinusZ() const { return rep().parameters()[6]; }
0203
0204 DDBox::DDBox(const DDSolid& s) : DDSolid(s) {
0205   if (s.shape() != DDSolidShape::ddbox) {
0206     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDBox.\n";
0207     ex = ex + "Use a different solid interface!";
0208     throw cms::Exception("DDException") << ex;
0209   }
0210 }
0211
0212 double DDBox::halfX() const { return rep().parameters()[0]; }
0213
0214 double DDBox::halfY() const { return rep().parameters()[1]; }
0215
0216 double DDBox::halfZ() const { return rep().parameters()[2]; }
0217
0218 DDShapelessSolid::DDShapelessSolid(const DDSolid& s) : DDSolid(s) {
0219   if (s.shape() != DDSolidShape::ddshapeless) {
0220     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDShapelessSolid.\n";
0221     ex = ex + "Use a different solid interface!";
0222     throw cms::Exception("DDException") << ex;
0223   }
0224 }
0225
0226 DDUnion::DDUnion(const DDSolid& s) : DDBooleanSolid(s) {
0227   if (s.shape() != DDSolidShape::ddunion) {
0228     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDUnion.\n";
0229     ex = ex + "Use a different solid interface!";
0230     throw cms::Exception("DDException") << ex;
0231   }
0232 }
0233
0234 DDIntersection::DDIntersection(const DDSolid& s) : DDBooleanSolid(s) {
0235   if (s.shape() != DDSolidShape::ddunion) {
0236     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDIntersection.\n";
0237     ex = ex + "Use a different solid interface!";
0238     throw cms::Exception("DDException") << ex;
0239   }
0240 }
0241
0242 DDSubtraction::DDSubtraction(const DDSolid& s) : DDBooleanSolid(s) {
0243   if (s.shape() != DDSolidShape::ddsubtraction) {
0244     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is no DDSubtraction.\n";
0245     ex = ex + "Use a different solid interface!";
0246     throw cms::Exception("DDException") << ex;
0247   }
0248 }
0249
0250 DDPolySolid::DDPolySolid(const DDSolid& s) : DDSolid(s) {}
0251
0252 std::vector<double> DDPolySolid::getVec(const size_t& which, const size_t& offset, const size_t& numVecs) const {
0253   // which:  first second or third std::vector
0254   // offset: number of non-std::vector components before std::vectors start
0255   if ((rep().parameters().size() - offset) % numVecs != 0) {
0256     edm::LogError("DDSolid") << "Could not find equal sized components of std::vectors in a PolySolid description."
0257                              << "rep().parameters().size()=" << rep().parameters().size() << "  numVecs=" << numVecs
0258                              << "  offset=" << offset << std::endl;
0259   }
0260   std::vector<double> tvec;
0261   for (size_t i = offset + which; i < rep().parameters().size(); i = i + numVecs) {
0262     tvec.emplace_back(rep().parameters()[i]);
0263   }
0264   return tvec;
0265 }
0266
0267 DDPolycone::DDPolycone(const DDSolid& s) : DDPolySolid(s) {
0268   if (s.shape() != DDSolidShape::ddpolycone_rz && s.shape() != DDSolidShape::ddpolycone_rrz) {
0269     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDPolycone.\n";
0270     ex = ex + "Use a different solid interface!";
0271     throw cms::Exception("DDException") << ex;
0272   }
0273 }
0274
0275 double DDPolycone::startPhi() const { return rep().parameters()[0]; }
0276
0277 double DDPolycone::deltaPhi() const { return rep().parameters()[1]; }
0278
0279 std::vector<double> DDPolycone::rVec() const {
0280   std::vector<double> tvec;
0281   if (shape() == DDSolidShape::ddpolycone_rz)
0282     tvec = getVec(1, 2, 2);
0283   return tvec;
0284 }
0285
0286 std::vector<double> DDPolycone::zVec() const {
0287   if (shape() == DDSolidShape::ddpolycone_rz)
0288     return getVec(0, 2, 2);
0289   else  // (shape() == DDSolidShape::ddpolycone_rrz)
0290     return getVec(0, 2, 3);
0291 }
0292
0293 std::vector<double> DDPolycone::rMinVec() const {
0294   std::vector<double> tvec;
0295   if (shape() == DDSolidShape::ddpolycone_rrz)
0296     tvec = getVec(1, 2, 3);
0297   return tvec;
0298 }
0299
0300 std::vector<double> DDPolycone::rMaxVec() const {
0301   std::vector<double> tvec;
0302   if (shape() == DDSolidShape::ddpolycone_rrz)
0303     tvec = getVec(2, 2, 3);
0304   return tvec;
0305 }
0306
0307 DDPolyhedra::DDPolyhedra(const DDSolid& s) : DDPolySolid(s) {
0308   if (s.shape() != DDSolidShape::ddpolyhedra_rz && s.shape() != DDSolidShape::ddpolyhedra_rrz) {
0309     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDPolyhedra.\n";
0310     ex = ex + "Use a different solid interface!";
0311     throw cms::Exception("DDException") << ex;
0312   }
0313 }
0314
0315 int DDPolyhedra::sides() const { return int(rep().parameters()[0]); }
0316
0317 double DDPolyhedra::startPhi() const { return rep().parameters()[1]; }
0318
0319 double DDPolyhedra::deltaPhi() const { return rep().parameters()[2]; }
0320
0321 std::vector<double> DDPolyhedra::rVec() const {
0322   std::vector<double> tvec;
0323   if (shape() == DDSolidShape::ddpolyhedra_rz)
0324     tvec = getVec(1, 3, 2);
0325   return tvec;
0326 }
0327
0328 std::vector<double> DDPolyhedra::zVec() const {
0329   if (shape() == DDSolidShape::ddpolyhedra_rz)
0330     return getVec(0, 3, 2);
0331   else  // (shape() == ddpolycone_rrz)
0332     return getVec(0, 3, 3);
0333 }
0334
0335 std::vector<double> DDPolyhedra::rMinVec() const {
0336   std::vector<double> tvec;
0337   if (shape() == DDSolidShape::ddpolyhedra_rrz)
0338     tvec = getVec(1, 3, 3);
0339   return tvec;
0340 }
0341
0342 std::vector<double> DDPolyhedra::rMaxVec() const {
0343   std::vector<double> tvec;
0344   if (shape() == DDSolidShape::ddpolyhedra_rrz)
0345     tvec = getVec(2, 3, 3);
0346   return tvec;
0347 }
0348
0349 DDExtrudedPolygon::DDExtrudedPolygon(const DDSolid& s) : DDPolySolid(s) {
0350   if (s.shape() != DDSolidShape::ddextrudedpolygon) {
0351     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDExtrudedPolygon.\n";
0352     ex = ex + "Use a different solid interface!";
0353     throw cms::Exception("DDException") << ex;
0354   }
0355 }
0356
0357 auto DDExtrudedPolygon::xyPointsSize(void) const -> std::size_t {
0358   // Compute the size of the X and Y coordinate vectors
0359   // which define the vertices of the outlined polygon
0360   // defined in clock-wise order
0361
0362   return (rep().parameters().size() - 4 * zSectionsSize()) * 0.5;
0363 }
0364
0365 auto DDExtrudedPolygon::zSectionsSize(void) const -> std::size_t {
0366   // The first parameters element stores a size of the four equal size vectors
0367   // which form the ExtrudedPolygon shape Z sections:
0368   //
0369   //    * first: Z coordinate of the XY polygone plane,
0370   //    * second and third: x and y offset of the polygone in the XY plane,
0371   //    * fourth: the polygone scale in each XY plane
0372   //
0373   // The Z sections defined by the z position in an increasing order.
0374
0375   return rep().parameters()[0];
0376 }
0377
0378 std::vector<double> DDExtrudedPolygon::xVec(void) const {
0379   return std::vector<double>(rep().parameters().begin() + 1, rep().parameters().begin() + 1 + xyPointsSize());
0380 }
0381
0382 std::vector<double> DDExtrudedPolygon::yVec(void) const {
0383   return std::vector<double>(rep().parameters().begin() + 1 + xyPointsSize(),
0384                              rep().parameters().begin() + 1 + 2 * xyPointsSize());
0385 }
0386
0387 std::vector<double> DDExtrudedPolygon::zVec(void) const {
0388   return std::vector<double>(rep().parameters().end() - 4 * zSectionsSize(),
0389                              rep().parameters().end() - 3 * zSectionsSize());
0390 }
0391
0392 std::vector<double> DDExtrudedPolygon::zxVec(void) const {
0393   return std::vector<double>(rep().parameters().end() - 3 * zSectionsSize(),
0394                              rep().parameters().end() - 2 * zSectionsSize());
0395 }
0396
0397 std::vector<double> DDExtrudedPolygon::zyVec(void) const {
0398   return std::vector<double>(rep().parameters().end() - 2 * zSectionsSize(),
0399                              rep().parameters().end() - zSectionsSize());
0400 }
0401
0402 std::vector<double> DDExtrudedPolygon::zscaleVec(void) const {
0403   return std::vector<double>(rep().parameters().end() - zSectionsSize(), rep().parameters().end());
0404 }
0405
0406 DDCons::DDCons(const DDSolid& s) : DDSolid(s) {
0407   if (s.shape() != DDSolidShape::ddcons) {
0408     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDCons.\n";
0409     ex = ex + "Use a different solid interface!";
0410     throw cms::Exception("DDException") << ex;
0411   }
0412 }
0413
0414 double DDCons::zhalf() const { return rep().parameters()[0]; }
0415
0416 double DDCons::rInMinusZ() const { return rep().parameters()[1]; }
0417
0418 double DDCons::rOutMinusZ() const { return rep().parameters()[2]; }
0419
0420 double DDCons::rInPlusZ() const { return rep().parameters()[3]; }
0421
0422 double DDCons::rOutPlusZ() const { return rep().parameters()[4]; }
0423
0424 double DDCons::phiFrom() const { return rep().parameters()[5]; }
0425
0426 double DDCons::deltaPhi() const { return rep().parameters()[6]; }
0427
0428 DDTorus::DDTorus(const DDSolid& s) : DDSolid(s) {
0429   if (s.shape() != DDSolidShape::ddtorus) {
0430     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDTorus.\n";
0431     ex = ex + "Use a different solid interface!";
0432     throw cms::Exception("DDException") << ex;
0433   }
0434 }
0435
0436 double DDTorus::rMin() const { return rep().parameters()[0]; }
0437
0438 double DDTorus::rMax() const { return rep().parameters()[1]; }
0439
0440 double DDTorus::rTorus() const { return rep().parameters()[2]; }
0441
0442 double DDTorus::startPhi() const { return rep().parameters()[3]; }
0443
0444 double DDTorus::deltaPhi() const { return rep().parameters()[4]; }
0445
0446 DDTubs::DDTubs(const DDSolid& s) : DDSolid(s) {
0447   if (s.shape() != DDSolidShape::ddtubs) {
0448     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDTubs.\n";
0449     ex = ex + "Use a different solid interface!";
0450     throw cms::Exception("DDException") << ex;
0451   }
0452 }
0453
0454 double DDTubs::zhalf() const { return rep().parameters()[0]; }
0455
0456 double DDTubs::rIn() const { return rep().parameters()[1]; }
0457
0458 double DDTubs::rOut() const { return rep().parameters()[2]; }
0459
0460 double DDTubs::startPhi() const { return rep().parameters()[3]; }
0461
0462 double DDTubs::deltaPhi() const { return rep().parameters()[4]; }
0463
0464 DDBooleanSolid::DDBooleanSolid(const DDSolid& s) : DDSolid(s), boolean_(static_cast<DDI::BooleanSolid&>(s.rep())) {}
0465
0466 DDRotation DDBooleanSolid::rotation() const { return boolean_.r(); }
0467
0468 DDTranslation DDBooleanSolid::translation() const { return boolean_.t(); }
0469
0470 DDSolid DDBooleanSolid::solidA() const { return boolean_.a(); }
0471
0472 DDSolid DDBooleanSolid::solidB() const { return boolean_.b(); }
0473
0474 DDSphere::DDSphere(const DDSolid& s) : DDSolid(s) {
0475   if (s.shape() != DDSolidShape::ddsphere) {
0476     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDSphere (or sphere section).\n";
0477     ex = ex + "Use a different solid interface!";
0478     throw cms::Exception("DDException") << ex;
0479   }
0480 }
0481
0482 double DDSphere::innerRadius() const { return rep().parameters()[0]; }
0483
0484 double DDSphere::outerRadius() const { return rep().parameters()[1]; }
0485
0486 double DDSphere::startPhi() const { return rep().parameters()[2]; }
0487
0488 double DDSphere::deltaPhi() const { return rep().parameters()[3]; }
0489
0490 double DDSphere::startTheta() const { return rep().parameters()[4]; }
0491
0492 double DDSphere::deltaTheta() const { return rep().parameters()[5]; }
0493
0494 DDEllipticalTube::DDEllipticalTube(const DDSolid& s) : DDSolid(s) {
0495   if (s.shape() != DDSolidShape::ddellipticaltube) {
0496     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDEllipticalTube.\n";
0497     ex = ex + "Use a different solid interface!";
0498     throw cms::Exception("DDException") << ex;
0499   }
0500 }
0501
0502 double DDEllipticalTube::xSemiAxis() const { return rep().parameters()[0]; }
0503
0504 double DDEllipticalTube::ySemiAxis() const { return rep().parameters()[1]; }
0505
0506 double DDEllipticalTube::zHeight() const { return rep().parameters()[2]; }
0507
0508 DDCutTubs::DDCutTubs(const DDSolid& s) : DDSolid(s) {
0509   if (s.shape() != DDSolidShape::ddcuttubs) {
0510     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDCutTubs.\n";
0511     ex = ex + "Use a different solid interface!";
0512     throw cms::Exception("DDException") << ex;
0513   }
0514 }
0515
0516 double DDCutTubs::zhalf() const { return rep().parameters()[0]; }
0517
0518 double DDCutTubs::rIn() const { return rep().parameters()[1]; }
0519
0520 double DDCutTubs::rOut() const { return rep().parameters()[2]; }
0521
0522 double DDCutTubs::startPhi() const { return rep().parameters()[3]; }
0523
0524 double DDCutTubs::deltaPhi() const { return rep().parameters()[4]; }
0525
0526 std::array<double, 3> DDCutTubs::lowNorm(void) const {
0527   return std::array<double, 3>{{rep().parameters()[5], rep().parameters()[6], rep().parameters()[7]}};
0528 }
0529
0530 std::array<double, 3> DDCutTubs::highNorm(void) const {
0531   return std::array<double, 3>{{rep().parameters()[8], rep().parameters()[9], rep().parameters()[10]}};
0532 }
0533
0534 DDAssembly::DDAssembly(const DDSolid& s) : DDSolid(s) {
0535   if (s.shape() != DDSolidShape::ddassembly) {
0536     std::string ex = "Solid [" + s.name().ns() + ":" + s.name().name() + "] is not a DDAssembly.\n";
0537     ex = ex + "Use a different solid interface!";
0538     throw cms::Exception("DDException") << ex;
0539   }
0540 }
0541
0542 // =================================================================================
0543 // =========================SolidFactory============================================
0544
0545 DDSolid DDSolidFactory::assembly(const DDName& name) { return DDSolid(name, std::make_unique<DDI::Assembly>()); }
0546
0547 DDSolid DDSolidFactory::box(const DDName& name, double xHalf, double yHalf, double zHalf) {
0548   return DDSolid(name, std::make_unique<DDI::Box>(xHalf, yHalf, zHalf));
0549 }
0550
0551 DDSolid DDSolidFactory::polycone(const DDName& name,
0552                                  double startPhi,
0553                                  double deltaPhi,
0554                                  const std::vector<double>& z,
0555                                  const std::vector<double>& rmin,
0556                                  const std::vector<double>& rmax) {
0557   return DDSolid(name, std::make_unique<DDI::Polycone>(startPhi, deltaPhi, z, rmin, rmax));
0558 }
0559
0560 DDSolid DDSolidFactory::polycone(
0561     const DDName& name, double startPhi, double deltaPhi, const std::vector<double>& z, const std::vector<double>& r) {
0562   return DDSolid(name, std::make_unique<DDI::Polycone>(startPhi, deltaPhi, z, r));
0563 }
0564
0565 DDSolid DDSolidFactory::polyhedra(const DDName& name,
0566                                   int sides,
0567                                   double startPhi,
0568                                   double deltaPhi,
0569                                   const std::vector<double>& z,
0570                                   const std::vector<double>& rmin,
0571                                   const std::vector<double>& rmax) {
0572   return DDSolid(name, std::make_unique<DDI::Polyhedra>(sides, startPhi, deltaPhi, z, rmin, rmax));
0573 }
0574
0575 DDSolid DDSolidFactory::polyhedra(const DDName& name,
0576                                   int sides,
0577                                   double startPhi,
0578                                   double deltaPhi,
0579                                   const std::vector<double>& z,
0580                                   const std::vector<double>& r) {
0581   return DDSolid(name, std::make_unique<DDI::Polyhedra>(sides, startPhi, deltaPhi, z, r));
0582 }
0583
0584 DDSolid DDSolidFactory::extrudedpolygon(const DDName& name,
0585                                         const std::vector<double>& x,
0586                                         const std::vector<double>& y,
0587                                         const std::vector<double>& z,
0588                                         const std::vector<double>& zx,
0589                                         const std::vector<double>& zy,
0590                                         const std::vector<double>& zscale) {
0591   return DDSolid(name, std::make_unique<DDI::ExtrudedPolygon>(x, y, z, zx, zy, zscale));
0592 }
0593
0594 DDSolid DDSolidFactory::unionSolid(
0595     const DDName& name, const DDSolid& a, const DDSolid& b, const DDTranslation& t, const DDRotation& r) {
0596   return DDSolid(name, std::make_unique<DDI::Union>(a, b, t, r));
0597 }
0598
0599 DDSolid DDSolidFactory::subtraction(
0600     const DDName& name, const DDSolid& a, const DDSolid& b, const DDTranslation& t, const DDRotation& r) {
0601   return DDSolid(name, std::make_unique<DDI::Subtraction>(a, b, t, r));
0602 }
0603
0604 DDSolid DDSolidFactory::intersection(
0605     const DDName& name, const DDSolid& a, const DDSolid& b, const DDTranslation& t, const DDRotation& r) {
0606   return DDSolid(name, std::make_unique<DDI::Intersection>(a, b, t, r));
0607 }
0608
0609 DDSolid DDSolidFactory::trap(const DDName& name,
0610                              double pDz,
0611                              double pTheta,
0612                              double pPhi,
0613                              double pDy1,
0614                              double pDx1,
0615                              double pDx2,
0616                              double pAlp1,
0617                              double pDy2,
0618                              double pDx3,
0619                              double pDx4,
0620                              double pAlp2) {
0621   return DDSolid(name,
0622                  std::make_unique<DDI::Trap>(pDz, pTheta, pPhi, pDy1, pDx1, pDx2, pAlp1, pDy2, pDx3, pDx4, pAlp2));
0623 }
0624
0625 DDSolid DDSolidFactory::pseudoTrap(const DDName& name,
0626                                    double pDx1,   /**< Half-length along x at the surface positioned at -dz */
0627                                    double pDx2,   /**<  Half-length along x at the surface positioned at +dz */
0628                                    double pDy1,   /**<  Half-length along y at the surface positioned at -dz */
0629                                    double pDy2,   /**<  Half-length along y at the surface positioned at +dz */
0630                                    double pDz,    /**< Half of the height of the pseudo trapezoid along z */
0631                                    double radius, /**< radius of the cut-out (negative sign) or rounding (pos. sign) */
0632                                    bool atMinusZ /**< if true, the cut-out or rounding is applied at -dz, else at +dz */
0633 ) {
0634   return DDSolid(name, std::make_unique<DDI::PseudoTrap>(pDx1, pDx2, pDy1, pDy2, pDz, radius, atMinusZ));
0635 }
0636
0637 DDSolid DDSolidFactory::truncTubs(const DDName& name,
0638                                   double zHalf,      /**< half-length of the z-axis */
0639                                   double rIn,        /**< inner radius of the tube-section */
0640                                   double rOut,       /**< outer radius of the tube-section */
0641                                   double startPhi,   /**< starting angle of the tube-section */
0642                                   double deltaPhi,   /**< spanning angle of the tube-section */
0643                                   double cutAtStart, /**< tructation at startPhi side */
0644                                   double cutAtDelta, /**< truncation at deltaPhi side */
0645                                   bool cutInside) {
0646   return DDSolid(
0647       name, std::make_unique<DDI::TruncTubs>(zHalf, rIn, rOut, startPhi, deltaPhi, cutAtStart, cutAtDelta, cutInside));
0648 }
0649
0650 DDSolid DDSolidFactory::cons(const DDName& name,
0651                              double zhalf,
0652                              double rInMinusZ,
0653                              double rOutMinusZ,
0654                              double rInPlusZ,
0655                              double rOutPlusZ,
0656                              double phiFrom,
0657                              double deltaPhi) {
0658   return DDSolid(name,
0659                  std::make_unique<DDI::Cons>(zhalf, rInMinusZ, rOutMinusZ, rInPlusZ, rOutPlusZ, phiFrom, deltaPhi));
0660 }
0661
0662 DDSolid DDSolidFactory::torus(
0663     const DDName& name, double rMin, double rMax, double rTorus, double startPhi, double deltaPhi) {
0664   return DDSolid(name, std::make_unique<DDI::Torus>(rMin, rMax, rTorus, startPhi, deltaPhi));
0665 }
0666
0667 DDSolid DDSolidFactory::tubs(
0668     const DDName& name, double zhalf, double rIn, double rOut, double phiFrom, double deltaPhi) {
0669   return DDSolid(name, std::make_unique<DDI::Tubs>(zhalf, rIn, rOut, phiFrom, deltaPhi));
0670 }
0671
0672 DDSolid DDSolidFactory::cuttubs(const DDName& name,
0673                                 double zhalf,
0674                                 double rIn,
0675                                 double rOut,
0676                                 double phiFrom,
0677                                 double deltaPhi,
0678                                 double lx,
0679                                 double ly,
0680                                 double lz,
0681                                 double tx,
0682                                 double ty,
0683                                 double tz) {
0684   return DDSolid(name, std::make_unique<DDI::CutTubs>(zhalf, rIn, rOut, phiFrom, deltaPhi, lx, ly, lz, tx, ty, tz));
0685 }
0686
0687 DDSolid DDSolidFactory::sphere(const DDName& name,
0688                                double innerRadius,
0689                                double outerRadius,
0690                                double startPhi,
0691                                double deltaPhi,
0692                                double startTheta,
0693                                double deltaTheta) {
0694   return DDSolid(name,
0695                  std::make_unique<DDI::Sphere>(innerRadius, outerRadius, startPhi, deltaPhi, startTheta, deltaTheta));
0696 }
0697
0698 DDSolid DDSolidFactory::ellipticalTube(const DDName& name, double xSemiAxis, double ySemiAxis, double zHeight) {
0699   return DDSolid(name, std::make_unique<DDI::EllipticalTube>(xSemiAxis, ySemiAxis, zHeight));
0700 }
0701
0702 DDSolid DDSolidFactory::shapeless(const DDName& name) { return DDSolid(name, std::make_unique<DDI::Shapeless>()); }