Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-12-08 08:16:20

0001 //////////////////////////////////////////////////////////////////////////////
0002 // File: DDEcalBarrelNewAlgo.cc
0003 // Description: Geometry factory class for Ecal Barrel
0004 ///////////////////////////////////////////////////////////////////////////////
0005 
0006 #include <cmath>
0007 #include <algorithm>
0008 
0009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0010 #include "DetectorDescription/Core/interface/DDLogicalPart.h"
0011 #include "DetectorDescription/Core/interface/DDSolid.h"
0012 #include "DetectorDescription/Core/interface/DDCurrentNamespace.h"
0013 #include "DetectorDescription/Core/interface/DDTranslation.h"
0014 #include "CLHEP/Units/GlobalSystemOfUnits.h"
0015 
0016 #include <CLHEP/Geometry/Point3D.h>
0017 #include <CLHEP/Geometry/Vector3D.h>
0018 #include <CLHEP/Geometry/Transform3D.h>
0019 #include <map>
0020 #include <string>
0021 #include <vector>
0022 #include "DetectorDescription/Core/interface/DDTypes.h"
0023 #include "DetectorDescription/Core/interface/DDName.h"
0024 #include "DetectorDescription/Core/interface/DDAlgorithm.h"
0025 #include "DetectorDescription/Core/interface/DDMaterial.h"
0026 #include "DetectorDescription/Core/interface/DDSplit.h"
0027 #include "DetectorDescription/Core/interface/DDTransform.h"
0028 #include "Geometry/CaloGeometry/interface/EcalTrapezoidParameters.h"
0029 #include "CLHEP/Geometry/Transform3D.h"
0030 
0031 //#define EDM_ML_DEBUG
0032 
0033 class DDEcalBarrelNewAlgo : public DDAlgorithm {
0034 public:
0035   typedef EcalTrapezoidParameters Trap;
0036   typedef HepGeom::Point3D<double> Pt3D;
0037   typedef HepGeom::Transform3D Tf3D;
0038   typedef HepGeom::ReflectZ3D RfZ3D;
0039   typedef HepGeom::Translate3D Tl3D;
0040   typedef HepGeom::Rotate3D Ro3D;
0041   typedef HepGeom::RotateZ3D RoZ3D;
0042   typedef HepGeom::RotateY3D RoY3D;
0043   typedef HepGeom::RotateX3D RoX3D;
0044 
0045   typedef CLHEP::Hep3Vector Vec3;
0046   typedef CLHEP::HepRotation Rota;
0047 
0048   //Constructor and Destructor
0049   DDEcalBarrelNewAlgo();
0050   ~DDEcalBarrelNewAlgo() override;
0051 
0052   void initialize(const DDNumericArguments& nArgs,
0053                   const DDVectorArguments& vArgs,
0054                   const DDMapArguments& mArgs,
0055                   const DDStringArguments& sArgs,
0056                   const DDStringVectorArguments& vsArgs) override;
0057   void execute(DDCompactView& cpv) override;
0058 
0059   DDMaterial ddmat(const std::string& s) const;
0060   DDName ddname(const std::string& s) const;
0061   DDRotation myrot(const std::string& s, const CLHEP::HepRotation& r) const;
0062   DDSolid mytrap(const std::string& s, const Trap& t) const;
0063 
0064   const std::string& idNameSpace() const { return m_idNameSpace; }
0065 
0066   // barrel parent volume
0067   DDName barName() const { return ddname(m_BarName); }
0068   DDMaterial barMat() const { return ddmat(m_BarMat); }
0069   const std::vector<double>& vecBarZPts() const { return m_vecBarZPts; }
0070   const std::vector<double>& vecBarRMin() const { return m_vecBarRMin; }
0071   const std::vector<double>& vecBarRMax() const { return m_vecBarRMax; }
0072   const std::vector<double>& vecBarTran() const { return m_vecBarTran; }
0073   const std::vector<double>& vecBarRota() const { return m_vecBarRota; }
0074   const std::vector<double>& vecBarRota2() const { return m_vecBarRota2; }
0075   const std::vector<double>& vecBarRota3() const { return m_vecBarRota3; }
0076   double barPhiLo() const { return m_BarPhiLo; }
0077   double barPhiHi() const { return m_BarPhiHi; }
0078   double barHere() const { return m_BarHere; }
0079 
0080   DDName spmName() const { return ddname(m_SpmName); }
0081   DDMaterial spmMat() const { return ddmat(m_SpmMat); }
0082   const std::vector<double>& vecSpmZPts() const { return m_vecSpmZPts; }
0083   const std::vector<double>& vecSpmRMin() const { return m_vecSpmRMin; }
0084   const std::vector<double>& vecSpmRMax() const { return m_vecSpmRMax; }
0085   const std::vector<double>& vecSpmTran() const { return m_vecSpmTran; }
0086   const std::vector<double>& vecSpmRota() const { return m_vecSpmRota; }
0087   const std::vector<double>& vecSpmBTran() const { return m_vecSpmBTran; }
0088   const std::vector<double>& vecSpmBRota() const { return m_vecSpmBRota; }
0089   unsigned int spmNPerHalf() const { return m_SpmNPerHalf; }
0090   double spmLowPhi() const { return m_SpmLowPhi; }
0091   double spmDelPhi() const { return m_SpmDelPhi; }
0092   double spmPhiOff() const { return m_SpmPhiOff; }
0093   const std::vector<double>& vecSpmHere() const { return m_vecSpmHere; }
0094   DDName spmCutName() const { return ddname(m_SpmCutName); }
0095   double spmCutThick() const { return m_SpmCutThick; }
0096   int spmCutShow() const { return m_SpmCutShow; }
0097   double spmCutRM() const { return m_SpmCutRM; }
0098   double spmCutRP() const { return m_SpmCutRP; }
0099   const std::vector<double>& vecSpmCutTM() const { return m_vecSpmCutTM; }
0100   const std::vector<double>& vecSpmCutTP() const { return m_vecSpmCutTP; }
0101   double spmExpThick() const { return m_SpmExpThick; }
0102   double spmExpWide() const { return m_SpmExpWide; }
0103   double spmExpYOff() const { return m_SpmExpYOff; }
0104   DDName spmSideName() const { return ddname(m_SpmSideName); }
0105   DDMaterial spmSideMat() const { return ddmat(m_SpmSideMat); }
0106   double spmSideHigh() const { return m_SpmSideHigh; }
0107   double spmSideThick() const { return m_SpmSideThick; }
0108   double spmSideYOffM() const { return m_SpmSideYOffM; }
0109   double spmSideYOffP() const { return m_SpmSideYOffP; }
0110 
0111   double nomCryDimAF() const { return m_NomCryDimAF; }
0112   double nomCryDimLZ() const { return m_NomCryDimLZ; }
0113   const std::vector<double>& vecNomCryDimBF() const { return m_vecNomCryDimBF; }
0114   const std::vector<double>& vecNomCryDimCF() const { return m_vecNomCryDimCF; }
0115   const std::vector<double>& vecNomCryDimAR() const { return m_vecNomCryDimAR; }
0116   const std::vector<double>& vecNomCryDimBR() const { return m_vecNomCryDimBR; }
0117   const std::vector<double>& vecNomCryDimCR() const { return m_vecNomCryDimCR; }
0118 
0119   double underAF() const { return m_UnderAF; }
0120   double underLZ() const { return m_UnderLZ; }
0121   double underBF() const { return m_UnderBF; }
0122   double underCF() const { return m_UnderCF; }
0123   double underAR() const { return m_UnderAR; }
0124   double underBR() const { return m_UnderBR; }
0125   double underCR() const { return m_UnderCR; }
0126 
0127   double wallThAlv() const { return m_WallThAlv; }
0128   double wrapThAlv() const { return m_WrapThAlv; }
0129   double clrThAlv() const { return m_ClrThAlv; }
0130   const std::vector<double>& vecGapAlvEta() const { return m_vecGapAlvEta; }
0131 
0132   double wallFrAlv() const { return m_WallFrAlv; }
0133   double wrapFrAlv() const { return m_WrapFrAlv; }
0134   double clrFrAlv() const { return m_ClrFrAlv; }
0135 
0136   double wallReAlv() const { return m_WallReAlv; }
0137   double wrapReAlv() const { return m_WrapReAlv; }
0138   double clrReAlv() const { return m_ClrReAlv; }
0139 
0140   unsigned int nCryTypes() const { return m_NCryTypes; }
0141   unsigned int nCryPerAlvEta() const { return m_NCryPerAlvEta; }
0142 
0143   const std::string& cryName() const { return m_CryName; }
0144   const std::string& clrName() const { return m_ClrName; }
0145   const std::string& wrapName() const { return m_WrapName; }
0146   const std::string& wallName() const { return m_WallName; }
0147 
0148   DDMaterial cryMat() const { return ddmat(m_CryMat); }
0149   DDMaterial clrMat() const { return ddmat(m_ClrMat); }
0150   DDMaterial wrapMat() const { return ddmat(m_WrapMat); }
0151   DDMaterial wallMat() const { return ddmat(m_WallMat); }
0152   DDName capName() const { return ddname(m_capName); }
0153   double capHere() const { return m_capHere; }
0154   DDMaterial capMat() const { return ddmat(m_capMat); }
0155   double capXSize() const { return m_capXSize; }
0156   double capYSize() const { return m_capYSize; }
0157   double capThick() const { return m_capThick; }
0158 
0159   DDName cerName() const { return ddname(m_CERName); }
0160   DDMaterial cerMat() const { return ddmat(m_CERMat); }
0161   double cerXSize() const { return m_CERXSize; }
0162   double cerYSize() const { return m_CERYSize; }
0163   double cerThick() const { return m_CERThick; }
0164 
0165   DDName bsiName() const { return ddname(m_BSiName); }
0166   DDMaterial bsiMat() const { return ddmat(m_BSiMat); }
0167   double bsiXSize() const { return m_BSiXSize; }
0168   double bsiYSize() const { return m_BSiYSize; }
0169   double bsiThick() const { return m_BSiThick; }
0170 
0171   DDName atjName() const { return ddname(m_ATJName); }
0172   DDMaterial atjMat() const { return ddmat(m_ATJMat); }
0173   double atjThick() const { return m_ATJThick; }
0174 
0175   DDName sglName() const { return ddname(m_SGLName); }
0176   DDMaterial sglMat() const { return ddmat(m_SGLMat); }
0177   double sglThick() const { return m_SGLThick; }
0178 
0179   DDName aglName() const { return ddname(m_AGLName); }
0180   DDMaterial aglMat() const { return ddmat(m_AGLMat); }
0181   double aglThick() const { return m_AGLThick; }
0182 
0183   DDName andName() const { return ddname(m_ANDName); }
0184   DDMaterial andMat() const { return ddmat(m_ANDMat); }
0185   double andThick() const { return m_ANDThick; }
0186 
0187   DDName apdName() const { return ddname(m_APDName); }
0188   DDMaterial apdMat() const { return ddmat(m_APDMat); }
0189   double apdSide() const { return m_APDSide; }
0190   double apdThick() const { return m_APDThick; }
0191   double apdZ() const { return m_APDZ; }
0192   double apdX1() const { return m_APDX1; }
0193   double apdX2() const { return m_APDX2; }
0194 
0195   double webHere() const { return m_WebHere; }
0196   const std::string& webPlName() const { return m_WebPlName; }
0197   const std::string& webClrName() const { return m_WebClrName; }
0198   DDMaterial webPlMat() const { return ddmat(m_WebPlMat); }
0199   DDMaterial webClrMat() const { return ddmat(m_WebClrMat); }
0200   const std::vector<double>& vecWebPlTh() const { return m_vecWebPlTh; }
0201   const std::vector<double>& vecWebClrTh() const { return m_vecWebClrTh; }
0202   const std::vector<double>& vecWebLength() const { return m_vecWebLength; }
0203 
0204   double ilyHere() const { return m_IlyHere; }
0205   const std::string& ilyName() const { return m_IlyName; }
0206   double ilyPhiLow() const { return m_IlyPhiLow; }
0207   double ilyDelPhi() const { return m_IlyDelPhi; }
0208   const std::vector<std::string>& vecIlyMat() const { return m_vecIlyMat; }
0209   const std::vector<double>& vecIlyThick() const { return m_vecIlyThick; }
0210 
0211   const std::string& ilyPipeName() const { return m_IlyPipeName; }
0212   double ilyPipeHere() const { return m_IlyPipeHere; }
0213   DDMaterial ilyPipeMat() const { return ddmat(m_IlyPipeMat); }
0214   double ilyPipeOD() const { return m_IlyPipeOD; }
0215   double ilyPipeID() const { return m_IlyPipeID; }
0216   const std::vector<double>& vecIlyPipeLength() const { return m_vecIlyPipeLength; }
0217   const std::vector<double>& vecIlyPipeType() const { return m_vecIlyPipeType; }
0218   const std::vector<double>& vecIlyPipePhi() const { return m_vecIlyPipePhi; }
0219   const std::vector<double>& vecIlyPipeZ() const { return m_vecIlyPipeZ; }
0220 
0221   DDName ilyPTMName() const { return ddname(m_IlyPTMName); }
0222   double ilyPTMHere() const { return m_IlyPTMHere; }
0223   DDMaterial ilyPTMMat() const { return ddmat(m_IlyPTMMat); }
0224   double ilyPTMWidth() const { return m_IlyPTMWidth; }
0225   double ilyPTMLength() const { return m_IlyPTMLength; }
0226   double ilyPTMHeight() const { return m_IlyPTMHeight; }
0227   const std::vector<double>& vecIlyPTMZ() const { return m_vecIlyPTMZ; }
0228   const std::vector<double>& vecIlyPTMPhi() const { return m_vecIlyPTMPhi; }
0229 
0230   DDName ilyFanOutName() const { return ddname(m_IlyFanOutName); }
0231   double ilyFanOutHere() const { return m_IlyFanOutHere; }
0232   DDMaterial ilyFanOutMat() const { return ddmat(m_IlyFanOutMat); }
0233   double ilyFanOutWidth() const { return m_IlyFanOutWidth; }
0234   double ilyFanOutLength() const { return m_IlyFanOutLength; }
0235   double ilyFanOutHeight() const { return m_IlyFanOutHeight; }
0236   const std::vector<double>& vecIlyFanOutZ() const { return m_vecIlyFanOutZ; }
0237   const std::vector<double>& vecIlyFanOutPhi() const { return m_vecIlyFanOutPhi; }
0238   DDName ilyDiffName() const { return ddname(m_IlyDiffName); }
0239   DDMaterial ilyDiffMat() const { return ddmat(m_IlyDiffMat); }
0240   double ilyDiffOff() const { return m_IlyDiffOff; }
0241   double ilyDiffLength() const { return m_IlyDiffLength; }
0242   DDName ilyBndlName() const { return ddname(m_IlyBndlName); }
0243   DDMaterial ilyBndlMat() const { return ddmat(m_IlyBndlMat); }
0244   double ilyBndlOff() const { return m_IlyBndlOff; }
0245   double ilyBndlLength() const { return m_IlyBndlLength; }
0246   DDName ilyFEMName() const { return ddname(m_IlyFEMName); }
0247   DDMaterial ilyFEMMat() const { return ddmat(m_IlyFEMMat); }
0248   double ilyFEMWidth() const { return m_IlyFEMWidth; }
0249   double ilyFEMLength() const { return m_IlyFEMLength; }
0250   double ilyFEMHeight() const { return m_IlyFEMHeight; }
0251   const std::vector<double>& vecIlyFEMZ() const { return m_vecIlyFEMZ; }
0252   const std::vector<double>& vecIlyFEMPhi() const { return m_vecIlyFEMPhi; }
0253 
0254   DDName hawRName() const { return ddname(m_HawRName); }
0255   DDName fawName() const { return ddname(m_FawName); }
0256   double fawHere() const { return m_FawHere; }
0257   double hawRHBIG() const { return m_HawRHBIG; }
0258   double hawRhsml() const { return m_HawRhsml; }
0259   double hawRCutY() const { return m_HawRCutY; }
0260   double hawRCutZ() const { return m_HawRCutZ; }
0261   double hawRCutDelY() const { return m_HawRCutDelY; }
0262   double hawYOffCry() const { return m_HawYOffCry; }
0263 
0264   unsigned int nFawPerSupm() const { return m_NFawPerSupm; }
0265   double fawPhiOff() const { return m_FawPhiOff; }
0266   double fawDelPhi() const { return m_FawDelPhi; }
0267   double fawPhiRot() const { return m_FawPhiRot; }
0268   double fawRadOff() const { return m_FawRadOff; }
0269 
0270   double gridHere() const { return m_GridHere; }
0271   DDName gridName() const { return ddname(m_GridName); }
0272   DDMaterial gridMat() const { return ddmat(m_GridMat); }
0273   double gridThick() const { return m_GridThick; }
0274 
0275   double backHere() const { return m_BackHere; }
0276   double backXOff() const { return m_BackXOff; }
0277   double backYOff() const { return m_BackYOff; }
0278   DDName backSideName() const { return ddname(m_BackSideName); }
0279   double backSideHere() const { return m_BackSideHere; }
0280   double backSideLength() const { return m_BackSideLength; }
0281   double backSideHeight() const { return m_BackSideHeight; }
0282   double backSideWidth() const { return m_BackSideWidth; }
0283   double backSideYOff1() const { return m_BackSideYOff1; }
0284   double backSideYOff2() const { return m_BackSideYOff2; }
0285   double backSideAngle() const { return m_BackSideAngle; }
0286   DDMaterial backSideMat() const { return ddmat(m_BackSideMat); }
0287   DDName backPlateName() const { return ddname(m_BackPlateName); }
0288   double backPlateHere() const { return m_BackPlateHere; }
0289   double backPlateLength() const { return m_BackPlateLength; }
0290   double backPlateThick() const { return m_BackPlateThick; }
0291   double backPlateWidth() const { return m_BackPlateWidth; }
0292   DDMaterial backPlateMat() const { return ddmat(m_BackPlateMat); }
0293   DDName backPlate2Name() const { return ddname(m_BackPlate2Name); }
0294   double backPlate2Thick() const { return m_BackPlate2Thick; }
0295   DDMaterial backPlate2Mat() const { return ddmat(m_BackPlate2Mat); }
0296   const std::string& grilleName() const { return m_GrilleName; }
0297   double grilleThick() const { return m_GrilleThick; }
0298   double grilleHere() const { return m_GrilleHere; }
0299   double grilleWidth() const { return m_GrilleWidth; }
0300   double grilleZSpace() const { return m_GrilleZSpace; }
0301   DDMaterial grilleMat() const { return ddmat(m_GrilleMat); }
0302   const std::vector<double>& vecGrilleHeight() const { return m_vecGrilleHeight; }
0303   const std::vector<double>& vecGrilleZOff() const { return m_vecGrilleZOff; }
0304 
0305   DDName grEdgeSlotName() const { return ddname(m_GrEdgeSlotName); }
0306   DDMaterial grEdgeSlotMat() const { return ddmat(m_GrEdgeSlotMat); }
0307   double grEdgeSlotHere() const { return m_GrEdgeSlotHere; }
0308   double grEdgeSlotHeight() const { return m_GrEdgeSlotHeight; }
0309   double grEdgeSlotWidth() const { return m_GrEdgeSlotWidth; }
0310   const std::string& grMidSlotName() const { return m_GrMidSlotName; }
0311   DDMaterial grMidSlotMat() const { return ddmat(m_GrMidSlotMat); }
0312   double grMidSlotHere() const { return m_GrMidSlotHere; }
0313   double grMidSlotWidth() const { return m_GrMidSlotWidth; }
0314   double grMidSlotXOff() const { return m_GrMidSlotXOff; }
0315   const std::vector<double>& vecGrMidSlotHeight() const { return m_vecGrMidSlotHeight; }
0316 
0317   double backPipeHere() const { return m_BackPipeHere; }
0318   const std::string& backPipeName() const { return m_BackPipeName; }
0319   const std::vector<double>& vecBackPipeDiam() const { return m_vecBackPipeDiam; }
0320   const std::vector<double>& vecBackPipeThick() const { return m_vecBackPipeThick; }
0321   DDMaterial backPipeMat() const { return ddmat(m_BackPipeMat); }
0322   DDMaterial backPipeWaterMat() const { return ddmat(m_BackPipeWaterMat); }
0323   double backMiscHere() const { return m_BackMiscHere; }
0324   const std::vector<double>& vecBackMiscThick() const { return m_vecBackMiscThick; }
0325   const std::vector<std::string>& vecBackMiscName() const { return m_vecBackMiscName; }
0326   const std::vector<std::string>& vecBackMiscMat() const { return m_vecBackMiscMat; }
0327   double patchPanelHere() const { return m_PatchPanelHere; }
0328   const std::vector<double>& vecPatchPanelThick() const { return m_vecPatchPanelThick; }
0329   const std::vector<std::string>& vecPatchPanelNames() const { return m_vecPatchPanelNames; }
0330   const std::vector<std::string>& vecPatchPanelMat() const { return m_vecPatchPanelMat; }
0331   DDName patchPanelName() const { return ddname(m_PatchPanelName); }
0332 
0333   const std::vector<std::string>& vecBackCoolName() const { return m_vecBackCoolName; }
0334   double backCoolHere() const { return m_BackCoolHere; }
0335   double backCoolBarWidth() const { return m_BackCoolBarWidth; }
0336   double backCoolBarHeight() const { return m_BackCoolBarHeight; }
0337   DDMaterial backCoolMat() const { return ddmat(m_BackCoolMat); }
0338   double backCoolBarHere() const { return m_BackCoolBarHere; }
0339   DDName backCoolBarName() const { return ddname(m_BackCoolBarName); }
0340   double backCoolBarThick() const { return m_BackCoolBarThick; }
0341   DDMaterial backCoolBarMat() const { return ddmat(m_BackCoolBarMat); }
0342   DDName backCoolBarSSName() const { return ddname(m_BackCoolBarSSName); }
0343   double backCoolBarSSThick() const { return m_BackCoolBarSSThick; }
0344   DDMaterial backCoolBarSSMat() const { return ddmat(m_BackCoolBarSSMat); }
0345   DDName backCoolBarWaName() const { return ddname(m_BackCoolBarWaName); }
0346   double backCoolBarWaThick() const { return m_BackCoolBarWaThick; }
0347   DDMaterial backCoolBarWaMat() const { return ddmat(m_BackCoolBarWaMat); }
0348   double backCoolVFEHere() const { return m_BackCoolVFEHere; }
0349   DDName backCoolVFEName() const { return ddname(m_BackCoolVFEName); }
0350   DDMaterial backCoolVFEMat() const { return ddmat(m_BackCoolVFEMat); }
0351   DDName backVFEName() const { return ddname(m_BackVFEName); }
0352   DDMaterial backVFEMat() const { return ddmat(m_BackVFEMat); }
0353   const std::vector<double>& vecBackVFELyrThick() const { return m_vecBackVFELyrThick; }
0354   const std::vector<std::string>& vecBackVFELyrName() const { return m_vecBackVFELyrName; }
0355   const std::vector<std::string>& vecBackVFELyrMat() const { return m_vecBackVFELyrMat; }
0356   const std::vector<double>& vecBackCoolNSec() const { return m_vecBackCoolNSec; }
0357   const std::vector<double>& vecBackCoolSecSep() const { return m_vecBackCoolSecSep; }
0358   const std::vector<double>& vecBackCoolNPerSec() const { return m_vecBackCoolNPerSec; }
0359   double backCBStdSep() const { return m_BackCBStdSep; }
0360 
0361   double backCoolTankHere() const { return m_BackCoolTankHere; }
0362   const std::string& backCoolTankName() const { return m_BackCoolTankName; }
0363   double backCoolTankWidth() const { return m_BackCoolTankWidth; }
0364   double backCoolTankThick() const { return m_BackCoolTankThick; }
0365   DDMaterial backCoolTankMat() const { return ddmat(m_BackCoolTankMat); }
0366   const std::string& backCoolTankWaName() const { return m_BackCoolTankWaName; }
0367   double backCoolTankWaWidth() const { return m_BackCoolTankWaWidth; }
0368   DDMaterial backCoolTankWaMat() const { return ddmat(m_BackCoolTankWaMat); }
0369   const std::string& backBracketName() const { return m_BackBracketName; }
0370   double backBracketHeight() const { return m_BackBracketHeight; }
0371   DDMaterial backBracketMat() const { return ddmat(m_BackBracketMat); }
0372 
0373   double dryAirTubeHere() const { return m_DryAirTubeHere; }
0374   const std::string& dryAirTubeName() const { return m_DryAirTubeName; }
0375   double mBCoolTubeNum() const { return m_MBCoolTubeNum; }
0376   double dryAirTubeInnDiam() const { return m_DryAirTubeInnDiam; }
0377   double dryAirTubeOutDiam() const { return m_DryAirTubeOutDiam; }
0378   DDMaterial dryAirTubeMat() const { return ddmat(m_DryAirTubeMat); }
0379   double mBCoolTubeHere() const { return m_MBCoolTubeHere; }
0380   const std::string& mBCoolTubeName() const { return m_MBCoolTubeName; }
0381   double mBCoolTubeInnDiam() const { return m_MBCoolTubeInnDiam; }
0382   double mBCoolTubeOutDiam() const { return m_MBCoolTubeOutDiam; }
0383   DDMaterial mBCoolTubeMat() const { return ddmat(m_MBCoolTubeMat); }
0384   double mBManifHere() const { return m_MBManifHere; }
0385   DDName mBManifName() const { return ddname(m_MBManifName); }
0386   double mBManifInnDiam() const { return m_MBManifInnDiam; }
0387   double mBManifOutDiam() const { return m_MBManifOutDiam; }
0388   DDMaterial mBManifMat() const { return ddmat(m_MBManifMat); }
0389   double mBLyrHere() const { return m_MBLyrHere; }
0390   const std::vector<double>& vecMBLyrThick() const { return m_vecMBLyrThick; }
0391   const std::vector<std::string>& vecMBLyrName() const { return m_vecMBLyrName; }
0392   const std::vector<std::string>& vecMBLyrMat() const { return m_vecMBLyrMat; }
0393 
0394   //----------
0395 
0396   double pincerRodHere() const { return m_PincerRodHere; }
0397   DDName pincerRodName() const { return ddname(m_PincerRodName); }
0398   DDMaterial pincerRodMat() const { return ddmat(m_PincerRodMat); }
0399   std::vector<double> vecPincerRodAzimuth() const { return m_vecPincerRodAzimuth; }
0400   DDName pincerEnvName() const { return ddname(m_PincerEnvName); }
0401   DDMaterial pincerEnvMat() const { return ddmat(m_PincerEnvMat); }
0402   double pincerEnvWidth() const { return m_PincerEnvWidth; }
0403   double pincerEnvHeight() const { return m_PincerEnvHeight; }
0404   double pincerEnvLength() const { return m_PincerEnvLength; }
0405   std::vector<double> vecPincerEnvZOff() const { return m_vecPincerEnvZOff; }
0406 
0407   DDName pincerBlkName() const { return ddname(m_PincerBlkName); }
0408   DDMaterial pincerBlkMat() const { return ddmat(m_PincerBlkMat); }
0409   double pincerBlkLength() const { return m_PincerBlkLength; }
0410 
0411   DDName pincerShim1Name() const { return ddname(m_PincerShim1Name); }
0412   double pincerShimHeight() const { return m_PincerShimHeight; }
0413   DDName pincerShim2Name() const { return ddname(m_PincerShim2Name); }
0414   DDMaterial pincerShimMat() const { return ddmat(m_PincerShimMat); }
0415   double pincerShim1Width() const { return m_PincerShim1Width; }
0416   double pincerShim2Width() const { return m_PincerShim2Width; }
0417 
0418   DDName pincerCutName() const { return ddname(m_PincerCutName); }
0419   DDMaterial pincerCutMat() const { return ddmat(m_PincerCutMat); }
0420   double pincerCutWidth() const { return m_PincerCutWidth; }
0421   double pincerCutHeight() const { return m_PincerCutHeight; }
0422 
0423 protected:
0424 private:
0425   void web(unsigned int iWeb,
0426            double bWeb,
0427            double BWeb,
0428            double LWeb,
0429            double theta,
0430            const Pt3D& corner,
0431            const DDLogicalPart& logPar,
0432            double& zee,
0433            double side,
0434            double front,
0435            double delta,
0436            DDCompactView& cpv);
0437 
0438   std::string m_idNameSpace;  //Namespace of this and ALL sub-parts
0439 
0440   // Barrel volume
0441   std::string m_BarName;              // Barrel volume name
0442   std::string m_BarMat;               // Barrel material name
0443   std::vector<double> m_vecBarZPts;   // Barrel list of z pts
0444   std::vector<double> m_vecBarRMin;   // Barrel list of rMin pts
0445   std::vector<double> m_vecBarRMax;   // Barrel list of rMax pts
0446   std::vector<double> m_vecBarTran;   // Barrel translation
0447   std::vector<double> m_vecBarRota;   // Barrel rotation
0448   std::vector<double> m_vecBarRota2;  // 2nd Barrel rotation
0449   std::vector<double> m_vecBarRota3;  // 2nd Barrel rotation
0450   double m_BarPhiLo;                  // Barrel phi lo
0451   double m_BarPhiHi;                  // Barrel phi hi
0452   double m_BarHere;                   // Barrel presence flag
0453 
0454   // Supermodule volume
0455   std::string m_SpmName;              // Supermodule volume name
0456   std::string m_SpmMat;               // Supermodule material name
0457   std::vector<double> m_vecSpmZPts;   // Supermodule list of z pts
0458   std::vector<double> m_vecSpmRMin;   // Supermodule list of rMin pts
0459   std::vector<double> m_vecSpmRMax;   // Supermodule list of rMax pts
0460   std::vector<double> m_vecSpmTran;   // Supermodule translation
0461   std::vector<double> m_vecSpmRota;   // Supermodule rotation
0462   std::vector<double> m_vecSpmBTran;  // Base Supermodule translation
0463   std::vector<double> m_vecSpmBRota;  // Base Supermodule rotation
0464   unsigned int m_SpmNPerHalf;         // # Supermodules per half detector
0465   double m_SpmLowPhi;                 // Low   phi value of base supermodule
0466   double m_SpmDelPhi;                 // Delta phi value of base supermodule
0467   double m_SpmPhiOff;                 // Phi offset value supermodule
0468   std::vector<double> m_vecSpmHere;   // Bit saying if a supermodule is present or not
0469   std::string m_SpmCutName;           // Name of cut box
0470   double m_SpmCutThick;               // Box thickness
0471   int m_SpmCutShow;                   // Non-zero means show the box on display (testing only)
0472   std::vector<double> m_vecSpmCutTM;  // Translation for minus phi cut box
0473   std::vector<double> m_vecSpmCutTP;  // Translation for plus  phi cut box
0474   double m_SpmCutRM;                  // Rotation for minus phi cut box
0475   double m_SpmCutRP;                  // Rotation for plus  phi cut box
0476   double m_SpmExpThick;               // Thickness (x) of supermodule expansion box
0477   double m_SpmExpWide;                // Width     (y) of supermodule expansion box
0478   double m_SpmExpYOff;                // Offset    (y) of supermodule expansion box
0479   std::string m_SpmSideName;          // Supermodule Side Plate volume name
0480   std::string m_SpmSideMat;           // Supermodule Side Plate material name
0481   double m_SpmSideHigh;               // Side plate height
0482   double m_SpmSideThick;              // Side plate thickness
0483   double m_SpmSideYOffM;              // Side plate Y offset on minus phi side
0484   double m_SpmSideYOffP;              // Side plate Y offset on plus  phi side
0485 
0486   double m_NomCryDimAF;                  // Nominal crystal AF
0487   double m_NomCryDimLZ;                  // Nominal crystal LZ
0488   std::vector<double> m_vecNomCryDimBF;  // Nominal crystal BF
0489   std::vector<double> m_vecNomCryDimCF;  // Nominal crystal CF
0490   std::vector<double> m_vecNomCryDimAR;  // Nominal crystal AR
0491   std::vector<double> m_vecNomCryDimBR;  // Nominal crystal BR
0492   std::vector<double> m_vecNomCryDimCR;  // Nominal crystal CR
0493 
0494   double m_UnderAF;  // undershoot of AF
0495   double m_UnderLZ;  // undershoot of LZ
0496   double m_UnderBF;  // undershoot of BF
0497   double m_UnderCF;  // undershoot of CF
0498   double m_UnderAR;  // undershoot of AR
0499   double m_UnderBR;  // undershoot of BR
0500   double m_UnderCR;  // undershoot of CR
0501 
0502   double m_WallThAlv;                  // alveoli wall thickness
0503   double m_WrapThAlv;                  // wrapping thickness
0504   double m_ClrThAlv;                   // clearance thickness (nominal)
0505   std::vector<double> m_vecGapAlvEta;  // Extra clearance after each alveoli perp to crystal axis
0506 
0507   double m_WallFrAlv;  // alveoli wall frontage
0508   double m_WrapFrAlv;  // wrapping frontage
0509   double m_ClrFrAlv;   // clearance frontage (nominal)
0510 
0511   double m_WallReAlv;  // alveoli wall rearage
0512   double m_WrapReAlv;  // wrapping rearage
0513   double m_ClrReAlv;   // clearance rearage (nominal)
0514 
0515   unsigned int m_NCryTypes;      // number of crystal shapes
0516   unsigned int m_NCryPerAlvEta;  // number of crystals in eta per alveolus
0517 
0518   std::string m_CryName;   // string name of crystal volume
0519   std::string m_ClrName;   // string name of clearance volume
0520   std::string m_WrapName;  // string name of wrap volume
0521   std::string m_WallName;  // string name of wall volume
0522 
0523   std::string m_CryMat;   // string name of crystal material
0524   std::string m_ClrMat;   // string name of clearance material
0525   std::string m_WrapMat;  // string name of wrap material
0526   std::string m_WallMat;  // string name of wall material
0527 
0528   std::string m_capName;  // Capsule
0529   double m_capHere;       //
0530   std::string m_capMat;   //
0531   double m_capXSize;      //
0532   double m_capYSize;      //
0533   double m_capThick;      //
0534 
0535   std::string m_CERName;  // Ceramic
0536   std::string m_CERMat;   //
0537   double m_CERXSize;      //
0538   double m_CERYSize;      //
0539   double m_CERThick;      //
0540 
0541   std::string m_BSiName;  // Bulk Silicon
0542   std::string m_BSiMat;   //
0543   double m_BSiXSize;      //
0544   double m_BSiYSize;      //
0545   double m_BSiThick;      //
0546 
0547   std::string m_APDName;  // APD
0548   std::string m_APDMat;   //
0549   double m_APDSide;       //
0550   double m_APDThick;      //
0551   double m_APDZ;          //
0552   double m_APDX1;         //
0553   double m_APDX2;         //
0554 
0555   std::string m_ATJName;  // After-The-Junction
0556   std::string m_ATJMat;   //
0557   double m_ATJThick;      //
0558 
0559   std::string m_SGLName;  // APD-Silicone glue
0560   std::string m_SGLMat;   //
0561   double m_SGLThick;      //
0562 
0563   std::string m_AGLName;  // APD-Glue
0564   std::string m_AGLMat;   //
0565   double m_AGLThick;      //
0566 
0567   std::string m_ANDName;  // APD-Non-Depleted
0568   std::string m_ANDMat;   //
0569   double m_ANDThick;      //
0570 
0571   double m_WebHere;                    // here flag
0572   std::string m_WebPlName;             // string name of web plate volume
0573   std::string m_WebClrName;            // string name of web clearance volume
0574   std::string m_WebPlMat;              // string name of web material
0575   std::string m_WebClrMat;             // string name of web clearance material
0576   std::vector<double> m_vecWebPlTh;    // Thickness of web plates
0577   std::vector<double> m_vecWebClrTh;   // Thickness of total web clearance
0578   std::vector<double> m_vecWebLength;  // Length of web plate
0579 
0580   double m_IlyHere;                      // here flag
0581   std::string m_IlyName;                 // string name of inner layer volume
0582   double m_IlyPhiLow;                    // low phi of volumes
0583   double m_IlyDelPhi;                    // delta phi of ily
0584   std::vector<std::string> m_vecIlyMat;  // materials of inner layer volumes
0585   std::vector<double> m_vecIlyThick;     // Thicknesses of inner layer volumes
0586 
0587   std::string m_IlyPipeName;               // Cooling pipes
0588   double m_IlyPipeHere;                    //
0589   std::string m_IlyPipeMat;                //
0590   double m_IlyPipeOD;                      //
0591   double m_IlyPipeID;                      //
0592   std::vector<double> m_vecIlyPipeLength;  //
0593   std::vector<double> m_vecIlyPipeType;    //
0594   std::vector<double> m_vecIlyPipePhi;     //
0595   std::vector<double> m_vecIlyPipeZ;       //
0596 
0597   std::string m_IlyPTMName;            // PTM
0598   double m_IlyPTMHere;                 //
0599   std::string m_IlyPTMMat;             //
0600   double m_IlyPTMWidth;                //
0601   double m_IlyPTMLength;               //
0602   double m_IlyPTMHeight;               //
0603   std::vector<double> m_vecIlyPTMZ;    //
0604   std::vector<double> m_vecIlyPTMPhi;  //
0605 
0606   std::string m_IlyFanOutName;            // FanOut
0607   double m_IlyFanOutHere;                 //
0608   std::string m_IlyFanOutMat;             //
0609   double m_IlyFanOutWidth;                //
0610   double m_IlyFanOutLength;               //
0611   double m_IlyFanOutHeight;               //
0612   std::vector<double> m_vecIlyFanOutZ;    //
0613   std::vector<double> m_vecIlyFanOutPhi;  //
0614   std::string m_IlyDiffName;              // Diffuser
0615   std::string m_IlyDiffMat;               //
0616   double m_IlyDiffOff;                    //
0617   double m_IlyDiffLength;                 //
0618   std::string m_IlyBndlName;              // Fiber bundle
0619   std::string m_IlyBndlMat;               //
0620   double m_IlyBndlOff;                    //
0621   double m_IlyBndlLength;                 //
0622   std::string m_IlyFEMName;               // FEM
0623   std::string m_IlyFEMMat;                //
0624   double m_IlyFEMWidth;                   //
0625   double m_IlyFEMLength;                  //
0626   double m_IlyFEMHeight;                  //
0627   std::vector<double> m_vecIlyFEMZ;       //
0628   std::vector<double> m_vecIlyFEMPhi;     //
0629 
0630   std::string m_HawRName;      // string name of half-alveolar wedge
0631   std::string m_FawName;       // string name of full-alveolar wedge
0632   double m_FawHere;            // here flag
0633   double m_HawRHBIG;           // height at big end of half alveolar wedge
0634   double m_HawRhsml;           // height at small end of half alveolar wedge
0635   double m_HawRCutY;           // x dim of hawR cut box
0636   double m_HawRCutZ;           // y dim of hawR cut box
0637   double m_HawRCutDelY;        // y offset of hawR cut box from top of HAW
0638   double m_HawYOffCry;         // Y offset of crystal wrt HAW at front
0639   unsigned int m_NFawPerSupm;  // Number of Full Alv. Wedges per supermodule
0640   double m_FawPhiOff;          // Phi offset for FAW placement
0641   double m_FawDelPhi;          // Phi delta for FAW placement
0642   double m_FawPhiRot;          // Phi rotation of FAW about own axis prior to placement
0643   double m_FawRadOff;          // Radial offset for FAW placement
0644 
0645   double m_GridHere;       // here flag
0646   std::string m_GridName;  // Grid name
0647   std::string m_GridMat;   // Grid material
0648   double m_GridThick;      // Grid Thickness
0649 
0650   double m_BackXOff;  //
0651   double m_BackYOff;  //
0652 
0653   double m_BackHere;                      // here flag
0654   std::string m_BackSideName;             // Back Sides
0655   double m_BackSideHere;                  //
0656   double m_BackSideLength;                //
0657   double m_BackSideHeight;                //
0658   double m_BackSideWidth;                 //
0659   double m_BackSideYOff1;                 //
0660   double m_BackSideYOff2;                 //
0661   double m_BackSideAngle;                 //
0662   std::string m_BackSideMat;              //
0663   std::string m_BackPlateName;            // back plate
0664   double m_BackPlateHere;                 //
0665   double m_BackPlateLength;               //
0666   double m_BackPlateThick;                //
0667   double m_BackPlateWidth;                //
0668   std::string m_BackPlateMat;             //
0669   std::string m_BackPlate2Name;           // back plate2
0670   double m_BackPlate2Thick;               //
0671   std::string m_BackPlate2Mat;            //
0672   std::string m_GrilleName;               // grille
0673   double m_GrilleHere;                    //
0674   double m_GrilleThick;                   //
0675   double m_GrilleWidth;                   //
0676   double m_GrilleZSpace;                  //
0677   std::string m_GrilleMat;                //
0678   std::vector<double> m_vecGrilleHeight;  //
0679   std::vector<double> m_vecGrilleZOff;    //
0680 
0681   std::string m_GrEdgeSlotName;  // Slots in Grille
0682   std::string m_GrEdgeSlotMat;   //
0683   double m_GrEdgeSlotHere;       //
0684   double m_GrEdgeSlotHeight;     //
0685   double m_GrEdgeSlotWidth;      //
0686 
0687   std::string m_GrMidSlotName;               // Slots in Grille
0688   std::string m_GrMidSlotMat;                //
0689   double m_GrMidSlotHere;                    //
0690   double m_GrMidSlotWidth;                   //
0691   double m_GrMidSlotXOff;                    //
0692   std::vector<double> m_vecGrMidSlotHeight;  //
0693 
0694   double m_BackPipeHere;                   // here flag
0695   std::string m_BackPipeName;              //
0696   std::vector<double> m_vecBackPipeDiam;   // pipes
0697   std::vector<double> m_vecBackPipeThick;  // pipes
0698   std::string m_BackPipeMat;               //
0699   std::string m_BackPipeWaterMat;          //
0700 
0701   std::vector<std::string> m_vecBackCoolName;  // cooling circuits
0702   double m_BackCoolHere;                       // here flag
0703   double m_BackCoolBarHere;                    // here flag
0704   double m_BackCoolBarWidth;                   //
0705   double m_BackCoolBarHeight;                  //
0706   std::string m_BackCoolMat;
0707   std::string m_BackCoolBarName;  // cooling bar
0708   double m_BackCoolBarThick;      //
0709   std::string m_BackCoolBarMat;
0710   std::string m_BackCoolBarSSName;  // cooling bar tubing
0711   double m_BackCoolBarSSThick;      //
0712   std::string m_BackCoolBarSSMat;
0713   std::string m_BackCoolBarWaName;  // cooling bar water
0714   double m_BackCoolBarWaThick;      //
0715   std::string m_BackCoolBarWaMat;
0716   double m_BackCoolVFEHere;  // here flag
0717   std::string m_BackCoolVFEName;
0718   std::string m_BackCoolVFEMat;
0719   std::string m_BackVFEName;
0720   std::string m_BackVFEMat;
0721   std::vector<double> m_vecBackVFELyrThick;      //
0722   std::vector<std::string> m_vecBackVFELyrName;  //
0723   std::vector<std::string> m_vecBackVFELyrMat;   //
0724   std::vector<double> m_vecBackCoolNSec;         //
0725   std::vector<double> m_vecBackCoolSecSep;       //
0726   std::vector<double> m_vecBackCoolNPerSec;      //
0727   double m_BackMiscHere;                         // here flag
0728   std::vector<double> m_vecBackMiscThick;        // misc materials
0729   std::vector<std::string> m_vecBackMiscName;    //
0730   std::vector<std::string> m_vecBackMiscMat;     //
0731   double m_BackCBStdSep;                         //
0732 
0733   double m_PatchPanelHere;                        // here flag
0734   std::string m_PatchPanelName;                   //
0735   std::vector<double> m_vecPatchPanelThick;       // patch panel materials
0736   std::vector<std::string> m_vecPatchPanelNames;  //
0737   std::vector<std::string> m_vecPatchPanelMat;    //
0738 
0739   double m_BackCoolTankHere;         // here flag
0740   std::string m_BackCoolTankName;    // service tank
0741   double m_BackCoolTankWidth;        //
0742   double m_BackCoolTankThick;        //
0743   std::string m_BackCoolTankMat;     //
0744   std::string m_BackCoolTankWaName;  //
0745   double m_BackCoolTankWaWidth;      //
0746   std::string m_BackCoolTankWaMat;   //
0747   std::string m_BackBracketName;     //
0748   double m_BackBracketHeight;        //
0749   std::string m_BackBracketMat;      //
0750 
0751   double m_DryAirTubeHere;                  // here flag
0752   std::string m_DryAirTubeName;             // dry air tube
0753   unsigned int m_MBCoolTubeNum;             //
0754   double m_DryAirTubeInnDiam;               //
0755   double m_DryAirTubeOutDiam;               //
0756   std::string m_DryAirTubeMat;              //
0757   double m_MBCoolTubeHere;                  // here flag
0758   std::string m_MBCoolTubeName;             // mothr bd cooling tube
0759   double m_MBCoolTubeInnDiam;               //
0760   double m_MBCoolTubeOutDiam;               //
0761   std::string m_MBCoolTubeMat;              //
0762   double m_MBManifHere;                     // here flag
0763   std::string m_MBManifName;                //mother bd manif
0764   double m_MBManifInnDiam;                  //
0765   double m_MBManifOutDiam;                  //
0766   std::string m_MBManifMat;                 //
0767   double m_MBLyrHere;                       // here flag
0768   std::vector<double> m_vecMBLyrThick;      // mother bd lyrs
0769   std::vector<std::string> m_vecMBLyrName;  //
0770   std::vector<std::string> m_vecMBLyrMat;   //
0771 
0772   //-------------------------------------------------------------------
0773 
0774   double m_PincerRodHere;                     // here flag
0775   std::string m_PincerRodName;                // pincer rod
0776   std::string m_PincerRodMat;                 //
0777   std::vector<double> m_vecPincerRodAzimuth;  //
0778 
0779   std::string m_PincerEnvName;             // pincer envelope
0780   std::string m_PincerEnvMat;              //
0781   double m_PincerEnvWidth;                 //
0782   double m_PincerEnvHeight;                //
0783   double m_PincerEnvLength;                //
0784   std::vector<double> m_vecPincerEnvZOff;  //
0785 
0786   std::string m_PincerBlkName;  // pincer block
0787   std::string m_PincerBlkMat;   //
0788   double m_PincerBlkLength;     //
0789 
0790   std::string m_PincerShim1Name;  // pincer shim
0791   double m_PincerShimHeight;      //
0792   std::string m_PincerShim2Name;  //
0793   std::string m_PincerShimMat;    //
0794   double m_PincerShim1Width;      //
0795   double m_PincerShim2Width;      //
0796 
0797   std::string m_PincerCutName;  // pincer block
0798   std::string m_PincerCutMat;   //
0799   double m_PincerCutWidth;      //
0800   double m_PincerCutHeight;     //
0801 };
0802 
0803 namespace std {}
0804 using namespace std;
0805 
0806 DDEcalBarrelNewAlgo::DDEcalBarrelNewAlgo()
0807     : m_idNameSpace(""),
0808       m_BarName(""),
0809       m_BarMat(""),
0810       m_vecBarZPts(),
0811       m_vecBarRMin(),
0812       m_vecBarRMax(),
0813       m_vecBarTran(),
0814       m_vecBarRota(),
0815       m_vecBarRota2(),
0816       m_vecBarRota3(),
0817       m_BarPhiLo(0),
0818       m_BarPhiHi(0),
0819       m_BarHere(0),
0820       m_SpmName(""),
0821       m_SpmMat(""),
0822       m_vecSpmZPts(),
0823       m_vecSpmRMin(),
0824       m_vecSpmRMax(),
0825       m_vecSpmTran(),
0826       m_vecSpmRota(),
0827       m_vecSpmBTran(),
0828       m_vecSpmBRota(),
0829       m_SpmNPerHalf(0),
0830       m_SpmLowPhi(0),
0831       m_SpmDelPhi(0),
0832       m_SpmPhiOff(0),
0833       m_vecSpmHere(),
0834       m_SpmCutName(""),
0835       m_SpmCutThick(0),
0836       m_SpmCutShow(0),
0837       m_vecSpmCutTM(),
0838       m_vecSpmCutTP(),
0839       m_SpmCutRM(0),
0840       m_SpmCutRP(0),
0841       m_SpmExpThick(0),
0842       m_SpmExpWide(0),
0843       m_SpmExpYOff(0),
0844       m_SpmSideName(""),
0845       m_SpmSideMat(""),
0846       m_SpmSideHigh(0),
0847       m_SpmSideThick(0),
0848       m_SpmSideYOffM(0),
0849       m_SpmSideYOffP(0),
0850       m_NomCryDimAF(0),
0851       m_NomCryDimLZ(0),
0852       m_vecNomCryDimBF(),
0853       m_vecNomCryDimCF(),
0854       m_vecNomCryDimAR(),
0855       m_vecNomCryDimBR(),
0856       m_vecNomCryDimCR(),
0857       m_UnderAF(0),
0858       m_UnderLZ(0),
0859       m_UnderBF(0),
0860       m_UnderCF(0),
0861       m_UnderAR(0),
0862       m_UnderBR(0),
0863       m_UnderCR(0),
0864       m_WallThAlv(0),
0865       m_WrapThAlv(0),
0866       m_ClrThAlv(0),
0867       m_vecGapAlvEta(),
0868       m_WallFrAlv(0),
0869       m_WrapFrAlv(0),
0870       m_ClrFrAlv(0),
0871       m_WallReAlv(0),
0872       m_WrapReAlv(0),
0873       m_ClrReAlv(0),
0874       m_NCryTypes(0),
0875       m_NCryPerAlvEta(0),
0876       m_CryName(""),
0877       m_ClrName(""),
0878       m_WrapName(""),
0879       m_WallName(""),
0880       m_CryMat(""),
0881       m_ClrMat(""),
0882       m_WrapMat(""),
0883       m_WallMat(""),
0884 
0885       m_capName(""),
0886       m_capHere(0),
0887       m_capMat(""),
0888       m_capXSize(0),
0889       m_capYSize(0),
0890       m_capThick(0),
0891 
0892       m_CERName(""),
0893       m_CERMat(""),
0894       m_CERXSize(0),
0895       m_CERYSize(0),
0896       m_CERThick(0),
0897 
0898       m_BSiName(""),
0899       m_BSiMat(""),
0900       m_BSiXSize(0),
0901       m_BSiYSize(0),
0902       m_BSiThick(0),
0903 
0904       m_APDName(""),
0905       m_APDMat(""),
0906       m_APDSide(0),
0907       m_APDThick(0),
0908       m_APDZ(0),
0909       m_APDX1(0),
0910       m_APDX2(0),
0911 
0912       m_ATJName(""),
0913       m_ATJMat(""),
0914       m_ATJThick(0),
0915 
0916       m_SGLName(""),
0917       m_SGLMat(""),
0918       m_SGLThick(0),
0919 
0920       m_AGLName(""),
0921       m_AGLMat(""),
0922       m_AGLThick(0),
0923 
0924       m_ANDName(""),
0925       m_ANDMat(""),
0926       m_ANDThick(0),
0927 
0928       m_WebHere(0),
0929       m_WebPlName(""),
0930       m_WebClrName(""),
0931       m_WebPlMat(""),
0932       m_WebClrMat(""),
0933       m_vecWebPlTh(),
0934       m_vecWebClrTh(),
0935       m_vecWebLength(),
0936       m_IlyHere(0),
0937       m_IlyName(),
0938       m_IlyPhiLow(0),
0939       m_IlyDelPhi(0),
0940       m_vecIlyMat(),
0941       m_vecIlyThick(),
0942       m_IlyPipeName(""),
0943       m_IlyPipeHere(0),
0944       m_IlyPipeMat(""),
0945       m_IlyPipeOD(0),
0946       m_IlyPipeID(0),
0947       m_vecIlyPipeLength(),
0948       m_vecIlyPipeType(),
0949       m_vecIlyPipePhi(),
0950       m_vecIlyPipeZ(),
0951       m_IlyPTMName(""),
0952       m_IlyPTMHere(0),
0953       m_IlyPTMMat(""),
0954       m_IlyPTMWidth(0),
0955       m_IlyPTMLength(0),
0956       m_IlyPTMHeight(0),
0957       m_vecIlyPTMZ(),
0958       m_vecIlyPTMPhi(),
0959       m_IlyFanOutName(""),
0960       m_IlyFanOutHere(0),
0961       m_IlyFanOutMat(""),
0962       m_IlyFanOutWidth(0),
0963       m_IlyFanOutLength(0),
0964       m_IlyFanOutHeight(0),
0965       m_vecIlyFanOutZ(),
0966       m_vecIlyFanOutPhi(),
0967       m_IlyDiffName(""),
0968       m_IlyDiffMat(""),
0969       m_IlyDiffOff(0),
0970       m_IlyDiffLength(0),
0971       m_IlyBndlName(""),
0972       m_IlyBndlMat(""),
0973       m_IlyBndlOff(0),
0974       m_IlyBndlLength(0),
0975       m_IlyFEMName(""),
0976       m_IlyFEMMat(""),
0977       m_IlyFEMWidth(0),
0978       m_IlyFEMLength(0),
0979       m_IlyFEMHeight(0),
0980       m_vecIlyFEMZ(),
0981       m_vecIlyFEMPhi(),
0982       m_HawRName(""),
0983       m_FawName(""),
0984       m_FawHere(0),
0985       m_HawRHBIG(0),
0986       m_HawRhsml(0),
0987       m_HawRCutY(0),
0988       m_HawRCutZ(0),
0989       m_HawRCutDelY(0),
0990       m_HawYOffCry(0),
0991       m_NFawPerSupm(0),
0992       m_FawPhiOff(0),
0993       m_FawDelPhi(0),
0994       m_FawPhiRot(0),
0995       m_FawRadOff(0),
0996       m_GridHere(0),
0997       m_GridName(""),
0998       m_GridMat(""),
0999       m_GridThick(0),
1000       m_BackXOff(0),
1001       m_BackYOff(0),
1002       m_BackHere(0),
1003       m_BackSideName(""),
1004       m_BackSideHere(0),
1005       m_BackSideLength(0),
1006       m_BackSideHeight(0),
1007       m_BackSideWidth(0),
1008       m_BackSideYOff1(0),
1009       m_BackSideYOff2(0),
1010       m_BackSideAngle(0),
1011       m_BackSideMat(""),
1012       m_BackPlateName(""),
1013       m_BackPlateHere(0),
1014       m_BackPlateLength(0),
1015       m_BackPlateThick(0),
1016       m_BackPlateWidth(0),
1017       m_BackPlateMat(""),
1018       m_BackPlate2Name(""),
1019       m_BackPlate2Thick(0),
1020       m_BackPlate2Mat(""),
1021       m_GrilleName(""),
1022       m_GrilleHere(0),
1023       m_GrilleThick(0),
1024       m_GrilleWidth(0),
1025       m_GrilleZSpace(0),
1026       m_GrilleMat(""),
1027       m_vecGrilleHeight(),
1028       m_vecGrilleZOff(),
1029       m_GrEdgeSlotName(""),
1030       m_GrEdgeSlotMat(""),
1031       m_GrEdgeSlotHere(0),
1032       m_GrEdgeSlotHeight(0),
1033       m_GrEdgeSlotWidth(0),
1034       m_GrMidSlotName(""),
1035       m_GrMidSlotMat(""),
1036       m_GrMidSlotHere(0),
1037       m_GrMidSlotWidth(0),
1038       m_GrMidSlotXOff(0),
1039       m_vecGrMidSlotHeight(),
1040       m_BackPipeHere(0),
1041       m_BackPipeName(""),
1042       m_vecBackPipeDiam(),
1043       m_vecBackPipeThick(),
1044       m_BackPipeMat(""),
1045       m_BackPipeWaterMat(""),
1046 
1047       m_vecBackCoolName(),
1048       m_BackCoolHere(0),
1049       m_BackCoolBarHere(0),
1050       m_BackCoolBarWidth(0),
1051       m_BackCoolBarHeight(0),
1052       m_BackCoolMat(""),
1053       m_BackCoolBarName(""),
1054       m_BackCoolBarThick(0),
1055       m_BackCoolBarMat(""),
1056       m_BackCoolBarSSName(""),
1057       m_BackCoolBarSSThick(0),
1058       m_BackCoolBarSSMat(""),
1059       m_BackCoolBarWaName(""),
1060       m_BackCoolBarWaThick(0),
1061       m_BackCoolBarWaMat(""),
1062       m_BackCoolVFEHere(0),
1063       m_BackCoolVFEName(""),
1064       m_BackCoolVFEMat(""),
1065       m_BackVFEName(""),
1066       m_BackVFEMat(""),
1067       m_vecBackVFELyrThick(),
1068       m_vecBackVFELyrName(),
1069       m_vecBackVFELyrMat(),
1070       m_vecBackCoolNSec(),
1071       m_vecBackCoolSecSep(),
1072       m_vecBackCoolNPerSec(),
1073 
1074       m_BackMiscHere(0),
1075       m_vecBackMiscThick(),
1076       m_vecBackMiscName(),
1077       m_vecBackMiscMat(),
1078       m_BackCBStdSep(0),
1079       m_PatchPanelHere(0),
1080       m_PatchPanelName(""),
1081       m_vecPatchPanelThick(),
1082       m_vecPatchPanelNames(),
1083       m_vecPatchPanelMat(),
1084       m_BackCoolTankHere(0),
1085       m_BackCoolTankName(""),
1086       m_BackCoolTankWidth(0),
1087       m_BackCoolTankThick(0),
1088       m_BackCoolTankMat(""),
1089       m_BackCoolTankWaName(""),
1090       m_BackCoolTankWaWidth(0),
1091       m_BackCoolTankWaMat(""),
1092       m_BackBracketName(""),
1093       m_BackBracketHeight(0),
1094       m_BackBracketMat(""),
1095 
1096       m_DryAirTubeHere(0),
1097       m_DryAirTubeName(""),
1098       m_MBCoolTubeNum(0),
1099       m_DryAirTubeInnDiam(0),
1100       m_DryAirTubeOutDiam(0),
1101       m_DryAirTubeMat(""),
1102       m_MBCoolTubeHere(0),
1103       m_MBCoolTubeName(""),
1104       m_MBCoolTubeInnDiam(0),
1105       m_MBCoolTubeOutDiam(0),
1106       m_MBCoolTubeMat(""),
1107       m_MBManifHere(0),
1108       m_MBManifName(""),
1109       m_MBManifInnDiam(0),
1110       m_MBManifOutDiam(0),
1111       m_MBManifMat(""),
1112       m_MBLyrHere(0),
1113       m_vecMBLyrThick(0),
1114       m_vecMBLyrName(),
1115       m_vecMBLyrMat(),
1116 
1117       m_PincerRodHere(0),
1118       m_PincerRodName(""),
1119       m_PincerRodMat(""),
1120       m_vecPincerRodAzimuth(),
1121       m_PincerEnvName(""),
1122       m_PincerEnvMat(""),
1123       m_PincerEnvWidth(0),
1124       m_PincerEnvHeight(0),
1125       m_PincerEnvLength(0),
1126       m_vecPincerEnvZOff(),
1127       m_PincerBlkName(""),
1128       m_PincerBlkMat(""),
1129       m_PincerBlkLength(0),
1130       m_PincerShim1Name(""),
1131       m_PincerShimHeight(0),
1132       m_PincerShim2Name(""),
1133       m_PincerShimMat(""),
1134       m_PincerShim1Width(0),
1135       m_PincerShim2Width(0),
1136       m_PincerCutName(""),
1137       m_PincerCutMat(""),
1138       m_PincerCutWidth(0),
1139       m_PincerCutHeight(0)
1140 
1141 {
1142 #ifdef EDM_ML_DEBUG
1143   edm::LogVerbatim("EcalGeom") << "DDEcalBarrelAlgo info: Creating an instance";
1144 #endif
1145 }
1146 
1147 DDEcalBarrelNewAlgo::~DDEcalBarrelNewAlgo() {}
1148 
1149 void DDEcalBarrelNewAlgo::initialize(const DDNumericArguments& nArgs,
1150                                      const DDVectorArguments& vArgs,
1151                                      const DDMapArguments& /*mArgs*/,
1152                                      const DDStringArguments& sArgs,
1153                                      const DDStringVectorArguments& vsArgs) {
1154 #ifdef EDM_ML_DEBUG
1155   edm::LogVerbatim("EcalGeom") << "DDEcalBarrelAlgo info: Initialize";
1156 #endif
1157   m_idNameSpace = DDCurrentNamespace::ns();
1158   // TRICK!
1159   m_idNameSpace = parent().name().ns();
1160   // barrel parent volume
1161   m_BarName = sArgs["BarName"];
1162   m_BarMat = sArgs["BarMat"];
1163   m_vecBarZPts = vArgs["BarZPts"];
1164   m_vecBarRMin = vArgs["BarRMin"];
1165   m_vecBarRMax = vArgs["BarRMax"];
1166   m_vecBarTran = vArgs["BarTran"];
1167   m_vecBarRota = vArgs["BarRota"];
1168   m_vecBarRota2 = vArgs["BarRota2"];
1169   m_vecBarRota3 = vArgs["BarRota3"];
1170   m_BarPhiLo = nArgs["BarPhiLo"];
1171   m_BarPhiHi = nArgs["BarPhiHi"];
1172   m_BarHere = nArgs["BarHere"];
1173 
1174   m_SpmName = sArgs["SpmName"];
1175   m_SpmMat = sArgs["SpmMat"];
1176   m_vecSpmZPts = vArgs["SpmZPts"];
1177   m_vecSpmRMin = vArgs["SpmRMin"];
1178   m_vecSpmRMax = vArgs["SpmRMax"];
1179   m_vecSpmTran = vArgs["SpmTran"];
1180   m_vecSpmRota = vArgs["SpmRota"];
1181   m_vecSpmBTran = vArgs["SpmBTran"];
1182   m_vecSpmBRota = vArgs["SpmBRota"];
1183   m_SpmNPerHalf = static_cast<unsigned int>(nArgs["SpmNPerHalf"]);
1184   m_SpmLowPhi = nArgs["SpmLowPhi"];
1185   m_SpmDelPhi = nArgs["SpmDelPhi"];
1186   m_SpmPhiOff = nArgs["SpmPhiOff"];
1187   m_vecSpmHere = vArgs["SpmHere"];
1188   m_SpmCutName = sArgs["SpmCutName"];
1189   m_SpmCutThick = nArgs["SpmCutThick"];
1190   m_SpmCutShow = int(nArgs["SpmCutShow"]);
1191   m_vecSpmCutTM = vArgs["SpmCutTM"];
1192   m_vecSpmCutTP = vArgs["SpmCutTP"];
1193   m_SpmCutRM = nArgs["SpmCutRM"];
1194   m_SpmCutRP = nArgs["SpmCutRP"];
1195   m_SpmExpThick = nArgs["SpmExpThick"];
1196   m_SpmExpWide = nArgs["SpmExpWide"];
1197   m_SpmExpYOff = nArgs["SpmExpYOff"];
1198   m_SpmSideName = sArgs["SpmSideName"];
1199   m_SpmSideMat = sArgs["SpmSideMat"];
1200   m_SpmSideHigh = nArgs["SpmSideHigh"];
1201   m_SpmSideThick = nArgs["SpmSideThick"];
1202   m_SpmSideYOffM = nArgs["SpmSideYOffM"];
1203   m_SpmSideYOffP = nArgs["SpmSideYOffP"];
1204 
1205   m_NomCryDimAF = nArgs["NomCryDimAF"];
1206   m_NomCryDimLZ = nArgs["NomCryDimLZ"];
1207   m_vecNomCryDimBF = vArgs["NomCryDimBF"];
1208   m_vecNomCryDimCF = vArgs["NomCryDimCF"];
1209   m_vecNomCryDimAR = vArgs["NomCryDimAR"];
1210   m_vecNomCryDimBR = vArgs["NomCryDimBR"];
1211   m_vecNomCryDimCR = vArgs["NomCryDimCR"];
1212 
1213   m_UnderAF = nArgs["UnderAF"];
1214   m_UnderLZ = nArgs["UnderLZ"];
1215   m_UnderBF = nArgs["UnderBF"];
1216   m_UnderCF = nArgs["UnderCF"];
1217   m_UnderAR = nArgs["UnderAR"];
1218   m_UnderBR = nArgs["UnderBR"];
1219   m_UnderCR = nArgs["UnderCR"];
1220 
1221   m_WallThAlv = nArgs["WallThAlv"];
1222   m_WrapThAlv = nArgs["WrapThAlv"];
1223   m_ClrThAlv = nArgs["ClrThAlv"];
1224   m_vecGapAlvEta = vArgs["GapAlvEta"];
1225 
1226   m_WallFrAlv = nArgs["WallFrAlv"];
1227   m_WrapFrAlv = nArgs["WrapFrAlv"];
1228   m_ClrFrAlv = nArgs["ClrFrAlv"];
1229 
1230   m_WallReAlv = nArgs["WallReAlv"];
1231   m_WrapReAlv = nArgs["WrapReAlv"];
1232   m_ClrReAlv = nArgs["ClrReAlv"];
1233 
1234   m_NCryTypes = static_cast<unsigned int>(nArgs["NCryTypes"]);
1235   m_NCryPerAlvEta = static_cast<unsigned int>(nArgs["NCryPerAlvEta"]);
1236 
1237   m_CryName = sArgs["CryName"];
1238   m_ClrName = sArgs["ClrName"];
1239   m_WrapName = sArgs["WrapName"];
1240   m_WallName = sArgs["WallName"];
1241 
1242   m_CryMat = sArgs["CryMat"];
1243   m_ClrMat = sArgs["ClrMat"];
1244   m_WrapMat = sArgs["WrapMat"];
1245   m_WallMat = sArgs["WallMat"];
1246 
1247   m_capName = sArgs["CapName"];
1248   m_capHere = nArgs["CapHere"];
1249   m_capMat = sArgs["CapMat"];
1250   m_capXSize = nArgs["CapXSize"];
1251   m_capYSize = nArgs["CapYSize"];
1252   m_capThick = nArgs["CapThick"];
1253 
1254   m_CERName = sArgs["CerName"];
1255   m_CERMat = sArgs["CerMat"];
1256   m_CERXSize = nArgs["CerXSize"];
1257   m_CERYSize = nArgs["CerYSize"];
1258   m_CERThick = nArgs["CerThick"];
1259 
1260   m_BSiName = sArgs["BSiName"];
1261   m_BSiMat = sArgs["BSiMat"];
1262   m_BSiXSize = nArgs["BSiXSize"];
1263   m_BSiYSize = nArgs["BSiYSize"];
1264   m_BSiThick = nArgs["BSiThick"];
1265 
1266   m_APDName = sArgs["APDName"];
1267   m_APDMat = sArgs["APDMat"];
1268   m_APDSide = nArgs["APDSide"];
1269   m_APDThick = nArgs["APDThick"];
1270   m_APDZ = nArgs["APDZ"];
1271   m_APDX1 = nArgs["APDX1"];
1272   m_APDX2 = nArgs["APDX2"];
1273 
1274   m_ATJName = sArgs["ATJName"];
1275   m_ATJMat = sArgs["ATJMat"];
1276   m_ATJThick = nArgs["ATJThick"];
1277 
1278   m_SGLName = sArgs["SGLName"];
1279   m_SGLMat = sArgs["SGLMat"];
1280   m_SGLThick = nArgs["SGLThick"];
1281 
1282   m_AGLName = sArgs["AGLName"];
1283   m_AGLMat = sArgs["AGLMat"];
1284   m_AGLThick = nArgs["AGLThick"];
1285 
1286   m_ANDName = sArgs["ANDName"];
1287   m_ANDMat = sArgs["ANDMat"];
1288   m_ANDThick = nArgs["ANDThick"];
1289 
1290   m_WebHere = nArgs["WebHere"];
1291   m_WebPlName = sArgs["WebPlName"];
1292   m_WebClrName = sArgs["WebClrName"];
1293   m_WebPlMat = sArgs["WebPlMat"];
1294   m_WebClrMat = sArgs["WebClrMat"];
1295   m_vecWebPlTh = vArgs["WebPlTh"];
1296   m_vecWebClrTh = vArgs["WebClrTh"];
1297   m_vecWebLength = vArgs["WebLength"];
1298 
1299   m_IlyHere = nArgs["IlyHere"];
1300   m_IlyName = sArgs["IlyName"];
1301   m_IlyPhiLow = nArgs["IlyPhiLow"];
1302   m_IlyDelPhi = nArgs["IlyDelPhi"];
1303   m_vecIlyMat = vsArgs["IlyMat"];
1304   m_vecIlyThick = vArgs["IlyThick"];
1305 
1306   m_IlyPipeName = sArgs["IlyPipeName"];
1307   m_IlyPipeHere = nArgs["IlyPipeHere"];
1308   m_IlyPipeMat = sArgs["IlyPipeMat"];
1309   m_IlyPipeOD = nArgs["IlyPipeOD"];
1310   m_IlyPipeID = nArgs["IlyPipeID"];
1311   m_vecIlyPipeLength = vArgs["IlyPipeLength"];
1312   m_vecIlyPipeType = vArgs["IlyPipeType"];
1313   m_vecIlyPipePhi = vArgs["IlyPipePhi"];
1314   m_vecIlyPipeZ = vArgs["IlyPipeZ"];
1315 
1316   m_IlyPTMName = sArgs["IlyPTMName"];
1317   m_IlyPTMHere = nArgs["IlyPTMHere"];
1318   m_IlyPTMMat = sArgs["IlyPTMMat"];
1319   m_IlyPTMWidth = nArgs["IlyPTMWidth"];
1320   m_IlyPTMLength = nArgs["IlyPTMLength"];
1321   m_IlyPTMHeight = nArgs["IlyPTMHeight"];
1322   m_vecIlyPTMZ = vArgs["IlyPTMZ"];
1323   m_vecIlyPTMPhi = vArgs["IlyPTMPhi"];
1324 
1325   m_IlyFanOutName = sArgs["IlyFanOutName"];
1326   m_IlyFanOutHere = nArgs["IlyFanOutHere"];
1327   m_IlyFanOutMat = sArgs["IlyFanOutMat"];
1328   m_IlyFanOutWidth = nArgs["IlyFanOutWidth"];
1329   m_IlyFanOutLength = nArgs["IlyFanOutLength"];
1330   m_IlyFanOutHeight = nArgs["IlyFanOutHeight"];
1331   m_vecIlyFanOutZ = vArgs["IlyFanOutZ"];
1332   m_vecIlyFanOutPhi = vArgs["IlyFanOutPhi"];
1333   m_IlyDiffName = sArgs["IlyDiffName"];
1334   m_IlyDiffMat = sArgs["IlyDiffMat"];
1335   m_IlyDiffOff = nArgs["IlyDiffOff"];
1336   m_IlyDiffLength = nArgs["IlyDiffLength"];
1337   m_IlyBndlName = sArgs["IlyBndlName"];
1338   m_IlyBndlMat = sArgs["IlyBndlMat"];
1339   m_IlyBndlOff = nArgs["IlyBndlOff"];
1340   m_IlyBndlLength = nArgs["IlyBndlLength"];
1341   m_IlyFEMName = sArgs["IlyFEMName"];
1342   m_IlyFEMMat = sArgs["IlyFEMMat"];
1343   m_IlyFEMWidth = nArgs["IlyFEMWidth"];
1344   m_IlyFEMLength = nArgs["IlyFEMLength"];
1345   m_IlyFEMHeight = nArgs["IlyFEMHeight"];
1346   m_vecIlyFEMZ = vArgs["IlyFEMZ"];
1347   m_vecIlyFEMPhi = vArgs["IlyFEMPhi"];
1348 
1349   m_HawRName = sArgs["HawRName"];
1350   m_FawName = sArgs["FawName"];
1351   m_FawHere = nArgs["FawHere"];
1352   m_HawRHBIG = nArgs["HawRHBIG"];
1353   m_HawRhsml = nArgs["HawRhsml"];
1354   m_HawRCutY = nArgs["HawRCutY"];
1355   m_HawRCutZ = nArgs["HawRCutZ"];
1356   m_HawRCutDelY = nArgs["HawRCutDelY"];
1357   m_HawYOffCry = nArgs["HawYOffCry"];
1358 
1359   m_NFawPerSupm = static_cast<unsigned int>(nArgs["NFawPerSupm"]);
1360   m_FawPhiOff = nArgs["FawPhiOff"];
1361   m_FawDelPhi = nArgs["FawDelPhi"];
1362   m_FawPhiRot = nArgs["FawPhiRot"];
1363   m_FawRadOff = nArgs["FawRadOff"];
1364 
1365   m_GridHere = nArgs["GridHere"];
1366   m_GridName = sArgs["GridName"];
1367   m_GridMat = sArgs["GridMat"];
1368   m_GridThick = nArgs["GridThick"];
1369 
1370   m_BackHere = nArgs["BackHere"];
1371   m_BackXOff = nArgs["BackXOff"];
1372   m_BackYOff = nArgs["BackYOff"];
1373   m_BackSideName = sArgs["BackSideName"];
1374   m_BackSideHere = nArgs["BackSideHere"];
1375   m_BackSideLength = nArgs["BackSideLength"];
1376   m_BackSideHeight = nArgs["BackSideHeight"];
1377   m_BackSideWidth = nArgs["BackSideWidth"];
1378   m_BackSideYOff1 = nArgs["BackSideYOff1"];
1379   m_BackSideYOff2 = nArgs["BackSideYOff2"];
1380   m_BackSideAngle = nArgs["BackSideAngle"];
1381   m_BackSideMat = sArgs["BackSideMat"];
1382   m_BackPlateName = sArgs["BackPlateName"];
1383   m_BackPlateHere = nArgs["BackPlateHere"];
1384   m_BackPlateLength = nArgs["BackPlateLength"];
1385   m_BackPlateThick = nArgs["BackPlateThick"];
1386   m_BackPlateWidth = nArgs["BackPlateWidth"];
1387   m_BackPlateMat = sArgs["BackPlateMat"];
1388   m_BackPlate2Name = sArgs["BackPlate2Name"];
1389   m_BackPlate2Thick = nArgs["BackPlate2Thick"];
1390   m_BackPlate2Mat = sArgs["BackPlate2Mat"];
1391   m_GrilleName = sArgs["GrilleName"];
1392   m_GrilleHere = nArgs["GrilleHere"];
1393   m_GrilleThick = nArgs["GrilleThick"];
1394   m_GrilleWidth = nArgs["GrilleWidth"];
1395   m_GrilleZSpace = nArgs["GrilleZSpace"];
1396   m_GrilleMat = sArgs["GrilleMat"];
1397   m_vecGrilleHeight = vArgs["GrilleHeight"];
1398   m_vecGrilleZOff = vArgs["GrilleZOff"];
1399 
1400   m_GrEdgeSlotName = sArgs["GrEdgeSlotName"];
1401   m_GrEdgeSlotMat = sArgs["GrEdgeSlotMat"];
1402   m_GrEdgeSlotHere = nArgs["GrEdgeSlotHere"];
1403   m_GrEdgeSlotHeight = nArgs["GrEdgeSlotHeight"];
1404   m_GrEdgeSlotWidth = nArgs["GrEdgeSlotWidth"];
1405   m_GrMidSlotName = sArgs["GrMidSlotName"];
1406   m_GrMidSlotMat = sArgs["GrMidSlotMat"];
1407   m_GrMidSlotHere = nArgs["GrMidSlotHere"];
1408   m_GrMidSlotWidth = nArgs["GrMidSlotWidth"];
1409   m_GrMidSlotXOff = nArgs["GrMidSlotXOff"];
1410   m_vecGrMidSlotHeight = vArgs["GrMidSlotHeight"];
1411 
1412   m_BackPipeHere = nArgs["BackPipeHere"];
1413   m_BackPipeName = sArgs["BackPipeName"];
1414   m_vecBackPipeDiam = vArgs["BackPipeDiam"];
1415   m_vecBackPipeThick = vArgs["BackPipeThick"];
1416   m_BackPipeMat = sArgs["BackPipeMat"];
1417   m_BackPipeWaterMat = sArgs["BackPipeWaterMat"];
1418 
1419   m_BackCoolHere = nArgs["BackCoolHere"];
1420   m_vecBackCoolName = vsArgs["BackCoolName"];
1421   m_BackCoolBarHere = nArgs["BackCoolBarHere"];
1422   m_BackCoolBarWidth = nArgs["BackCoolBarWidth"];
1423   m_BackCoolBarHeight = nArgs["BackCoolBarHeight"];
1424   m_BackCoolMat = sArgs["BackCoolMat"];
1425   m_BackCoolBarName = sArgs["BackCoolBarName"];
1426   m_BackCoolBarThick = nArgs["BackCoolBarThick"];
1427   m_BackCoolBarMat = sArgs["BackCoolBarMat"];
1428   m_BackCoolBarSSName = sArgs["BackCoolBarSSName"];
1429   m_BackCoolBarSSThick = nArgs["BackCoolBarSSThick"];
1430   m_BackCoolBarSSMat = sArgs["BackCoolBarSSMat"];
1431   m_BackCoolBarWaName = sArgs["BackCoolBarWaName"];
1432   m_BackCoolBarWaThick = nArgs["BackCoolBarWaThick"];
1433   m_BackCoolBarWaMat = sArgs["BackCoolBarWaMat"];
1434   m_BackCoolVFEHere = nArgs["BackCoolVFEHere"];
1435   m_BackCoolVFEName = sArgs["BackCoolVFEName"];
1436   m_BackCoolVFEMat = sArgs["BackCoolVFEMat"];
1437   m_BackVFEName = sArgs["BackVFEName"];
1438   m_BackVFEMat = sArgs["BackVFEMat"];
1439   m_vecBackVFELyrThick = vArgs["BackVFELyrThick"];
1440   m_vecBackVFELyrName = vsArgs["BackVFELyrName"];
1441   m_vecBackVFELyrMat = vsArgs["BackVFELyrMat"];
1442   m_vecBackCoolNSec = vArgs["BackCoolNSec"];
1443   m_vecBackCoolSecSep = vArgs["BackCoolSecSep"];
1444   m_vecBackCoolNPerSec = vArgs["BackCoolNPerSec"];
1445   m_BackCBStdSep = nArgs["BackCBStdSep"];
1446 
1447   m_BackMiscHere = nArgs["BackMiscHere"];
1448   m_vecBackMiscThick = vArgs["BackMiscThick"];
1449   m_vecBackMiscName = vsArgs["BackMiscName"];
1450   m_vecBackMiscMat = vsArgs["BackMiscMat"];
1451   m_PatchPanelHere = nArgs["PatchPanelHere"];
1452   m_vecPatchPanelThick = vArgs["PatchPanelThick"];
1453   m_vecPatchPanelNames = vsArgs["PatchPanelNames"];
1454   m_vecPatchPanelMat = vsArgs["PatchPanelMat"];
1455   m_PatchPanelName = sArgs["PatchPanelName"];
1456 
1457   m_BackCoolTankHere = nArgs["BackCoolTankHere"];
1458   m_BackCoolTankName = sArgs["BackCoolTankName"];
1459   m_BackCoolTankWidth = nArgs["BackCoolTankWidth"];
1460   m_BackCoolTankThick = nArgs["BackCoolTankThick"];
1461   m_BackCoolTankMat = sArgs["BackCoolTankMat"];
1462   m_BackCoolTankWaName = sArgs["BackCoolTankWaName"];
1463   m_BackCoolTankWaWidth = nArgs["BackCoolTankWaWidth"];
1464   m_BackCoolTankWaMat = sArgs["BackCoolTankWaMat"];
1465   m_BackBracketName = sArgs["BackBracketName"];
1466   m_BackBracketHeight = nArgs["BackBracketHeight"];
1467   m_BackBracketMat = sArgs["BackBracketMat"];
1468 
1469   m_DryAirTubeHere = nArgs["DryAirTubeHere"];
1470   m_DryAirTubeName = sArgs["DryAirTubeName"];
1471   m_MBCoolTubeNum = static_cast<unsigned int>(nArgs["MBCoolTubeNum"]);
1472   m_DryAirTubeInnDiam = nArgs["DryAirTubeInnDiam"];
1473   m_DryAirTubeOutDiam = nArgs["DryAirTubeOutDiam"];
1474   m_DryAirTubeMat = sArgs["DryAirTubeMat"];
1475   m_MBCoolTubeHere = nArgs["MBCoolTubeHere"];
1476   m_MBCoolTubeName = sArgs["MBCoolTubeName"];
1477   m_MBCoolTubeInnDiam = nArgs["MBCoolTubeInnDiam"];
1478   m_MBCoolTubeOutDiam = nArgs["MBCoolTubeOutDiam"];
1479   m_MBCoolTubeMat = sArgs["MBCoolTubeMat"];
1480   m_MBManifHere = nArgs["MBManifHere"];
1481   m_MBManifName = sArgs["MBManifName"];
1482   m_MBManifInnDiam = nArgs["MBManifInnDiam"];
1483   m_MBManifOutDiam = nArgs["MBManifOutDiam"];
1484   m_MBManifMat = sArgs["MBManifMat"];
1485   m_MBLyrHere = nArgs["MBLyrHere"];
1486   m_vecMBLyrThick = vArgs["MBLyrThick"];
1487   m_vecMBLyrName = vsArgs["MBLyrName"];
1488   m_vecMBLyrMat = vsArgs["MBLyrMat"];
1489 
1490   m_PincerRodHere = nArgs["PincerRodHere"];
1491   m_PincerRodName = sArgs["PincerRodName"];
1492   m_PincerRodMat = sArgs["PincerRodMat"];
1493   m_vecPincerRodAzimuth = vArgs["PincerRodAzimuth"];
1494   m_PincerEnvName = sArgs["PincerEnvName"];
1495   m_PincerEnvMat = sArgs["PincerEnvMat"];
1496   m_PincerEnvWidth = nArgs["PincerEnvWidth"];
1497   m_PincerEnvHeight = nArgs["PincerEnvHeight"];
1498   m_PincerEnvLength = nArgs["PincerEnvLength"];
1499   m_vecPincerEnvZOff = vArgs["PincerEnvZOff"];
1500   m_PincerBlkName = sArgs["PincerBlkName"];
1501   m_PincerBlkMat = sArgs["PincerBlkMat"];
1502   m_PincerBlkLength = nArgs["PincerBlkLength"];
1503   m_PincerShim1Name = sArgs["PincerShim1Name"];
1504   m_PincerShimHeight = nArgs["PincerShimHeight"];
1505   m_PincerShim2Name = sArgs["PincerShim2Name"];
1506   m_PincerShimMat = sArgs["PincerShimMat"];
1507   m_PincerShim1Width = nArgs["PincerShim1Width"];
1508   m_PincerShim2Width = nArgs["PincerShim2Width"];
1509   m_PincerCutName = sArgs["PincerCutName"];
1510   m_PincerCutMat = sArgs["PincerCutMat"];
1511   m_PincerCutWidth = nArgs["PincerCutWidth"];
1512   m_PincerCutHeight = nArgs["PincerCutHeight"];
1513 
1514 #ifdef EDM_ML_DEBUG
1515   edm::LogVerbatim("EcalGeom") << "DDEcalBarrelAlgo info: end initialize";
1516 #endif
1517 }
1518 
1519 ////////////////////////////////////////////////////////////////////
1520 // DDEcalBarrelAlgo methods...
1521 ////////////////////////////////////////////////////////////////////
1522 
1523 void DDEcalBarrelNewAlgo::execute(DDCompactView& cpv) {
1524 #ifdef EDM_ML_DEBUG
1525   edm::LogVerbatim("EcalGeom") << "******** DDEcalBarrelAlgo execute!" << std::endl;
1526 #endif
1527   if (barHere() != 0) {
1528     const unsigned int copyOne(1);
1529     const unsigned int copyTwo(2);
1530     // Barrel parent volume----------------------------------------------------------
1531     cpv.position(
1532         DDLogicalPart(barName(),
1533                       barMat(),
1534                       DDSolidFactory::polycone(
1535                           barName(), barPhiLo(), (barPhiHi() - barPhiLo()), vecBarZPts(), vecBarRMin(), vecBarRMax())),
1536         parent().name(),
1537         copyOne,
1538         DDTranslation(vecBarTran()[0], vecBarTran()[1], vecBarTran()[2]),
1539         myrot(barName().name() + "Rot",
1540               Rota(Vec3(vecBarRota3()[0], vecBarRota3()[1], vecBarRota3()[2]), vecBarRota3()[3]) *
1541                   Rota(Vec3(vecBarRota2()[0], vecBarRota2()[1], vecBarRota2()[2]), vecBarRota2()[3]) *
1542                   Rota(Vec3(vecBarRota()[0], vecBarRota()[1], vecBarRota()[2]), vecBarRota()[3])));
1543 #ifdef EDM_ML_DEBUG
1544     edm::LogVerbatim("EBGeom") << barName() << " PolyCone from " << barPhiLo() / CLHEP::deg << " to "
1545                                << barPhiHi() / CLHEP::deg << " with " << vecBarZPts().size() << " points";
1546     for (unsigned int k = 0; k < vecBarZPts().size(); ++k)
1547       edm::LogVerbatim("EBGeom") << "[" << k << "] " << vecBarZPts()[k] << ":" << vecBarRMin()[k] << ":"
1548                                  << vecBarRMax()[k];
1549     edm::LogVerbatim("EBGeomX") << barName() << ":" << copyOne << " positioned in " << parent().name() << " at "
1550                                 << DDTranslation(vecBarTran()[0], vecBarTran()[1], vecBarTran()[2]) << " with rotation";
1551 #endif
1552     // End Barrel parent volume----------------------------------------------------------
1553 
1554     // Supermodule parent------------------------------------------------------------
1555 
1556     const DDName spmcut1ddname((0 != spmCutShow()) ? spmName() : ddname(m_SpmName + "CUT1"));
1557     const DDSolid ddspm(
1558         DDSolidFactory::polycone(spmcut1ddname, spmLowPhi(), spmDelPhi(), vecSpmZPts(), vecSpmRMin(), vecSpmRMax()));
1559 #ifdef EDM_ML_DEBUG
1560     edm::LogVerbatim("EBGeom") << spmcut1ddname << " PolyCone from " << spmLowPhi() / CLHEP::deg << " to "
1561                                << (spmLowPhi() + spmDelPhi()) / CLHEP::deg << " with " << vecSpmZPts().size()
1562                                << " points";
1563     for (unsigned int k = 0; k < vecSpmZPts().size(); ++k)
1564       edm::LogVerbatim("EBGeom") << "[" << k << "] " << vecSpmZPts()[k] << ":" << vecSpmRMin()[k] << ":"
1565                                  << vecSpmRMax()[k];
1566 #endif
1567 
1568     const unsigned int indx(vecSpmRMax().size() / 2);
1569 
1570     // Deal with the cut boxes first
1571     const DDSolid spmCutBox(DDSolidFactory::box(spmCutName(),
1572                                                 1.05 * (vecSpmRMax()[indx] - vecSpmRMin()[indx]) / 2.,
1573                                                 spmCutThick() / 2.,
1574                                                 fabs(vecSpmZPts().back() - vecSpmZPts().front()) / 2. + 1 * mm));
1575 #ifdef EDM_ML_DEBUG
1576     edm::LogVerbatim("EBGeom") << spmCutName() << " Box " << 1.05 * (vecSpmRMax()[indx] - vecSpmRMin()[indx]) / 2.
1577                                << ":" << spmCutThick() / 2. << ":"
1578                                << (fabs(vecSpmZPts().back() - vecSpmZPts().front()) / 2. + 1 * mm);
1579 #endif
1580     const std::vector<double>& cutBoxParms(spmCutBox.parameters());
1581     const DDLogicalPart spmCutLog(spmCutName(), spmMat(), spmCutBox);
1582     /*
1583     // Now the expansion box
1584     const double xExp(spmExpThick() / 2.);
1585     const double yExp(spmExpWide() / 2.);
1586     const double zExp(fabs(vecSpmZPts().back() - vecSpmZPts().front()) / 2.);
1587     const DDName expName(m_SpmName + "EXP");
1588     const DDSolid spmExpBox(DDSolidFactory::box(expName, xExp, yExp, zExp));
1589 #ifdef EDM_ML_DEBUG
1590     edm::LogVerbatim("EBGeom") << expName << " Box " << xExp << ":" << yExp << ":" << zExp;
1591 #endif
1592     const DDTranslation expTra(vecSpmRMax().back() - xExp, spmExpYOff(), vecSpmZPts().front() + zExp);
1593     const DDLogicalPart expLog(expName, spmMat(), spmExpBox);
1594 
1595     const DDName unionName ( ddname( m_SpmName + "UNI" ) ) ;
1596       if( 0 != spmCutShow() )
1597       {
1598      cpv.position( expLog, spmName(), copyOne, expTra, DDRotation() ) ;
1599       }
1600       else
1601       {
1602      const DDSolid unionSolid ( DDSolidFactory::unionSolid(
1603                        unionName,
1604                        spmcut1ddname, expName,
1605                        expTra, DDRotation() ) ) ;
1606                        }
1607     */
1608 
1609     // Supermodule side platess
1610     const DDSolid sideSolid(DDSolidFactory::box(
1611         spmSideName(), spmSideHigh() / 2., spmSideThick() / 2., fabs(vecSpmZPts()[1] - vecSpmZPts()[0]) / 2.));
1612 #ifdef EDM_ML_DEBUG
1613     edm::LogVerbatim("EBGeom") << spmSideName() << " Box " << spmSideHigh() / 2. << ":" << spmSideThick() / 2. << ":"
1614                                << fabs(vecSpmZPts()[1] - vecSpmZPts()[0]) / 2.;
1615 #endif
1616     const std::vector<double>& sideParms(sideSolid.parameters());
1617     const DDLogicalPart sideLog(spmSideName(), spmSideMat(), sideSolid);
1618 
1619     DDSolid temp1;
1620     DDSolid temp2;
1621     for (unsigned int icopy(1); icopy <= 2; ++icopy) {
1622       const std::vector<double>& tvec(1 == icopy ? vecSpmCutTM() : vecSpmCutTP());
1623       const double rang(1 == icopy ? spmCutRM() : spmCutRP());
1624 
1625       const Tl3D tr(tvec[0], tvec[1], tvec[2]);
1626       const RoZ3D ro(rang);
1627       const Tf3D alltrot(
1628           RoZ3D(1 == icopy ? spmLowPhi() : spmLowPhi() + spmDelPhi()) *
1629           Tl3D((vecSpmRMax()[indx] + vecSpmRMin()[indx]) / 2., 0, (vecSpmZPts().front() + vecSpmZPts().back()) / 2.) *
1630           tr * ro);
1631 
1632       const DDRotation ddrot(myrot(spmCutName().name() + std::to_string(icopy), alltrot.getRotation()));
1633       const DDTranslation ddtra(alltrot.getTranslation());
1634 
1635       const Tl3D trSide(tvec[0],
1636                         tvec[1] + (1 == icopy ? 1. : -1.) * (cutBoxParms[1] + sideParms[1]) +
1637                             (1 == icopy ? spmSideYOffM() : spmSideYOffP()),
1638                         tvec[2]);
1639       const RoZ3D roSide(rang);
1640       const Tf3D sideRot(RoZ3D(1 == icopy ? spmLowPhi() : spmLowPhi() + spmDelPhi()) *
1641                          Tl3D(vecSpmRMin().front() + sideParms[0], 0, vecSpmZPts().front() + sideParms[2]) * trSide *
1642                          roSide);
1643 
1644       const DDRotation sideddrot(myrot(spmSideName().name() + std::to_string(icopy), sideRot.getRotation()));
1645       const DDTranslation sideddtra(sideRot.getTranslation());
1646 
1647       cpv.position(sideLog, spmName(), icopy, sideddtra, sideddrot);
1648 #ifdef EDM_ML_DEBUG
1649       edm::LogVerbatim("EBGeomX") << sideLog.name() << ":" << icopy << " positioned in " << spmName() << " at "
1650                                   << sideddtra << " with rotation";
1651 #endif
1652       if (0 != spmCutShow())  // do this if we are "showing" the boxes
1653       {
1654         cpv.position(spmCutLog, spmName(), icopy, ddtra, ddrot);
1655 #ifdef EDM_ML_DEBUG
1656         edm::LogVerbatim("EBGeomX") << spmCutLog.name() << ":" << icopy << " positioned in " << spmName() << " at "
1657                                     << ddtra << " with rotation";
1658 #endif
1659       } else  // do this if we are subtracting the boxes
1660       {
1661         if (1 == icopy) {
1662           temp1 = DDSolidFactory::subtraction(DDName(m_SpmName + "_T1"), spmcut1ddname, spmCutBox, ddtra, ddrot);
1663 #ifdef EDM_ML_DEBUG
1664           edm::LogVerbatim("EBGeom") << DDName(m_SpmName + "_T1") << " Subtraction " << spmcut1ddname << ":"
1665                                      << spmCutBox.name() << " at " << ddtra;
1666 #endif
1667         } else {
1668           temp2 = DDSolidFactory::subtraction(spmName(), temp1, spmCutBox, ddtra, ddrot);
1669 #ifdef EDM_ML_DEBUG
1670           edm::LogVerbatim("EBGeom") << spmName() << " Subtraction " << temp1.name() << ":" << spmCutBox.name()
1671                                      << " at " << ddtra;
1672 #endif
1673         }
1674       }
1675     }
1676 
1677     const DDLogicalPart spmLog(spmName(), spmMat(), ((0 != spmCutShow()) ? ddspm : temp2));
1678 
1679     const double dphi(360. * deg / (1. * spmNPerHalf()));
1680     for (unsigned int iphi(0); iphi < 2 * spmNPerHalf(); ++iphi) {
1681       const double phi(iphi * dphi + spmPhiOff());  //- 0.000130/deg ) ;
1682 
1683       // this base rotation includes the base translation & rotation
1684       // plus flipping for the negative z hemisphere, plus
1685       // the phi rotation for this module
1686       const Tf3D rotaBase(RoZ3D(phi) * (iphi < spmNPerHalf() ? Ro3D() : RoX3D(180. * deg)) *
1687                           Ro3D(vecSpmBRota()[3], Vec3(vecSpmBRota()[0], vecSpmBRota()[1], vecSpmBRota()[2])) *
1688                           Tl3D(Vec3(vecSpmBTran()[0], vecSpmBTran()[1], vecSpmBTran()[2])));
1689 
1690       // here the individual rotations & translations of the supermodule
1691       // are implemented on top of the overall "base" rotation & translation
1692 
1693       const unsigned int offr(4 * iphi);
1694       const unsigned int offt(3 * iphi);
1695 
1696       const Ro3D r1(vecSpmRota()[offr + 3],
1697                     Vec3(vecSpmRota()[offr + 0], vecSpmRota()[offr + 1], vecSpmRota()[offr + 2]));
1698 
1699       const Tf3D rotaExtra(r1 * Tl3D(Vec3(vecSpmTran()[offt + 0], vecSpmTran()[offt + 1], vecSpmTran()[offt + 2])));
1700 
1701       const Tf3D both(rotaExtra * rotaBase);
1702 
1703       const DDRotation rota(myrot(spmName().name() + std::to_string(phi / deg), both.getRotation()));
1704 
1705       if (vecSpmHere()[iphi] != 0) {
1706         // convert from CLHEP to DDTranslation & etc. -- Michael Case
1707         DDTranslation myTran(both.getTranslation().x(), both.getTranslation().y(), both.getTranslation().z());
1708         cpv.position(spmLog, barName(), iphi + 1, myTran, rota);
1709 #ifdef EDM_ML_DEBUG
1710         edm::LogVerbatim("EBGeomX") << spmLog.name() << ":" << (iphi + 1) << " positioned in " << barName() << " at "
1711                                     << myTran << " with rotation";
1712 #endif
1713       }
1714     }
1715     // End Supermodule parent------------------------------------------------------------
1716 
1717     // Begin Inner Layer volumes---------------------------------------------------------
1718     const double ilyLength(vecSpmZPts()[1] - vecSpmZPts()[0]);
1719     double ilyRMin(vecSpmRMin()[0]);
1720     double ilyThick(0);
1721     for (unsigned int ilyx(0); ilyx != vecIlyThick().size(); ++ilyx) {
1722       ilyThick += vecIlyThick()[ilyx];
1723     }
1724     const DDName ilyDDName(ddname(ilyName()));
1725     const DDSolid ilySolid(
1726         DDSolidFactory::tubs(ilyDDName, ilyLength / 2, ilyRMin, ilyRMin + ilyThick, ilyPhiLow(), ilyDelPhi()));
1727 #ifdef EDM_ML_DEBUG
1728     edm::LogVerbatim("EBGeom") << ilyDDName << " Tubs " << ilyLength / 2 << ":" << ilyRMin << ":" << ilyRMin + ilyThick
1729                                << ":" << ilyPhiLow() / CLHEP::deg << ":" << ilyDelPhi() / CLHEP::deg;
1730 #endif
1731     const DDLogicalPart ilyLog(ilyDDName, spmMat(), ilySolid);
1732     cpv.position(ilyLog, spmLog, copyOne, DDTranslation(0, 0, ilyLength / 2), DDRotation());
1733 #ifdef EDM_ML_DEBUG
1734     edm::LogVerbatim("EBGeomX") << ilyDDName << ":" << copyOne << " positioned in " << spmLog.name() << " at "
1735                                 << DDTranslation(0, 0, ilyLength / 2) << " with no rotation";
1736 #endif
1737     DDLogicalPart ilyPipeLog[200];
1738 
1739     if (0 != ilyPipeHere()) {
1740       for (unsigned int iPipeType(0); iPipeType != vecIlyPipeLength().size(); ++iPipeType) {
1741         const DDName pName(ddname(ilyPipeName() + "_" + std::to_string(iPipeType + 1)));
1742 
1743         DDSolid ilyPipeSolid(
1744             DDSolidFactory::tubs(pName, vecIlyPipeLength()[iPipeType] / 2., 0, ilyPipeOD() / 2, 0 * deg, 360 * deg));
1745 #ifdef EDM_ML_DEBUG
1746         edm::LogVerbatim("EBGeom") << pName << " Tubs " << vecIlyPipeLength()[iPipeType] / 2.
1747                                    << ":0:" << ilyPipeOD() / 2 << ":0:360";
1748 #endif
1749         ilyPipeLog[iPipeType] = DDLogicalPart(pName, ilyPipeMat(), ilyPipeSolid);
1750 
1751         const DDName pWaName(ddname(ilyPipeName() + "Wa_" + std::to_string(iPipeType + 1)));
1752         DDSolid ilyPipeWaSolid(
1753             DDSolidFactory::tubs(pWaName, vecIlyPipeLength()[iPipeType] / 2., 0, ilyPipeID() / 2, 0 * deg, 360 * deg));
1754 #ifdef EDM_ML_DEBUG
1755         edm::LogVerbatim("EBGeom") << pWaName << " Tubs " << vecIlyPipeLength()[iPipeType] / 2.
1756                                    << ":0:" << ilyPipeID() / 2 << ":0:360";
1757 #endif
1758         const DDLogicalPart ilyPipeWaLog(pWaName, backPipeWaterMat(), ilyPipeWaSolid);
1759 
1760         cpv.position(ilyPipeWaLog, pName, copyOne, DDTranslation(0, 0, 0), DDRotation());
1761 #ifdef EDM_ML_DEBUG
1762         edm::LogVerbatim("EBGeomX") << pWaName << ":" << copyOne << " positioned in " << pName << " at "
1763                                     << DDTranslation(0, 0, 0) << " with no rotation";
1764 #endif
1765       }
1766     }
1767 
1768     DDSolid ilyPTMSolid(
1769         DDSolidFactory::box(ilyPTMName(), ilyPTMHeight() / 2., ilyPTMWidth() / 2., ilyPTMLength() / 2.));
1770 #ifdef EDM_ML_DEBUG
1771     edm::LogVerbatim("EBGeom") << ilyPTMName() << " Box " << ilyPTMHeight() / 2. << ":" << ilyPTMWidth() / 2. << ":"
1772                                << ilyPTMLength() / 2.;
1773 #endif
1774     const DDLogicalPart ilyPTMLog(ilyPTMName(), ilyPTMMat(), ilyPTMSolid);
1775 
1776     DDSolid ilyFanOutSolid(
1777         DDSolidFactory::box(ilyFanOutName(), ilyFanOutHeight() / 2., ilyFanOutWidth() / 2., ilyFanOutLength() / 2.));
1778 #ifdef EDM_ML_DEBUG
1779     edm::LogVerbatim("EBGeom") << ilyFanOutName() << " Box " << ilyFanOutHeight() / 2. << ":" << ilyFanOutWidth() / 2.
1780                                << ":" << ilyFanOutLength() / 2.;
1781 #endif
1782     const DDLogicalPart ilyFanOutLog(ilyFanOutName(), ilyFanOutMat(), ilyFanOutSolid);
1783 
1784     DDSolid ilyFEMSolid(
1785         DDSolidFactory::box(ilyFEMName(), ilyFEMHeight() / 2., ilyFEMWidth() / 2., ilyFEMLength() / 2.));
1786 #ifdef EDM_ML_DEBUG
1787     edm::LogVerbatim("EBGeom") << ilyFEMName() << " Box " << ilyFEMHeight() / 2. << ":" << ilyFEMWidth() / 2. << ":"
1788                                << ilyFEMLength() / 2.;
1789 #endif
1790     const DDLogicalPart ilyFEMLog(ilyFEMName(), ilyFEMMat(), ilyFEMSolid);
1791 
1792     DDSolid ilyDiffSolid(
1793         DDSolidFactory::box(ilyDiffName(), ilyFanOutHeight() / 2., ilyFanOutWidth() / 2., ilyDiffLength() / 2.));
1794 #ifdef EDM_ML_DEBUG
1795     edm::LogVerbatim("EBGeom") << ilyDiffName() << " Box " << ilyFanOutHeight() / 2. << ":" << ilyFanOutWidth() / 2.
1796                                << ":" << ilyDiffLength() / 2.;
1797 #endif
1798     const DDLogicalPart ilyDiffLog(ilyDiffName(), ilyDiffMat(), ilyDiffSolid);
1799 
1800     DDSolid ilyBndlSolid(
1801         DDSolidFactory::box(ilyBndlName(), ilyFanOutHeight() / 2., ilyFanOutWidth() / 2., ilyBndlLength() / 2.));
1802 #ifdef EDM_ML_DEBUG
1803     edm::LogVerbatim("EBGeom") << ilyBndlName() << " Box " << ilyFanOutHeight() / 2. << ":" << ilyFanOutWidth() / 2.
1804                                << ":" << ilyBndlLength() / 2.;
1805 #endif
1806     const DDLogicalPart ilyBndlLog(ilyBndlName(), ilyBndlMat(), ilyBndlSolid);
1807     cpv.position(ilyDiffLog,
1808                  ilyFanOutName(),
1809                  copyOne,
1810                  DDTranslation(0, 0, -ilyFanOutLength() / 2 + ilyDiffLength() / 2 + ilyDiffOff()),
1811                  DDRotation());
1812 #ifdef EDM_ML_DEBUG
1813     edm::LogVerbatim("EBGeomX") << ilyDiffName() << ":" << copyOne << " positioned in " << ilyFanOutName() << " at "
1814                                 << DDTranslation(0, 0, -ilyFanOutLength() / 2 + ilyDiffLength() / 2 + ilyDiffOff())
1815                                 << " with no rotation";
1816 #endif
1817     cpv.position(ilyBndlLog,
1818                  ilyFanOutName(),
1819                  copyOne,
1820                  DDTranslation(0, 0, -ilyFanOutLength() / 2 + ilyBndlLength() / 2 + ilyBndlOff()),
1821                  DDRotation());
1822 #ifdef EDM_ML_DEBUG
1823     edm::LogVerbatim("EBGeomX") << ilyBndlName() << ":" << copyOne << " positioned in " << ilyFanOutName() << " at "
1824                                 << DDTranslation(0, 0, -ilyFanOutLength() / 2 + ilyBndlLength() / 2 + ilyBndlOff())
1825                                 << " with no rotation";
1826 #endif
1827     for (unsigned int ily(0); ily != vecIlyThick().size(); ++ily) {
1828       const double ilyRMax(ilyRMin + vecIlyThick()[ily]);
1829       const DDName xilyName(ddname(ilyName() + std::to_string(ily)));
1830       const DDSolid xilySolid(
1831           DDSolidFactory::tubs(xilyName, ilyLength / 2, ilyRMin, ilyRMax, ilyPhiLow(), ilyDelPhi()));
1832 #ifdef EDM_ML_DEBUG
1833       edm::LogVerbatim("EBGeom") << xilyName << " Tubs " << ilyLength / 2 << ":" << ilyRMin << ":" << ilyRMax << ":"
1834                                  << ilyPhiLow() / CLHEP::deg << ":" << ilyDelPhi() / CLHEP::deg;
1835 #endif
1836 
1837       const DDLogicalPart xilyLog(xilyName, ddmat(vecIlyMat()[ily]), xilySolid);
1838 
1839       if (0 != ilyHere()) {
1840         cpv.position(xilyLog, ilyLog, copyOne, DDTranslation(0, 0, 0), DDRotation());
1841 #ifdef EDM_ML_DEBUG
1842         edm::LogVerbatim("EBGeomX") << xilyLog.name() << ":" << copyOne << " positioned in " << ilyLog.name() << " at "
1843                                     << DDTranslation(0, 0, 0) << " with no rotation";
1844 #endif
1845         unsigned int copyNum[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1846 
1847         if (10 * mm < vecIlyThick()[ily] && vecIlyThick().size() != (ily + 1) && 0 != ilyPipeHere()) {
1848           if (0 != ilyPTMHere()) {
1849             unsigned int ptmCopy(0);
1850             for (unsigned int ilyPTM(0); ilyPTM != vecIlyPTMZ().size(); ++ilyPTM) {
1851               const double radius(ilyRMax - 1 * mm - ilyPTMHeight() / 2.);
1852               const double phi(vecIlyPTMPhi()[ilyPTM]);
1853               const double yy(radius * sin(phi));
1854               const double xx(radius * cos(phi));
1855               ++ptmCopy;
1856               cpv.position(ilyPTMLog,
1857                            xilyLog,
1858                            ptmCopy,
1859                            DDTranslation(xx, yy, vecIlyPTMZ()[ilyPTM] - ilyLength / 2),
1860                            myrot(ilyPTMLog.name().name() + "_rot" + std::to_string(ptmCopy), CLHEP::HepRotationZ(phi)));
1861 #ifdef EDM_ML_DEBUG
1862               edm::LogVerbatim("EBGeomX")
1863                   << ilyPTMLog.name() << ":" << ptmCopy << " positioned in " << xilyLog.name() << " at "
1864                   << DDTranslation(xx, yy, vecIlyPTMZ()[ilyPTM] - ilyLength / 2) << " with rotation";
1865 #endif
1866             }
1867           }
1868           if (0 != ilyFanOutHere()) {
1869             unsigned int fanOutCopy(0);
1870             for (unsigned int ilyFO(0); ilyFO != vecIlyFanOutZ().size(); ++ilyFO) {
1871               const double radius(ilyRMax - 1 * mm - ilyFanOutHeight() / 2.);
1872               const double phi(vecIlyFanOutPhi()[ilyFO]);
1873               const double yy(radius * sin(phi));
1874               const double xx(radius * cos(phi));
1875               ++fanOutCopy;
1876               cpv.position(ilyFanOutLog,
1877                            xilyLog,
1878                            fanOutCopy,
1879                            DDTranslation(xx, yy, vecIlyFanOutZ()[ilyFO] - ilyLength / 2),
1880                            myrot(ilyFanOutLog.name().name() + "_rot" + std::to_string(fanOutCopy),
1881                                  CLHEP::HepRotationZ(phi) * CLHEP::HepRotationY(180 * deg)));
1882 #ifdef EDM_ML_DEBUG
1883               edm::LogVerbatim("EBGeomX")
1884                   << ilyFanOutLog.name() << ":" << fanOutCopy << " positioned in " << xilyLog.name() << " at "
1885                   << DDTranslation(xx, yy, vecIlyFanOutZ()[ilyFO] - ilyLength / 2) << " with rotation";
1886 #endif
1887             }
1888             unsigned int femCopy(0);
1889             for (unsigned int ilyFEM(0); ilyFEM != vecIlyFEMZ().size(); ++ilyFEM) {
1890               const double radius(ilyRMax - 1 * mm - ilyFEMHeight() / 2.);
1891               const double phi(vecIlyFEMPhi()[ilyFEM]);
1892               const double yy(radius * sin(phi));
1893               const double xx(radius * cos(phi));
1894               ++femCopy;
1895               cpv.position(ilyFEMLog,
1896                            xilyLog,
1897                            femCopy,
1898                            DDTranslation(xx, yy, vecIlyFEMZ()[ilyFEM] - ilyLength / 2),
1899                            myrot(ilyFEMLog.name().name() + "_rot" + std::to_string(femCopy), CLHEP::HepRotationZ(phi)));
1900 #ifdef EDM_ML_DEBUG
1901               edm::LogVerbatim("EBGeomX")
1902                   << ilyFEMLog.name() << ":" << femCopy << " positioned in " << xilyLog.name() << " at "
1903                   << DDTranslation(xx, yy, vecIlyFEMZ()[ilyFEM] - ilyLength / 2) << " with rotation";
1904 #endif
1905             }
1906           }
1907           for (unsigned int iPipe(0); iPipe != vecIlyPipePhi().size(); ++iPipe) {
1908             const unsigned int type(static_cast<unsigned int>(round(vecIlyPipeType()[iPipe])));
1909             //        edm::LogVerbatim("EcalGeom") <<" iPipe, type= " << iPipe << ", " << type;
1910             const double zz(-ilyLength / 2 + vecIlyPipeZ()[iPipe] + (9 > type ? vecIlyPipeLength()[type] / 2. : 0));
1911 
1912             for (unsigned int ly(0); ly != 2; ++ly) {
1913               const double radius(0 == ly ? ilyRMin + ilyPipeOD() / 2. + 1 * mm : ilyRMax - ilyPipeOD() / 2. - 1 * mm);
1914               const double phi(vecIlyPipePhi()[iPipe]);
1915               const double yy(radius * sin(phi));
1916               const double xx(radius * cos(phi));
1917               ++copyNum[type],
1918                   cpv.position(
1919                       ilyPipeLog[type],
1920                       xilyLog,
1921                       copyNum[type],
1922                       DDTranslation(xx, yy, zz),
1923                       (9 > type ? DDRotation()
1924                                 : myrot(ilyPipeLog[type].name().name() + "_rot" + std::to_string(copyNum[type]),
1925                                         Rota(Vec3(xx, yy, 0), 90 * deg))));
1926 #ifdef EDM_ML_DEBUG
1927               std::string rrr = (9 > type) ? " with no rotation" : " with rotation";
1928               edm::LogVerbatim("EBGeomX") << ilyPipeLog[type].name() << ":" << copyNum[type] << " positioned in "
1929                                           << xilyLog.name() << " at" << DDTranslation(xx, yy, zz) << rrr;
1930 #endif
1931             }
1932           }
1933         }
1934       }
1935       ilyRMin = ilyRMax;
1936     }
1937     // End Inner Layer volumes---------------------------------------------------------
1938 
1939     const DDName clyrName(DDName("ECLYR"));
1940     std::vector<double> cri;
1941     std::vector<double> cro;
1942     std::vector<double> czz;
1943     czz.emplace_back(vecSpmZPts()[1]);
1944     cri.emplace_back(vecSpmRMin()[0]);
1945     cro.emplace_back(vecSpmRMin()[0] + 25 * mm);
1946     czz.emplace_back(vecSpmZPts()[2]);
1947     cri.emplace_back(vecSpmRMin()[2]);
1948     cro.emplace_back(vecSpmRMin()[2] + 10 * mm);
1949     const DDSolid clyrSolid(DDSolidFactory::polycone(clyrName, -9.5 * deg, 19 * deg, czz, cri, cro));
1950 #ifdef EDM_ML_DEBUG
1951     edm::LogVerbatim("EBGeom") << clyrName << " PolyCone from -9.5 to 9.5 with " << czz.size() << " points";
1952     for (unsigned int k = 0; k < czz.size(); ++k)
1953       edm::LogVerbatim("EBGeom") << "[" << k << "] " << czz[k] << ":" << cri[k] << ":" << cro[k];
1954 #endif
1955     const DDLogicalPart clyrLog(clyrName, ddmat(vecIlyMat()[4]), clyrSolid);
1956     cpv.position(clyrLog, spmLog, copyOne, DDTranslation(0, 0, 0), DDRotation());
1957 #ifdef EDM_ML_DEBUG
1958     edm::LogVerbatim("EBGeomX") << clyrLog.name() << ":" << copyOne << " positioned in " << spmLog.name() << " at "
1959                                 << DDTranslation(0, 0, 0) << " with no rotation";
1960 #endif
1961     // Begin Alveolar Wedge parent ------------------------------------------------------
1962     //----------------
1963 
1964     // the next few lines accumulate dimensions appropriate to crystal type 1
1965     // which we use to set some of the features of the half-alveolar wedge (hawR).
1966 
1967     //      const double ANom1 ( vecNomCryDimAR()[0] ) ;
1968     const double BNom1(vecNomCryDimCR()[0]);
1969     const double bNom1(vecNomCryDimCF()[0]);
1970     //      const double HNom1 ( vecNomCryDimBR()[0] ) ;
1971     //      const double hNom1 ( vecNomCryDimBF()[0] ) ;
1972     const double sWall1(wallThAlv());
1973     const double fWall1(wallFrAlv());
1974     //      const double rWall1( wallReAlv() ) ;
1975     const double sWrap1(wrapThAlv());
1976     const double fWrap1(wrapFrAlv());
1977     //      const double rWrap1( wrapReAlv() ) ;
1978     const double sClr1(clrThAlv());
1979     const double fClr1(clrFrAlv());
1980     //      const double rClr1 ( clrReAlv() ) ;
1981     const double LNom1(nomCryDimLZ());
1982     const double beta1(atan((BNom1 - bNom1) / LNom1));
1983     //      const double cosbeta1   ( cos( beta1 ) ) ;
1984     const double sinbeta1(sin(beta1));
1985 
1986     const double tana_hawR((BNom1 - bNom1) / LNom1);
1987 
1988     const double H_hawR(hawRHBIG());
1989     const double h_hawR(hawRhsml());
1990     const double a_hawR(bNom1 + sClr1 + 2 * sWrap1 + 2 * sWall1 - sinbeta1 * (fClr1 + fWrap1 + fWall1));
1991     const double B_hawR(a_hawR + H_hawR * tana_hawR);
1992     const double b_hawR(a_hawR + h_hawR * tana_hawR);
1993     const double L_hawR(vecSpmZPts()[2]);
1994 
1995     const Trap trapHAWR(a_hawR / 2.,  //double aHalfLengthXNegZLoY , // bl1, A/2
1996                         a_hawR / 2.,  //double aHalfLengthXPosZLoY , // bl2, a/2
1997                         b_hawR / 2.,  //double aHalfLengthXPosZHiY , // tl2, b/2
1998                         H_hawR / 2.,  //double aHalfLengthYNegZ    , // h1, H/2
1999                         h_hawR / 2.,  //double aHalfLengthYPosZ    , // h2, h/2
2000                         L_hawR / 2.,  //double aHalfLengthZ        , // dz,  L/2
2001                         90 * deg,     //double aAngleAD            , // alfa1
2002                         0,            //double aCoord15X           , // x15
2003                         0             //double aCoord15Y             // y15
2004     );
2005 
2006     const DDName hawRName1(ddname(hawRName().name() + "1"));
2007     const DDSolid hawRSolid1(mytrap(hawRName1.name(), trapHAWR));
2008     const DDLogicalPart hawRLog1(hawRName1, spmMat(), hawRSolid1);
2009 
2010     const double al1_fawR(atan((B_hawR - a_hawR) / H_hawR) + M_PI_2);
2011 
2012     // here is trap for Full Alveolar Wedge
2013     const Trap trapFAW(a_hawR,       //double aHalfLengthXNegZLoY , // bl1, A/2
2014                        a_hawR,       //double aHalfLengthXPosZLoY , // bl2, a/2
2015                        b_hawR,       //double aHalfLengthXPosZHiY , // tl2, b/2
2016                        H_hawR / 2.,  //double aHalfLengthYNegZ    , // h1, H/2
2017                        h_hawR / 2.,  //double aHalfLengthYPosZ    , // h2, h/2
2018                        L_hawR / 2.,  //double aHalfLengthZ        , // dz,  L/2
2019                        al1_fawR,     //double aAngleAD            , // alfa1
2020                        0,            //double aCoord15X           , // x15
2021                        0             //double aCoord15Y             // y15
2022     );
2023 
2024     const DDName fawName1(ddname(fawName().name() + "1"));
2025     const DDSolid fawSolid1(mytrap(fawName1.name(), trapFAW));
2026     const DDLogicalPart fawLog1(fawName1, spmMat(), fawSolid1);
2027 
2028     const Trap::VertexList vHAW(trapHAWR.vertexList());
2029     const Trap::VertexList vFAW(trapFAW.vertexList());
2030 
2031     const double hawBoxClr(1 * mm);
2032 
2033     // HAW cut box to cut off back end of wedge
2034     const DDName hawCutName(ddname(hawRName().name() + "CUTBOX"));
2035     const DDSolid hawCutBox(DDSolidFactory::box(hawCutName, b_hawR / 2 + hawBoxClr, hawRCutY() / 2, hawRCutZ() / 2));
2036 #ifdef EDM_ML_DEBUG
2037     edm::LogVerbatim("EBGeom") << hawCutName << " Box " << (b_hawR / 2 + hawBoxClr) << ":" << hawRCutY() / 2 << ":"
2038                                << hawRCutZ() / 2;
2039 #endif
2040     const std::vector<double>& hawBoxParms(hawCutBox.parameters());
2041     const DDLogicalPart hawCutLog(hawCutName, spmMat(), hawCutBox);
2042 
2043     const Pt3D b1(hawBoxParms[0], hawBoxParms[1], hawBoxParms[2]);
2044     const Pt3D b2(-hawBoxParms[0], hawBoxParms[1], hawBoxParms[2]);
2045     const Pt3D b3(-hawBoxParms[0], hawBoxParms[1], -hawBoxParms[2]);
2046 
2047     const double zDel(sqrt(4 * hawBoxParms[2] * hawBoxParms[2] - (h_hawR - hawRCutDelY()) * (h_hawR - hawRCutDelY())));
2048 
2049     const Tf3D hawCutForm(b1,
2050                           b2,
2051                           b3,
2052                           vHAW[2] + Pt3D(hawBoxClr, -hawRCutDelY(), 0),
2053                           vHAW[1] + Pt3D(-hawBoxClr, -hawRCutDelY(), 0),
2054                           Pt3D(vHAW[0].x() - hawBoxClr, vHAW[0].y(), vHAW[0].z() - zDel));
2055 
2056     const DDSolid hawRSolid(DDSolidFactory::subtraction(
2057         hawRName(),
2058         hawRSolid1,
2059         hawCutBox,
2060         DDTranslation(
2061             hawCutForm.getTranslation().x(), hawCutForm.getTranslation().y(), hawCutForm.getTranslation().z()),
2062         myrot(hawCutName.name() + "R", hawCutForm.getRotation())));
2063 #ifdef EDM_ML_DEBUG
2064     edm::LogVerbatim("EBGeom") << hawRName() << " Subtraction " << hawRSolid1.name() << ":" << hawCutBox.name()
2065                                << " at "
2066                                << DDTranslation(hawCutForm.getTranslation().x(),
2067                                                 hawCutForm.getTranslation().y(),
2068                                                 hawCutForm.getTranslation().z());
2069 #endif
2070     const DDLogicalPart hawRLog(hawRName(), spmMat(), hawRSolid);
2071 
2072     // FAW cut box to cut off back end of wedge
2073     const DDName fawCutName(ddname(fawName().name() + "CUTBOX"));
2074     const DDSolid fawCutBox(DDSolidFactory::box(fawCutName, 2 * hawBoxParms[0], hawBoxParms[1], hawBoxParms[2]));
2075 #ifdef EDM_ML_DEBUG
2076     edm::LogVerbatim("EBGeom") << fawCutName << " Box " << 2 * hawBoxParms[0] << ":" << hawBoxParms[1] << ":"
2077                                << hawBoxParms[2];
2078 #endif
2079 
2080     const std::vector<double>& fawBoxParms(fawCutBox.parameters());
2081     const DDLogicalPart fawCutLog(fawCutName, spmMat(), fawCutBox);
2082 
2083     const Pt3D bb1(fawBoxParms[0], fawBoxParms[1], fawBoxParms[2]);
2084     const Pt3D bb2(-fawBoxParms[0], fawBoxParms[1], fawBoxParms[2]);
2085     const Pt3D bb3(-fawBoxParms[0], fawBoxParms[1], -fawBoxParms[2]);
2086 
2087     const Tf3D fawCutForm(bb1,
2088                           bb2,
2089                           bb3,
2090                           vFAW[2] + Pt3D(2 * hawBoxClr, -5 * mm, 0),
2091                           vFAW[1] + Pt3D(-2 * hawBoxClr, -5 * mm, 0),
2092                           Pt3D(vFAW[1].x() - 2 * hawBoxClr, vFAW[1].y() - trapFAW.h(), vFAW[1].z() - zDel));
2093 
2094     const DDSolid fawSolid(DDSolidFactory::subtraction(
2095         fawName(),
2096         fawSolid1,
2097         fawCutBox,
2098         DDTranslation(
2099             fawCutForm.getTranslation().x(), fawCutForm.getTranslation().y(), fawCutForm.getTranslation().z()),
2100         myrot(fawCutName.name() + "R", fawCutForm.getRotation())));
2101 #ifdef EDM_ML_DEBUG
2102     edm::LogVerbatim("EBGeom") << fawName() << " Subtraction " << fawSolid1.name() << ":" << fawCutBox.name() << " at "
2103                                << DDTranslation(fawCutForm.getTranslation().x(),
2104                                                 fawCutForm.getTranslation().y(),
2105                                                 fawCutForm.getTranslation().z());
2106 #endif
2107     const DDLogicalPart fawLog(fawName(), spmMat(), fawSolid);
2108 
2109     const Tf3D hawRform(vHAW[3],
2110                         vHAW[0],
2111                         vHAW[1],  // HAW inside FAW
2112                         vFAW[3],
2113                         0.5 * (vFAW[0] + vFAW[3]),
2114                         0.5 * (vFAW[1] + vFAW[2]));
2115     cpv.position(
2116         hawRLog,
2117         fawLog,
2118         copyOne,
2119         DDTranslation(hawRform.getTranslation().x(), hawRform.getTranslation().y(), hawRform.getTranslation().z()),
2120         myrot(hawRName().name() + "R", hawRform.getRotation()));
2121 #ifdef EDM_ML_DEBUG
2122     edm::LogVerbatim("EBGeomX") << hawRLog.name() << ":" << copyOne << " positioned in " << fawLog.name() << " at "
2123                                 << DDTranslation(hawRform.getTranslation().x(),
2124                                                  hawRform.getTranslation().y(),
2125                                                  hawRform.getTranslation().z())
2126                                 << " with rotation";
2127 #endif
2128     cpv.position(
2129         hawRLog,
2130         fawLog,
2131         copyTwo,
2132         DDTranslation(-hawRform.getTranslation().x(), -hawRform.getTranslation().y(), -hawRform.getTranslation().z()),
2133         myrot(hawRName().name() + "RotRefl",
2134               CLHEP::HepRotationY(180 * deg) *  // rotate about Y after refl thru Z
2135                   CLHEP::HepRep3x3(1, 0, 0, 0, 1, 0, 0, 0, -1)));
2136 #ifdef EDM_ML_DEBUG
2137     edm::LogVerbatim("EBGeomX") << hawRLog.name() << ":" << copyTwo << " positioned in " << fawLog.name() << " at "
2138                                 << DDTranslation(-hawRform.getTranslation().x(),
2139                                                  -hawRform.getTranslation().y(),
2140                                                  -hawRform.getTranslation().z())
2141                                 << " with rotation";
2142 #endif
2143     /* this for display of haw cut box instead of subtraction
2144       cpv.position( hawCutLog,
2145          hawRName, 
2146          copyOne, 
2147          hawCutForm.getTranslation(),
2148          myrot( hawCutName.name()+"R", 
2149             hawCutForm.getRotation() )   ) ;
2150 */
2151 
2152     for (unsigned int iPhi(1); iPhi <= nFawPerSupm(); ++iPhi) {
2153       const double rPhi(fawPhiOff() + (iPhi - 0.5) * fawDelPhi());
2154 
2155       const Tf3D fawform(RoZ3D(rPhi) * Tl3D(fawRadOff() + (trapFAW.H() + trapFAW.h()) / 4, 0, trapFAW.L() / 2) *
2156                          RoZ3D(-90 * deg + fawPhiRot()));
2157       if (fawHere())
2158         cpv.position(
2159             fawLog,
2160             spmLog,
2161             iPhi,
2162             DDTranslation(fawform.getTranslation().x(), fawform.getTranslation().y(), fawform.getTranslation().z()),
2163             myrot(fawName().name() + "_Rot" + std::to_string(iPhi), fawform.getRotation()));
2164 #ifdef EDM_ML_DEBUG
2165       edm::LogVerbatim("EBGeomX") << fawLog.name() << ":" << iPhi << " positioned in " << spmLog.name() << " at "
2166                                   << DDTranslation(fawform.getTranslation().x(),
2167                                                    fawform.getTranslation().y(),
2168                                                    fawform.getTranslation().z())
2169                                   << " with rotation";
2170 #endif
2171     }
2172 
2173     // End Alveolar Wedge parent ------------------------------------------------------
2174 
2175     // Begin Grid + Tablet insertion
2176 
2177     const double h_Grid(gridThick());
2178 
2179     const Trap trapGrid((B_hawR - h_Grid * (B_hawR - a_hawR) / H_hawR) / 2,  // bl1, A/2
2180                         (b_hawR - h_Grid * (B_hawR - a_hawR) / H_hawR) / 2,  // bl2, a/2
2181                         b_hawR / 2.,                                         // tl2, b/2
2182                         h_Grid / 2.,                                         // h1, H/2
2183                         h_Grid / 2.,                                         // h2, h/2
2184                         (L_hawR - 8 * cm) / 2.,                              // dz,  L/2
2185                         90 * deg,                                            // alfa1
2186                         0,                                                   // x15
2187                         H_hawR - h_hawR                                      // y15
2188     );
2189 
2190     const DDSolid gridSolid(mytrap(gridName().name(), trapGrid));
2191     const DDLogicalPart gridLog(gridName(), gridMat(), gridSolid);
2192 
2193     const Trap::VertexList vGrid(trapGrid.vertexList());
2194 
2195     const Tf3D gridForm(vGrid[4],
2196                         vGrid[5],
2197                         vGrid[6],  // Grid inside HAW
2198                         vHAW[5] - Pt3D(0, h_Grid, 0),
2199                         vHAW[5],
2200                         vHAW[6]);
2201 
2202     if (0 != gridHere())
2203       cpv.position(
2204           gridLog,
2205           hawRLog,
2206           copyOne,
2207           DDTranslation(gridForm.getTranslation().x(), gridForm.getTranslation().y(), gridForm.getTranslation().z()),
2208           myrot(gridName().name() + "R", gridForm.getRotation()));
2209 #ifdef EDM_ML_DEBUG
2210     edm::LogVerbatim("EBGeomX") << gridLog.name() << ":" << copyOne << " positioned in " << hawRLog.name() << " at "
2211                                 << DDTranslation(gridForm.getTranslation().x(),
2212                                                  gridForm.getTranslation().y(),
2213                                                  gridForm.getTranslation().z())
2214                                 << " with rotation";
2215 #endif
2216     // End Grid + Tablet insertion
2217 
2218     // begin filling Wedge with crystal plus supports --------------------------
2219 
2220     const double aNom(nomCryDimAF());
2221     const double LNom(nomCryDimLZ());
2222 
2223     const double AUnd(underAR());
2224     const double aUnd(underAF());
2225     //      const double BUnd ( underCR() ) ;
2226     const double bUnd(underCF());
2227     const double HUnd(underBR());
2228     const double hUnd(underBF());
2229     const double LUnd(underLZ());
2230 
2231     const double sWall(wallThAlv());
2232     const double sWrap(wrapThAlv());
2233     const double sClr(clrThAlv());
2234 
2235     const double fWall(wallFrAlv());
2236     const double fWrap(wrapFrAlv());
2237     const double fClr(clrFrAlv());
2238 
2239     const double rWall(wallReAlv());
2240     const double rWrap(wrapReAlv());
2241     const double rClr(clrReAlv());
2242 
2243     // theta is angle in yz plane between z axis & leading edge of crystal
2244     double theta(90 * deg);
2245     double zee(0 * mm);
2246     double side(0 * mm);
2247     double zeta(0 * deg);  // increment in theta for last crystal
2248 
2249     for (unsigned int cryType(1); cryType <= nCryTypes(); ++cryType) {
2250       const std::string sType("_" + std::string(10 > cryType ? "0" : "") + std::to_string(cryType));
2251 
2252 #ifdef EDM_ML_DEBUG
2253       edm::LogVerbatim("EcalGeom") << "Crytype=" << cryType;
2254 #endif
2255       const double ANom(vecNomCryDimAR()[cryType - 1]);
2256       const double BNom(vecNomCryDimCR()[cryType - 1]);
2257       const double bNom(vecNomCryDimCF()[cryType - 1]);
2258       const double HNom(vecNomCryDimBR()[cryType - 1]);
2259       const double hNom(vecNomCryDimBF()[cryType - 1]);
2260 
2261       const double alfCry(90 * deg + atan((bNom - bUnd - aNom + aUnd) / (hNom - hUnd)));
2262 
2263       const Trap trapCry((ANom - AUnd) / 2.,         //double aHalfLengthXNegZLoY , // bl1, A/2
2264                          (aNom - aUnd) / 2.,         //double aHalfLengthXPosZLoY , // bl2, a/2
2265                          (bNom - bUnd) / 2.,         //double aHalfLengthXPosZHiY , // tl2, b/2
2266                          (HNom - HUnd) / 2.,         //double aHalfLengthYNegZ    , // h1, H/2
2267                          (hNom - hUnd) / 2.,         //double aHalfLengthYPosZ    , // h2, h/2
2268                          (LNom - LUnd) / 2.,         //double aHalfLengthZ        , // dz,  L/2
2269                          alfCry,                     //double aAngleAD            , // alfa1
2270                          aNom - aUnd - ANom + AUnd,  //double aCoord15X           , // x15
2271                          hNom - hUnd - HNom + HUnd   //double aCoord15Y             // y15
2272       );
2273 
2274       const DDName cryDDName(cryName() + sType);
2275       const DDSolid crySolid(mytrap(cryDDName.name(), trapCry));
2276       const DDLogicalPart cryLog(cryDDName, cryMat(), crySolid);
2277 
2278       //++++++++++++++++++++++++++++++++++  APD ++++++++++++++++++++++++++++++++++
2279       const unsigned int copyCap(1);
2280 
2281       const DDName capDDName(capName().name() + sType);
2282 
2283       DDSolid capSolid(DDSolidFactory::box(capDDName, capXSize() / 2., capYSize() / 2., capThick() / 2.));
2284 #ifdef EDM_ML_DEBUG
2285       edm::LogVerbatim("EBGeom") << capDDName << " Box " << capXSize() / 2. << ":" << capYSize() / 2 << ":"
2286                                  << capThick() / 2;
2287 #endif
2288 
2289       const DDLogicalPart capLog(capDDName, capMat(), capSolid);
2290 
2291       const DDName sglDDName(sglName().name() + sType);
2292 
2293       DDSolid sglSolid(DDSolidFactory::box(sglDDName, capXSize() / 2., capYSize() / 2., sglThick() / 2.));
2294 #ifdef EDM_ML_DEBUG
2295       edm::LogVerbatim("EBGeom") << sglDDName << " Box " << capXSize() / 2. << ":" << capYSize() / 2 << ":"
2296                                  << sglThick() / 2;
2297 #endif
2298 
2299       const DDLogicalPart sglLog(sglDDName, sglMat(), sglSolid);
2300 
2301       const unsigned int copySGL(1);
2302 
2303       const DDName cerDDName(cerName().name() + sType);
2304 
2305       DDSolid cerSolid(DDSolidFactory::box(cerDDName, cerXSize() / 2., cerYSize() / 2., cerThick() / 2.));
2306 #ifdef EDM_ML_DEBUG
2307       edm::LogVerbatim("EBGeom") << cerDDName << " Box " << cerXSize() / 2. << ":" << cerYSize() / 2 << ":"
2308                                  << cerThick() / 2;
2309 #endif
2310 
2311       const DDLogicalPart cerLog(cerDDName, cerMat(), cerSolid);
2312 
2313       unsigned int copyCER(0);
2314 
2315       const DDName bsiDDName(bsiName().name() + sType);
2316 
2317       DDSolid bsiSolid(DDSolidFactory::box(bsiDDName, bsiXSize() / 2., bsiYSize() / 2., bsiThick() / 2.));
2318 #ifdef EDM_ML_DEBUG
2319       edm::LogVerbatim("EBGeom") << bsiDDName << " Box " << bsiXSize() / 2. << ":" << bsiYSize() / 2 << ":"
2320                                  << bsiThick() / 2;
2321 #endif
2322 
2323       const DDLogicalPart bsiLog(bsiDDName, bsiMat(), bsiSolid);
2324 
2325       const unsigned int copyBSi(1);
2326 
2327       const DDName atjDDName(atjName().name() + sType);
2328 
2329       DDSolid atjSolid(DDSolidFactory::box(atjDDName, apdSide() / 2., apdSide() / 2., atjThick() / 2.));
2330 #ifdef EDM_ML_DEBUG
2331       edm::LogVerbatim("EBGeom") << atjDDName << " Box " << apdSide() / 2. << ":" << apdSide() / 2 << ":"
2332                                  << atjThick() / 2;
2333 #endif
2334 
2335       const DDLogicalPart atjLog(atjDDName, atjMat(), atjSolid);
2336 
2337       const unsigned int copyATJ(1);
2338 
2339       const DDName aglDDName(aglName().name() + sType);
2340 
2341       DDSolid aglSolid(DDSolidFactory::box(aglDDName, bsiXSize() / 2., bsiYSize() / 2., aglThick() / 2.));
2342 #ifdef EDM_ML_DEBUG
2343       edm::LogVerbatim("EBGeom") << aglDDName << " Box " << bsiXSize() / 2. << ":" << bsiYSize() / 2 << ":"
2344                                  << aglThick() / 2;
2345 #endif
2346 
2347       const DDLogicalPart aglLog(aglDDName, aglMat(), aglSolid);
2348 
2349       const unsigned int copyAGL(1);
2350 
2351       const DDName andDDName(andName().name() + sType);
2352 
2353       DDSolid andSolid(DDSolidFactory::box(andDDName, apdSide() / 2., apdSide() / 2., andThick() / 2.));
2354 #ifdef EDM_ML_DEBUG
2355       edm::LogVerbatim("EBGeom") << andDDName << " Box " << apdSide() / 2. << ":" << apdSide() / 2 << ":"
2356                                  << andThick() / 2;
2357 #endif
2358 
2359       const DDLogicalPart andLog(andDDName, andMat(), andSolid);
2360 
2361       const unsigned int copyAND(1);
2362 
2363       const DDName apdDDName(apdName().name() + sType);
2364 
2365       DDSolid apdSolid(DDSolidFactory::box(apdDDName, apdSide() / 2., apdSide() / 2., apdThick() / 2.));
2366 #ifdef EDM_ML_DEBUG
2367       edm::LogVerbatim("EBGeom") << apdDDName << " Box " << apdSide() / 2. << ":" << apdSide() / 2. << ":"
2368                                  << apdThick() / 2;
2369 #endif
2370 
2371       const DDLogicalPart apdLog(apdDDName, apdMat(), apdSolid);
2372 
2373       const unsigned int copyAPD(1);
2374       //++++++++++++++++++++++++++++++++++ END APD ++++++++++++++++++++++++++++++++++
2375 
2376       const double delta(atan((HNom - hNom) / LNom));
2377       //unused   const double cosdelta  ( cos( delta ) ) ;
2378       const double sindelta(sin(delta));
2379 
2380       const double gamma(atan((ANom - aNom) / LNom));
2381       //unused   const double cosgamma  ( cos( gamma ) ) ;
2382       const double singamma(sin(gamma));
2383 
2384       const double beta(atan((BNom - bNom) / LNom));
2385       //unused   const double cosbeta   ( cos( beta ) ) ;
2386       const double sinbeta(sin(beta));
2387 
2388       // Now clearance trap
2389       const double alfClr(90 * deg + atan((bNom - aNom) / (hNom + sClr)));
2390 
2391       const Trap trapClr((ANom + sClr + rClr * singamma) / 2.,  //double aHalfLengthXNegZLoY , // bl1, A/2
2392                          (aNom + sClr - fClr * singamma) / 2.,  //double aHalfLengthXPosZLoY , // bl2, a/2
2393                          (bNom + sClr - fClr * sinbeta) / 2.,   //double aHalfLengthXPosZHiY , // tl2, b/2
2394                          (HNom + sClr + rClr * sindelta) / 2.,  //double aHalfLengthYNegZ    , // h1,  H/2
2395                          (hNom + sClr - fClr * sindelta) / 2.,  //double aHalfLengthYPosZ    , // h2,  h/2
2396                          (LNom + fClr + rClr) / 2.,             // dz,  L/2
2397                          alfClr,                                //double aAngleAD            , // alfa1
2398                          aNom - ANom,                           //double aCoord15X           , // x15
2399                          hNom - HNom                            //double aCoord15Y             // y15
2400       );
2401 
2402       const DDName clrDDName(clrName() + sType);
2403       const DDSolid clrSolid(mytrap(clrDDName.name(), trapClr));
2404       const DDLogicalPart clrLog(clrDDName, clrMat(), clrSolid);
2405 
2406       // Now wrap trap
2407 
2408       const double alfWrap(90 * deg + atan((bNom - aNom) / (hNom + sClr + 2 * sWrap)));
2409 
2410       const Trap trapWrap((trapClr.A() + 2 * sWrap + rWrap * singamma) / 2,  // bl1, A/2
2411                           (trapClr.a() + 2 * sWrap - fWrap * singamma) / 2,  // bl2, a/2
2412                           (trapClr.b() + 2 * sWrap - fWrap * sinbeta) / 2,   // tl2, b/2
2413                           (trapClr.H() + 2 * sWrap + rWrap * sindelta) / 2,  // h1,  H/2
2414                           (trapClr.h() + 2 * sWrap - fWrap * sindelta) / 2,  // h2,  h/2
2415                           (trapClr.L() + fWrap + rWrap) / 2.,                // dz,  L/2
2416                           alfWrap,                                           //double aAngleAD            , // alfa1
2417                           aNom - ANom - (cryType > 9 ? 0 : 0.020 * mm),
2418                           hNom - HNom  //double aCoord15Y             // y15
2419       );
2420 
2421       const DDName wrapDDName(wrapName() + sType);
2422       const DDSolid wrapSolid(mytrap(wrapDDName.name(), trapWrap));
2423       const DDLogicalPart wrapLog(wrapDDName, wrapMat(), wrapSolid);
2424 
2425       // Now wall trap
2426 
2427       const double alfWall(90 * deg + atan((bNom - aNom) / (hNom + sClr + 2 * sWrap + 2 * sWall)));
2428 
2429       const Trap trapWall((trapWrap.A() + 2 * sWall + rWall * singamma) / 2,  // A/2
2430                           (trapWrap.a() + 2 * sWall - fWall * singamma) / 2,  // a/2
2431                           (trapWrap.b() + 2 * sWall - fWall * sinbeta) / 2,   // b/2
2432                           (trapWrap.H() + 2 * sWall + rWall * sindelta) / 2,  // H/2
2433                           (trapWrap.h() + 2 * sWall - fWall * sindelta) / 2,  // h/2
2434                           (trapWrap.L() + fWall + rWall) / 2.,                // L/2
2435                           alfWall,                                            // alfa1
2436                           aNom - ANom - (cryType < 10 ? 0.150 * mm : 0.100 * mm),
2437                           hNom - HNom  // y15
2438       );
2439 
2440       const DDName wallDDName(wallName() + sType);
2441       const DDSolid wallSolid(mytrap(wallDDName.name(), trapWall));
2442       const DDLogicalPart wallLog(wallDDName, wallMat(), wallSolid);
2443 
2444       /*     
2445          edm::LogVerbatim("EcalGeom") << "Traps:\n a: " 
2446         << trapCry.a() << ", " 
2447         << trapClr.a() << ", " 
2448         << trapWrap.a() << ", " 
2449         << trapWall.a() << "\n b: " 
2450         << trapCry.b() << ", " 
2451         << trapClr.b() << ", " 
2452         << trapWrap.b() << ", " 
2453         << trapWall.b() << "\n A: " 
2454         << trapCry.A() << ", " 
2455         << trapClr.A() << ", " 
2456         << trapWrap.A() << ", " 
2457         << trapWall.A() << "\n B: " 
2458         << trapCry.B() << ", " 
2459         << trapClr.B() << ", " 
2460         << trapWrap.B() << ", " 
2461         << trapWall.B() << "\n h: " 
2462         << trapCry.h() << ", " 
2463         << trapClr.h() << ", " 
2464         << trapWrap.h() << ", " 
2465         << trapWall.h() << "\n H: " 
2466         << trapCry.H() << ", " 
2467         << trapClr.H() << ", " 
2468         << trapWrap.H() << ", " 
2469         << trapWall.H() << "\n a1: " 
2470         << trapCry.a1()/deg << ", " 
2471         << trapClr.a1()/deg << ", " 
2472         << trapWrap.a1()/deg << ", " 
2473         << trapWall.a1()/deg << "\n a4: " 
2474         << trapCry.a4()/deg << ", " 
2475         << trapClr.a4()/deg << ", " 
2476         << trapWrap.a4()/deg << ", " 
2477         << trapWall.a4()/deg << "\n x15: " 
2478         << trapCry.x15() << ", " 
2479         << trapClr.x15() << ", " 
2480         << trapWrap.x15() << ", " 
2481         << trapWall.x15() << "\n y15: " 
2482         << trapCry.y15() << ", " 
2483         << trapClr.y15() << ", " 
2484         << trapWrap.y15() << ", " 
2485         << trapWall.y15();
2486 */
2487       // Now for placement of cry within clr
2488       const Vec3 cryToClr(0, 0, (rClr - fClr) / 2);
2489 
2490       cpv.position(cryLog,
2491                    clrLog,
2492                    copyOne,
2493                    DDTranslation(0, 0, (rClr - fClr) / 2),  //SAME as cryToClr above.
2494                    DDRotation());
2495 #ifdef EDM_ML_DEBUG
2496       edm::LogVerbatim("EBGeomX") << cryLog.name() << ":" << copyOne << " positioned in " << clrLog.name() << " at "
2497                                   << DDTranslation(0, 0, (rClr - fClr) / 2) << " with no rotation";
2498 #endif
2499       if (0 != capHere()) {
2500         cpv.position(aglLog, bsiLog, copyAGL, DDTranslation(0, 0, -aglThick() / 2. + bsiThick() / 2.), DDRotation());
2501 #ifdef EDM_ML_DEBUG
2502         edm::LogVerbatim("EBGeomX") << aglLog.name() << ":" << copyAGL << " positioned in " << bsiLog.name() << " at "
2503                                     << DDTranslation(0, 0, -aglThick() / 2. + bsiThick() / 2.) << " with no rotation";
2504 #endif
2505 
2506         cpv.position(
2507             andLog, bsiLog, copyAND, DDTranslation(0, 0, -andThick() / 2. - aglThick() + bsiThick() / 2.), DDRotation());
2508 #ifdef EDM_ML_DEBUG
2509         edm::LogVerbatim("EBGeomX") << andLog.name() << ":" << copyAND << " positioned in " << bsiLog.name() << " at "
2510                                     << DDTranslation(0, 0, -andThick() / 2. - aglThick() + bsiThick() / 2.)
2511                                     << " with no rotation";
2512 #endif
2513         cpv.position(apdLog,
2514                      bsiLog,
2515                      copyAPD,
2516                      DDTranslation(0, 0, -apdThick() / 2. - andThick() - aglThick() + bsiThick() / 2.),
2517                      DDRotation());
2518 #ifdef EDM_ML_DEBUG
2519         edm::LogVerbatim("EBGeomX") << apdLog.name() << ":" << copyAPD << " positioned in " << bsiLog.name() << " at "
2520                                     << DDTranslation(0, 0, -apdThick() / 2. - andThick() - aglThick() + bsiThick() / 2.)
2521                                     << " with no rotation";
2522 #endif
2523         cpv.position(atjLog,
2524                      bsiLog,
2525                      copyATJ,
2526                      DDTranslation(0, 0, -atjThick() / 2. - apdThick() - andThick() - aglThick() + bsiThick() / 2.),
2527                      DDRotation());
2528 #ifdef EDM_ML_DEBUG
2529         edm::LogVerbatim("EBGeomX")
2530             << atjLog.name() << ":" << copyATJ << " positioned in " << bsiLog.name() << " at "
2531             << DDTranslation(0, 0, -atjThick() / 2. - apdThick() - andThick() - aglThick() + bsiThick() / 2.)
2532             << " with no rotation";
2533 #endif
2534         cpv.position(bsiLog, cerLog, copyBSi, DDTranslation(0, 0, -bsiThick() / 2. + cerThick() / 2.), DDRotation());
2535 #ifdef EDM_ML_DEBUG
2536         edm::LogVerbatim("EBGeomX") << bsiLog.name() << ":" << copyBSi << " positioned in " << cerLog.name() << " at "
2537                                     << DDTranslation(0, 0, -bsiThick() / 2. + cerThick() / 2.) << " with no rotation";
2538 #endif
2539         cpv.position(sglLog, capLog, copySGL, DDTranslation(0, 0, -sglThick() / 2. + capThick() / 2.), DDRotation());
2540 #ifdef EDM_ML_DEBUG
2541         edm::LogVerbatim("EBGeomX") << sglLog.name() << ":" << copySGL << " positioned in " << capLog.name() << " at "
2542                                     << DDTranslation(0, 0, -sglThick() / 2. + capThick() / 2.) << " with no rotation";
2543 #endif
2544         for (unsigned int ijkl(0); ijkl != 2; ++ijkl) {
2545           cpv.position(cerLog,
2546                        capLog,
2547                        ++copyCER,
2548                        DDTranslation(trapCry.bl1() - (0 == ijkl ? apdX1() : apdX2()),
2549                                      trapCry.h1() - apdZ(),
2550                                      -sglThick() - cerThick() / 2. + capThick() / 2.),
2551                        DDRotation());
2552 #ifdef EDM_ML_DEBUG
2553           edm::LogVerbatim("EBGeomX") << cerLog.name() << ":" << copyCER << " positioned in " << capLog.name() << " at "
2554                                       << DDTranslation(trapCry.bl1() - (0 == ijkl ? apdX1() : apdX2()),
2555                                                        (trapCry.h1() - apdZ()),
2556                                                        (-sglThick() - cerThick() / 2. + capThick() / 2.))
2557                                       << " with no rotation";
2558 #endif
2559         }
2560         cpv.position(capLog,
2561                      clrLog,
2562                      copyCap,
2563                      DDTranslation(0, 0, -trapCry.dz() - capThick() / 2. + (rClr - fClr) / 2.),
2564                      DDRotation());
2565 #ifdef EDM_ML_DEBUG
2566         edm::LogVerbatim("EBGeomX") << capLog.name() << ":" << copyCap << " positioned in " << clrLog.name() << " at "
2567                                     << DDTranslation(0, 0, -trapCry.dz() - capThick() / 2. + (rClr - fClr) / 2.)
2568                                     << " with no rotation";
2569 #endif
2570       }
2571 
2572       const Vec3 clrToWrap(0, 0, (rWrap - fWrap) / 2);
2573 
2574       cpv.position(clrLog,
2575                    wrapLog,
2576                    copyOne,
2577                    DDTranslation(0, 0, (rWrap - fWrap) / 2),  //SAME as cryToWrap
2578                    DDRotation());
2579 #ifdef EDM_ML_DEBUG
2580       edm::LogVerbatim("EBGeomX") << clrLog.name() << ":" << copyOne << " positioned in " << wrapLog.name() << " at "
2581                                   << DDTranslation(0, 0, (rWrap - fWrap) / 2) << " with no rotation";
2582 #endif
2583 
2584       // Now for placement of clr within wall
2585       const Vec3 wrapToWall1(0, 0, (rWall - fWall) / 2);
2586       const Vec3 wrapToWall(Vec3((cryType > 9 ? 0 : 0.005 * mm), 0, 0) + wrapToWall1);
2587 
2588       cpv.position(wrapLog,
2589                    wallLog,
2590                    copyOne,
2591                    DDTranslation(Vec3((cryType > 9 ? 0 : 0.005 * mm), 0, 0) + wrapToWall1),  //SAME as wrapToWall
2592                    DDRotation());
2593 #ifdef EDM_ML_DEBUG
2594       edm::LogVerbatim("EBGeomX") << wrapLog.name() << ":" << copyOne << " positioned in " << wallLog.name() << " at "
2595                                   << DDTranslation(Vec3((cryType > 9 ? 0 : 0.005 * mm), 0, 0) + wrapToWall1)
2596                                   << " with no rotation";
2597 #endif
2598       const Trap::VertexList vWall(trapWall.vertexList());
2599       const Trap::VertexList vCry(trapCry.vertexList());
2600 
2601       const double sidePrime((trapWall.a() - trapCry.a()) / 2);
2602       const double frontPrime(fWall + fWrap + fClr + LUnd / 2);
2603 
2604       // define web plates with clearance ===========================================
2605 
2606       if (1 == cryType)  // first web plate: inside clearance volume
2607       {
2608         web(0,
2609             trapWall.b(),
2610             trapWall.B(),
2611             trapWall.L(),
2612             theta,
2613             vHAW[4] + Pt3D(0, hawYOffCry(), 0),
2614             hawRLog,
2615             zee,
2616             sidePrime,
2617             frontPrime,
2618             delta,
2619             cpv);
2620         zee += vecGapAlvEta()[0];
2621       }
2622 
2623       for (unsigned int etaAlv(1); etaAlv <= nCryPerAlvEta(); ++etaAlv) {
2624 #ifdef EDM_ML_DEBUG
2625         edm::LogVerbatim("EcalGeom") << "theta=" << theta / deg << ", sidePrime=" << sidePrime
2626                                      << ", frontPrime=" << frontPrime << ",  zeta=" << zeta << ", delta=" << delta
2627                                      << ",  zee=" << zee;
2628 #endif
2629         zee += 0.075 * mm + (side * cos(zeta) + trapWall.h() - sidePrime) / sin(theta);
2630 
2631 #ifdef EDM_ML_DEBUG
2632         edm::LogVerbatim("EcalGeom") << "New zee=" << zee;
2633 #endif
2634         // make transform for placing enclosed crystal
2635 
2636         const Pt3D trap2(vCry[2] + cryToClr + clrToWrap + wrapToWall);
2637 
2638         const Pt3D trap3(trap2 + Pt3D(0, -trapCry.h(), 0));
2639         const Pt3D trap1(trap3 + Pt3D(-trapCry.a(), 0, 0));
2640 
2641         const Pt3D wedge3(vHAW[4] + Pt3D(sidePrime, hawYOffCry(), zee));
2642         const Pt3D wedge2(wedge3 + Pt3D(0, trapCry.h() * cos(theta), -trapCry.h() * sin(theta)));
2643         const Pt3D wedge1(wedge3 + Pt3D(trapCry.a(), 0, 0));
2644 
2645         const Tf3D tForm1(trap1, trap2, trap3, wedge1, wedge2, wedge3);
2646 
2647         const double xx(0.050 * mm);
2648 
2649         const Tf3D tForm(HepGeom::Translate3D(xx, 0, 0) * tForm1);
2650 
2651         cpv.position(wallLog,
2652                      hawRLog,
2653                      etaAlv,
2654                      DDTranslation(tForm.getTranslation().x(), tForm.getTranslation().y(), tForm.getTranslation().z()),
2655                      myrot(wallLog.name().name() + "_" + std::to_string(etaAlv), tForm.getRotation()));
2656 #ifdef EDM_ML_DEBUG
2657         edm::LogVerbatim("EBGeomX") << wallLog.name() << ":" << etaAlv << " positioned in " << hawRLog.name() << " at "
2658                                     << DDTranslation(tForm.getTranslation().x(),
2659                                                      tForm.getTranslation().y(),
2660                                                      tForm.getTranslation().z())
2661                                     << " with rotation";
2662 #endif
2663         theta -= delta;
2664         side = sidePrime;
2665         zeta = delta;
2666       }
2667       if (5 == cryType || 9 == cryType || 13 == cryType || 17 == cryType)  // web plates
2668       {
2669         const unsigned int webIndex(cryType / 4);
2670         zee += 0.5 * vecGapAlvEta()[cryType] / sin(theta);
2671         web(webIndex,
2672             trapWall.a(),
2673             trapWall.A(),
2674             trapWall.L(),
2675             theta,
2676             vHAW[4] + Pt3D(0, hawYOffCry(), 0),
2677             hawRLog,
2678             zee,
2679             sidePrime,
2680             frontPrime,
2681             delta,
2682             cpv);
2683         zee += 0.5 * vecGapAlvEta()[cryType] / sin(theta);
2684       } else {
2685         if (17 != cryType)
2686           zee += vecGapAlvEta()[cryType] / sin(theta);
2687       }
2688     }
2689     // END   filling Wedge with crystal plus supports --------------------------
2690 
2691     //------------------------------------------------------------------------
2692     //------------------------------------------------------------------------
2693     //------------------------------------------------------------------------
2694     //------------------------------------------------------------------------
2695     //**************** Material at outer radius of supermodule ***************
2696     //------------------------------------------------------------------------
2697     //------------------------------------------------------------------------
2698     //------------------------------------------------------------------------
2699     //------------------------------------------------------------------------
2700 
2701     if (0 != backHere()) {
2702       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2703       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2704       //!!!!!!!!!!!!!!     Begin Back Cover Plate     !!!!!!!!!!!!!!!!!!!!!!!
2705       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2706       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2707 
2708       const DDTranslation outtra(backXOff() + backSideHeight() / 2, backYOff(), backSideLength() / 2);
2709 
2710       const double realBPthick(backPlateThick() + backPlate2Thick());
2711 
2712       DDSolid backPlateSolid(
2713           DDSolidFactory::box(backPlateName(), backPlateWidth() / 2., realBPthick / 2., backPlateLength() / 2.));
2714 #ifdef EDM_ML_DEBUG
2715       edm::LogVerbatim("EBGeom") << backPlateName() << " Box " << backPlateWidth() / 2. << ":" << realBPthick / 2.
2716                                  << ":" << backPlateLength() / 2;
2717 #endif
2718       const std::vector<double>& backPlateParms(backPlateSolid.parameters());
2719       const DDLogicalPart backPlateLog(backPlateName(), backPlateMat(), backPlateSolid);
2720 
2721       const DDTranslation backPlateTra(
2722           backSideHeight() / 2 + backPlateParms[1], 0 * mm, backPlateParms[2] - backSideLength() / 2);
2723 
2724       DDSolid backPlate2Solid(
2725           DDSolidFactory::box(backPlate2Name(), backPlateWidth() / 2., backPlate2Thick() / 2., backPlateLength() / 2.));
2726 #ifdef EDM_ML_DEBUG
2727       edm::LogVerbatim("EBGeom") << backPlate2Name() << " Box " << backPlateWidth() / 2. << ":"
2728                                  << backPlate2Thick() / 2. << ":" << backPlateLength() / 2;
2729 #endif
2730 
2731       const DDLogicalPart backPlate2Log(backPlate2Name(), backPlate2Mat(), backPlate2Solid);
2732 
2733       const DDTranslation backPlate2Tra(0, -backPlateParms[1] + backPlate2Thick() / 2., 0);
2734       if (0 != backPlateHere()) {
2735         cpv.position(backPlate2Log, backPlateName(), copyOne, backPlate2Tra, DDRotation());
2736 #ifdef EDM_ML_DEBUG
2737         edm::LogVerbatim("EBGeomX") << backPlate2Log.name() << ":" << copyOne << " positioned in " << backPlateName()
2738                                     << " at " << backPlate2Tra << " with no rotation";
2739 #endif
2740         cpv.position(backPlateLog,
2741                      spmName(),
2742                      copyOne,
2743                      outtra + backPlateTra,
2744                      myrot(backPlateName().name() + "Rot5", CLHEP::HepRotationZ(270 * deg)));
2745 #ifdef EDM_ML_DEBUG
2746         edm::LogVerbatim("EBGeomX") << backPlateLog.name() << ":" << copyOne << " positioned in " << spmName() << " at "
2747                                     << (outtra + backPlateTra) << " with rotation";
2748 #endif
2749       }
2750       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2751       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2752       //!!!!!!!!!!!!!!     End Back Cover Plate       !!!!!!!!!!!!!!!!!!!!!!!
2753       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2754       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2755 
2756       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2757       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2758       //!!!!!!!!!!!!!!     Begin Back Side Plates    !!!!!!!!!!!!!!!!!!!!!!!
2759       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2760       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2761 
2762       const Trap trapBS(backSideWidth() / 2.,   //double aHalfLengthXNegZLoY , // bl1, A/2
2763                         backSideWidth() / 2.,   //double aHalfLengthXPosZLoY , // bl2, a/2
2764                         backSideWidth() / 4.,   //double aHalfLengthXPosZHiY , // tl2, b/2
2765                         backSideHeight() / 2.,  //double aHalfLengthYNegZ    , // h1, H/2
2766                         backSideHeight() / 2.,  //double aHalfLengthYPosZ    , // h2, h/2
2767                         backSideLength() / 2.,  //double aHalfLengthZ        , // dz,  L/2
2768                         backSideAngle(),        //double aAngleAD            , // alfa1
2769                         0,                      //double aCoord15X           , // x15
2770                         0                       //double aCoord15Y             // y15
2771       );
2772 
2773       const DDSolid backSideSolid(mytrap(backSideName().name(), trapBS));
2774       const DDLogicalPart backSideLog(backSideName(), backSideMat(), backSideSolid);
2775 
2776       const DDTranslation backSideTra1(0 * mm, backPlateWidth() / 2 + backSideYOff1(), 1 * mm);
2777       if (0 != backSideHere()) {
2778         cpv.position(
2779             backSideLog,
2780             spmName(),
2781             copyOne,
2782             outtra + backSideTra1,
2783             myrot(backSideName().name() + "Rot8", CLHEP::HepRotationX(180 * deg) * CLHEP::HepRotationZ(90 * deg)));
2784 #ifdef EDM_ML_DEBUG
2785         edm::LogVerbatim("EBGeomX") << backSideLog.name() << ":" << copyOne << " positioned in " << spmName() << " at "
2786                                     << (outtra + backSideTra1) << " with rotation";
2787 #endif
2788         const DDTranslation backSideTra2(0 * mm, -backPlateWidth() / 2 + backSideYOff2(), 1 * mm);
2789         cpv.position(backSideLog,
2790                      spmName(),
2791                      copyTwo,
2792                      outtra + backSideTra2,
2793                      myrot(backSideName().name() + "Rot9", CLHEP::HepRotationZ(90 * deg)));
2794 #ifdef EDM_ML_DEBUG
2795         edm::LogVerbatim("EBGeomX") << backSideLog.name() << ":" << copyTwo << " positioned in " << spmName() << " at "
2796                                     << (outtra + backSideTra2) << " with rotation";
2797 #endif
2798       }
2799       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2800       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2801       //!!!!!!!!!!!!!!     End Back Side Plates       !!!!!!!!!!!!!!!!!!!!!!!
2802       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2803       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2804 
2805       //=====================
2806       const double backCoolWidth(backCoolBarWidth() + 2. * backCoolTankWidth());
2807 
2808       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2809       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2810       //!!!!!!!!!!!!!!     Begin Mother Board Cooling Manifold Setup !!!!!!!!
2811       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2812       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2813 
2814       const double manifCut(2 * mm);
2815 
2816       DDSolid mBManifSolid(DDSolidFactory::tubs(
2817           mBManifName(), backCoolWidth / 2. - manifCut, 0, mBManifOutDiam() / 2, 0 * deg, 360 * deg));
2818 #ifdef EDM_ML_DEBUG
2819       edm::LogVerbatim("EBGeom") << mBManifName() << " Tubs " << backCoolWidth / 2. - manifCut
2820                                  << ":0:" << mBManifOutDiam() / 2 << ":0:360";
2821 #endif
2822       const DDLogicalPart mBManifLog(mBManifName(), mBManifMat(), mBManifSolid);
2823 
2824       const DDName mBManifWaName(ddname(mBManifName().name() + "Wa"));
2825       DDSolid mBManifWaSolid(DDSolidFactory::tubs(
2826           mBManifWaName, backCoolWidth / 2. - manifCut, 0, mBManifInnDiam() / 2, 0 * deg, 360 * deg));
2827 #ifdef EDM_ML_DEBUG
2828       edm::LogVerbatim("EBGeom") << mBManifWaName << " Tubs " << backCoolWidth / 2. - manifCut
2829                                  << ":0:" << mBManifInnDiam() / 2 << ":0:360";
2830 #endif
2831       const DDLogicalPart mBManifWaLog(mBManifWaName, backPipeWaterMat(), mBManifWaSolid);
2832       cpv.position(mBManifWaLog, mBManifName(), copyOne, DDTranslation(0, 0, 0), DDRotation());
2833 #ifdef EDM_ML_DEBUG
2834       edm::LogVerbatim("EBGeomX") << mBManifWaLog.name() << ":" << copyOne << " positioned in " << mBManifName()
2835                                   << " at " << DDTranslation(0, 0, 0) << " with no rotation";
2836 #endif
2837       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2838       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2839       //!!!!!!!!!!!!!!     End Mother Board Cooling Manifold Setup   !!!!!!!!
2840       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2841       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2842       //=====================
2843 
2844       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2845       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2846       //!!!!!!!!!!!!!!     Begin Loop over Grilles & MB Cooling Manifold !!!!
2847       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2848       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2849       const double deltaY(-5 * mm);
2850 
2851       DDSolid grEdgeSlotSolid(
2852           DDSolidFactory::box(grEdgeSlotName(), grEdgeSlotHeight() / 2., grEdgeSlotWidth() / 2., grilleThick() / 2.));
2853 #ifdef EDM_ML_DEBUG
2854       edm::LogVerbatim("EBGeom") << grEdgeSlotName() << " Box " << grEdgeSlotHeight() / 2. << ":"
2855                                  << grEdgeSlotWidth() / 2 << ":" << grilleThick() / 2;
2856 #endif
2857       const DDLogicalPart grEdgeSlotLog(grEdgeSlotName(), grEdgeSlotMat(), grEdgeSlotSolid);
2858 
2859       unsigned int edgeSlotCopy(0);
2860       unsigned int midSlotCopy(0);
2861 
2862       DDLogicalPart grMidSlotLog[4];
2863 
2864       for (unsigned int iGr(0); iGr != vecGrilleHeight().size(); ++iGr) {
2865         DDName gName(ddname(grilleName() + std::to_string(iGr)));
2866         DDSolid grilleSolid(
2867             DDSolidFactory::box(gName, vecGrilleHeight()[iGr] / 2., backCoolWidth / 2., grilleThick() / 2.));
2868 #ifdef EDM_ML_DEBUG
2869         edm::LogVerbatim("EBGeom") << gName << " Box " << vecGrilleHeight()[iGr] / 2. << ":" << backCoolWidth / 2 << ":"
2870                                    << grilleThick() / 2;
2871 #endif
2872         const DDLogicalPart grilleLog(gName, grilleMat(), grilleSolid);
2873 
2874         const DDTranslation grilleTra(-realBPthick / 2 - vecGrilleHeight()[iGr] / 2,
2875                                       deltaY,
2876                                       vecGrilleZOff()[iGr] + grilleThick() / 2 - backSideLength() / 2);
2877         const DDTranslation gTra(outtra + backPlateTra + grilleTra);
2878 
2879         if (0 != grMidSlotHere() && 0 != iGr) {
2880           if (0 == (iGr - 1) % 2) {
2881             DDName mName(ddname(grMidSlotName() + std::to_string(iGr / 2)));
2882             DDSolid grMidSlotSolid(DDSolidFactory::box(
2883                 mName, vecGrMidSlotHeight()[(iGr - 1) / 2] / 2., grMidSlotWidth() / 2., grilleThick() / 2.));
2884 #ifdef EDM_ML_DEBUG
2885             edm::LogVerbatim("EBGeom") << mName << " Box " << vecGrMidSlotHeight()[(iGr - 1) / 2] / 2. << ":"
2886                                        << grMidSlotWidth() / 2 << ":" << grilleThick() / 2;
2887 #endif
2888             grMidSlotLog[(iGr - 1) / 2] = DDLogicalPart(mName, grMidSlotMat(), grMidSlotSolid);
2889           }
2890           cpv.position(grMidSlotLog[(iGr - 1) / 2],
2891                        gName,
2892                        ++midSlotCopy,
2893                        DDTranslation(
2894                            vecGrilleHeight()[iGr] / 2. - vecGrMidSlotHeight()[(iGr - 1) / 2] / 2., +grMidSlotXOff(), 0),
2895                        DDRotation());
2896 #ifdef EDM_ML_DEBUG
2897           edm::LogVerbatim("EBGeomX") << grMidSlotLog[(iGr - 1) / 2].name() << ":" << midSlotCopy << " positioned in "
2898                                       << gName << " at "
2899                                       << DDTranslation(
2900                                              vecGrilleHeight()[iGr] / 2. - vecGrMidSlotHeight()[(iGr - 1) / 2] / 2.,
2901                                              +grMidSlotXOff(),
2902                                              0)
2903                                       << " with no rotation";
2904 #endif
2905 
2906           cpv.position(grMidSlotLog[(iGr - 1) / 2],
2907                        gName,
2908                        ++midSlotCopy,
2909                        DDTranslation(
2910                            vecGrilleHeight()[iGr] / 2. - vecGrMidSlotHeight()[(iGr - 1) / 2] / 2., -grMidSlotXOff(), 0),
2911                        DDRotation());
2912 #ifdef EDM_ML_DEBUG
2913           edm::LogVerbatim("EBGeomX") << grMidSlotLog[(iGr - 1) / 2].name() << ":" << midSlotCopy << " positioned in "
2914                                       << gName << " at "
2915                                       << DDTranslation(
2916                                              vecGrilleHeight()[iGr] / 2. - vecGrMidSlotHeight()[(iGr - 1) / 2] / 2.,
2917                                              -grMidSlotXOff(),
2918                                              0)
2919                                       << " with no rotation";
2920 #endif
2921         }
2922 
2923         if (0 != grEdgeSlotHere() && 0 != iGr) {
2924           cpv.position(
2925               grEdgeSlotLog,
2926               gName,
2927               ++edgeSlotCopy,
2928               DDTranslation(
2929                   vecGrilleHeight()[iGr] / 2. - grEdgeSlotHeight() / 2., backCoolWidth / 2 - grEdgeSlotWidth() / 2., 0),
2930               DDRotation());
2931 #ifdef EDM_ML_DEBUG
2932           edm::LogVerbatim("EBGeomX") << grEdgeSlotLog.name() << ":" << edgeSlotCopy << " positioned in " << gName
2933                                       << " at "
2934                                       << DDTranslation(vecGrilleHeight()[iGr] / 2. - grEdgeSlotHeight() / 2.,
2935                                                        backCoolWidth / 2 - grEdgeSlotWidth() / 2.,
2936                                                        0)
2937                                       << " with no rotation";
2938 #endif
2939           cpv.position(grEdgeSlotLog,
2940                        gName,
2941                        ++edgeSlotCopy,
2942                        DDTranslation(vecGrilleHeight()[iGr] / 2. - grEdgeSlotHeight() / 2.,
2943                                      -backCoolWidth / 2 + grEdgeSlotWidth() / 2.,
2944                                      0),
2945                        DDRotation());
2946 #ifdef EDM_ML_DEBUG
2947           edm::LogVerbatim("EBGeomX") << grEdgeSlotLog.name() << ":" << edgeSlotCopy << " positioned in " << gName
2948                                       << " at "
2949                                       << DDTranslation(vecGrilleHeight()[iGr] / 2. - grEdgeSlotHeight() / 2.,
2950                                                        -backCoolWidth / 2 + grEdgeSlotWidth() / 2.,
2951                                                        0)
2952                                       << " with no rotation";
2953 #endif
2954         }
2955         if (0 != grilleHere()) {
2956           cpv.position(grilleLog, spmName(), iGr, gTra, DDRotation());
2957 #ifdef EDM_ML_DEBUG
2958           edm::LogVerbatim("EBGeomX") << grilleLog.name() << ":" << iGr << " positioned in " << spmName() << " at "
2959                                       << gTra << " with no rotation";
2960 #endif
2961         }
2962         if ((0 != iGr % 2) && (0 != mBManifHere())) {
2963           cpv.position(mBManifLog,
2964                        spmName(),
2965                        iGr,
2966                        gTra - DDTranslation(-mBManifOutDiam() / 2. + vecGrilleHeight()[iGr] / 2.,
2967                                             manifCut,
2968                                             grilleThick() / 2. + 3 * mBManifOutDiam() / 2.),
2969                        myrot(mBManifName().name() + "R1", CLHEP::HepRotationX(90 * deg)));
2970 #ifdef EDM_ML_DEBUG
2971           edm::LogVerbatim("EBGeomX") << mBManifLog.name() << ":" << iGr << " positioned in " << spmName() << " at "
2972                                       << (gTra - DDTranslation(-mBManifOutDiam() / 2. + vecGrilleHeight()[iGr] / 2.,
2973                                                                manifCut,
2974                                                                grilleThick() / 2. + 3 * mBManifOutDiam() / 2.))
2975                                       << " with rotation";
2976 #endif
2977           cpv.position(mBManifLog,
2978                        spmName(),
2979                        iGr - 1,
2980                        gTra - DDTranslation(-3 * mBManifOutDiam() / 2. + vecGrilleHeight()[iGr] / 2.,
2981                                             manifCut,
2982                                             grilleThick() / 2 + 3 * mBManifOutDiam() / 2.),
2983                        myrot(mBManifName().name() + "R2", CLHEP::HepRotationX(90 * deg)));
2984 #ifdef EDM_ML_DEBUG
2985           edm::LogVerbatim("EBGeomX") << mBManifLog.name() << ":" << (iGr - 1) << " positioned in " << spmName()
2986                                       << " at "
2987                                       << (gTra - DDTranslation(-3 * mBManifOutDiam() / 2. + vecGrilleHeight()[iGr] / 2.,
2988                                                                manifCut,
2989                                                                grilleThick() / 2 + 3 * mBManifOutDiam() / 2.))
2990                                       << " with rotation";
2991 #endif
2992         }
2993       }
2994 
2995       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2996       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2997       //!!!!!!!!!!!!!!     End Loop over Grilles & MB Cooling Manifold   !!!!
2998       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2999       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3000 
3001       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3002       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3003       //!!!!!!!!!!!!!!     Begin Cooling Bar Setup    !!!!!!!!!!!!!!!!!!!!!!!
3004       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3005       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3006 
3007       DDSolid backCoolBarSolid(DDSolidFactory::box(
3008           backCoolBarName(), backCoolBarHeight() / 2., backCoolBarWidth() / 2., backCoolBarThick() / 2.));
3009 #ifdef EDM_ML_DEBUG
3010       edm::LogVerbatim("EBGeom") << backCoolBarName() << " Box " << backCoolBarHeight() / 2. << ":"
3011                                  << backCoolBarWidth() / 2 << ":" << backCoolBarThick() / 2;
3012 #endif
3013       const DDLogicalPart backCoolBarLog(backCoolBarName(), backCoolBarMat(), backCoolBarSolid);
3014 
3015       DDSolid backCoolBarSSSolid(DDSolidFactory::box(
3016           backCoolBarSSName(), backCoolBarHeight() / 2., backCoolBarWidth() / 2., backCoolBarSSThick() / 2.));
3017 #ifdef EDM_ML_DEBUG
3018       edm::LogVerbatim("EBGeom") << backCoolBarSSName() << " Box " << backCoolBarHeight() / 2. << ":"
3019                                  << backCoolBarWidth() / 2. << ":" << backCoolBarSSThick() / 2.;
3020 #endif
3021       const DDLogicalPart backCoolBarSSLog(backCoolBarSSName(), backCoolBarSSMat(), backCoolBarSSSolid);
3022       const DDTranslation backCoolBarSSTra(0, 0, 0);
3023       cpv.position(backCoolBarSSLog, backCoolBarName(), copyOne, backCoolBarSSTra, DDRotation());
3024 #ifdef EDM_ML_DEBUG
3025       edm::LogVerbatim("EBGeomX") << backCoolBarSSLog.name() << ":" << copyOne << " positioned in " << backCoolBarName()
3026                                   << " at " << backCoolBarSSTra << " with no rotation";
3027 #endif
3028 
3029       DDSolid backCoolBarWaSolid(DDSolidFactory::box(
3030           backCoolBarWaName(), backCoolBarHeight() / 2., backCoolBarWidth() / 2., backCoolBarWaThick() / 2.));
3031 #ifdef EDM_ML_DEBUG
3032       edm::LogVerbatim("EBGeom") << backCoolBarWaName() << " Box " << backCoolBarHeight() / 2. << ":"
3033                                  << backCoolBarWidth() / 2. << ":" << backCoolBarWaThick() / 2;
3034 #endif
3035       const DDLogicalPart backCoolBarWaLog(backCoolBarWaName(), backCoolBarWaMat(), backCoolBarWaSolid);
3036       const DDTranslation backCoolBarWaTra(0, 0, 0);
3037       cpv.position(backCoolBarWaLog, backCoolBarSSName(), copyOne, backCoolBarWaTra, DDRotation());
3038 #ifdef EDM_ML_DEBUG
3039       edm::LogVerbatim("EBGeomX") << backCoolBarWaLog.name() << ":" << copyOne << " positioned in "
3040                                   << backCoolBarSSName() << " at " << backCoolBarWaTra << " with no rotation";
3041 #endif
3042 
3043       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3044       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3045       //!!!!!!!!!!!!!!     End Cooling Bar Setup      !!!!!!!!!!!!!!!!!!!!!!!
3046       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3047       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3048 
3049       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3050       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3051       //!!!!!!!!!!!!!!     Begin VFE Card Setup       !!!!!!!!!!!!!!!!!!!!!!!
3052       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3053       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3054 
3055       double thickVFE(0);
3056       for (unsigned int iLyr(0); iLyr != vecBackVFELyrThick().size(); ++iLyr) {
3057         thickVFE += vecBackVFELyrThick()[iLyr];
3058       }
3059       DDSolid backVFESolid(
3060           DDSolidFactory::box(backVFEName(), backCoolBarHeight() / 2., backCoolBarWidth() / 2., thickVFE / 2.));
3061 #ifdef EDM_ML_DEBUG
3062       edm::LogVerbatim("EBGeom") << backVFEName() << " Box " << backCoolBarHeight() / 2. << ":"
3063                                  << backCoolBarWidth() / 2 << ":" << thickVFE / 2;
3064 #endif
3065       const DDLogicalPart backVFELog(backVFEName(), backVFEMat(), backVFESolid);
3066       DDTranslation offTra(0, 0, -thickVFE / 2);
3067       for (unsigned int iLyr(0); iLyr != vecBackVFELyrThick().size(); ++iLyr) {
3068         DDSolid backVFELyrSolid(DDSolidFactory::box(ddname(vecBackVFELyrName()[iLyr]),
3069                                                     backCoolBarHeight() / 2.,
3070                                                     backCoolBarWidth() / 2.,
3071                                                     vecBackVFELyrThick()[iLyr] / 2.));
3072 #ifdef EDM_ML_DEBUG
3073         edm::LogVerbatim("EBGeom") << ddname(vecBackVFELyrName()[iLyr]) << " Box " << backCoolBarHeight() / 2. << ":"
3074                                    << backCoolBarWidth() / 2. << ":" << vecBackVFELyrThick()[iLyr] / 2;
3075 #endif
3076         const DDLogicalPart backVFELyrLog(
3077             ddname(vecBackVFELyrName()[iLyr]), ddmat(vecBackVFELyrMat()[iLyr]), backVFELyrSolid);
3078         const DDTranslation backVFELyrTra(0, 0, vecBackVFELyrThick()[iLyr] / 2);
3079         cpv.position(backVFELyrLog, backVFEName(), copyOne, backVFELyrTra + offTra, DDRotation());
3080 #ifdef EDM_ML_DEBUG
3081         edm::LogVerbatim("EBGeomX") << backVFELyrLog.name() << ":" << copyOne << " positioned in " << backVFEName()
3082                                     << " at " << (backVFELyrTra + offTra) << " with no rotation";
3083 #endif
3084         offTra += 2 * backVFELyrTra;
3085       }
3086 
3087       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3088       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3089       //!!!!!!!!!!!!!!     End VFE Card Setup         !!!!!!!!!!!!!!!!!!!!!!!
3090       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3091       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3092 
3093       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3094       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3095       //!!!!!!!!!!!!!!     Begin Cooling Bar + VFE Setup  !!!!!!!!!!!!!!!!!!!
3096       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3097       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3098 
3099       const double halfZCoolVFE(thickVFE + backCoolBarThick() / 2.);
3100       DDSolid backCoolVFESolid(
3101           DDSolidFactory::box(backCoolVFEName(), backCoolBarHeight() / 2., backCoolBarWidth() / 2., halfZCoolVFE));
3102 #ifdef EDM_ML_DEBUG
3103       edm::LogVerbatim("EBGeom") << backCoolVFEName() << " Box " << backCoolBarHeight() / 2. << ":"
3104                                  << backCoolBarWidth() / 2. << ":" << halfZCoolVFE;
3105 #endif
3106       const DDLogicalPart backCoolVFELog(backCoolVFEName(), backCoolVFEMat(), backCoolVFESolid);
3107       if (0 != backCoolBarHere()) {
3108         cpv.position(backCoolBarLog, backCoolVFEName(), copyOne, DDTranslation(), DDRotation());
3109 #ifdef EDM_ML_DEBUG
3110         edm::LogVerbatim("EBGeomX") << backCoolBarLog.name() << ":" << copyOne << " positioned in " << backCoolVFEName()
3111                                     << " at " << DDTranslation() << " with no rotation";
3112 #endif
3113       }
3114       if (0 != backCoolVFEHere()) {
3115         cpv.position(backVFELog,
3116                      backCoolVFEName(),
3117                      copyOne,
3118                      DDTranslation(0, 0, backCoolBarThick() / 2. + thickVFE / 2.),
3119                      DDRotation());
3120 #ifdef EDM_ML_DEBUG
3121         edm::LogVerbatim("EBGeomX") << backVFELog.name() << ":" << copyOne << " positioned in " << backCoolVFEName()
3122                                     << " at " << DDTranslation(0, 0, backCoolBarThick() / 2. + thickVFE / 2.)
3123                                     << " with no rotation";
3124 #endif
3125       }
3126       cpv.position(backVFELog,
3127                    backCoolVFEName(),
3128                    copyTwo,
3129                    DDTranslation(0, 0, -backCoolBarThick() / 2. - thickVFE / 2.),
3130                    myrot(backVFEName().name() + "Flip", CLHEP::HepRotationX(180 * deg)));
3131 #ifdef EDM_ML_DEBUG
3132       edm::LogVerbatim("EBGeomX") << backVFELog.name() << ":" << copyTwo << " positioned in " << backCoolVFEName()
3133                                   << " at " << DDTranslation(0, 0, -backCoolBarThick() / 2. - thickVFE / 2.)
3134                                   << " with rotation";
3135 #endif
3136       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3137       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3138       //!!!!!!!!!!!!!!     End Cooling Bar + VFE Setup    !!!!!!!!!!!!!!!!!!!
3139       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3140       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3141 
3142       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3143       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3144       //!!!!!!!!!!!!!! Begin Placement of Readout & Cooling by Module  !!!!!!
3145       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3146       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3147       unsigned int iCVFECopy(1);
3148       unsigned int iSep(0);
3149       unsigned int iNSec(0);
3150       const unsigned int nMisc(vecBackMiscThick().size() / 4);
3151       for (unsigned int iMod(0); iMod != 4; ++iMod) {
3152         const double pipeLength(vecGrilleZOff()[2 * iMod + 1] - vecGrilleZOff()[2 * iMod] - grilleThick() - 3 * mm);
3153 
3154         const double pipeZPos(vecGrilleZOff()[2 * iMod + 1] - pipeLength / 2 - 1.5 * mm);
3155 
3156         // accumulate total height of parent volume
3157 
3158         double backCoolHeight(backCoolBarHeight() + mBCoolTubeOutDiam());
3159         for (unsigned int iMisc(0); iMisc != nMisc; ++iMisc) {
3160           backCoolHeight += vecBackMiscThick()[iMod * nMisc + iMisc];
3161         }
3162         double bottomThick(mBCoolTubeOutDiam());
3163         for (unsigned int iMB(0); iMB != vecMBLyrThick().size(); ++iMB) {
3164           backCoolHeight += vecMBLyrThick()[iMB];
3165           bottomThick += vecMBLyrThick()[iMB];
3166         }
3167 
3168         DDName backCName(ddname(vecBackCoolName()[iMod]));
3169         const double halfZBCool((pipeLength - 2 * mBManifOutDiam() - grilleZSpace()) / 2);
3170         DDSolid backCoolSolid(DDSolidFactory::box(backCName, backCoolHeight / 2., backCoolWidth / 2., halfZBCool));
3171 #ifdef EDM_ML_DEBUG
3172         edm::LogVerbatim("EBGeom") << backCName << " Box " << backCoolHeight / 2. << ":" << backCoolWidth / 2. << ":"
3173                                    << halfZBCool;
3174 #endif
3175         const DDLogicalPart backCoolLog(backCName, spmMat(), backCoolSolid);
3176 
3177         const DDTranslation bCoolTra(
3178             -realBPthick / 2 + backCoolHeight / 2 - vecGrilleHeight()[2 * iMod],
3179             deltaY,
3180             vecGrilleZOff()[2 * iMod] + grilleThick() + grilleZSpace() + halfZBCool - backSideLength() / 2);
3181         if (0 != backCoolHere()) {
3182           cpv.position(backCoolLog, spmName(), iMod + 1, outtra + backPlateTra + bCoolTra, DDRotation());
3183 #ifdef EDM_ML_DEBUG
3184           edm::LogVerbatim("EBGeomX") << backCoolLog.name() << ":" << (iMod + 1) << " positioned in " << spmName()
3185                                       << " at " << (outtra + backPlateTra + bCoolTra) << " with no rotation";
3186 #endif
3187         }
3188         //===
3189         const double backCoolTankHeight(backCoolBarHeight());  // - backBracketHeight() ) ;
3190 
3191         const double halfZTank(halfZBCool - 5 * cm);
3192 
3193         DDName bTankName(ddname(backCoolTankName() + std::to_string(iMod + 1)));
3194         DDSolid backCoolTankSolid(
3195             DDSolidFactory::box(bTankName, backCoolTankHeight / 2., backCoolTankWidth() / 2., halfZTank));
3196 #ifdef EDM_ML_DEBUG
3197         edm::LogVerbatim("EBGeom") << bTankName << " Box " << backCoolTankHeight / 2. << ":" << backCoolTankWidth() / 2.
3198                                    << ":" << halfZTank;
3199 #endif
3200         const DDLogicalPart backCoolTankLog(bTankName, backCoolTankMat(), backCoolTankSolid);
3201         if (0 != backCoolTankHere()) {
3202           cpv.position(backCoolTankLog,
3203                        backCName,
3204                        copyOne,
3205                        DDTranslation(-backCoolHeight / 2 + backCoolTankHeight / 2. + bottomThick,
3206                                      backCoolBarWidth() / 2. + backCoolTankWidth() / 2.,
3207                                      0),
3208                        DDRotation());
3209 #ifdef EDM_ML_DEBUG
3210           edm::LogVerbatim("EBGeomX") << backCoolTankLog.name() << ":" << copyOne << " positioned in " << backCName
3211                                       << " at "
3212                                       << DDTranslation(-backCoolHeight / 2 + backCoolTankHeight / 2. + bottomThick,
3213                                                        backCoolBarWidth() / 2. + backCoolTankWidth() / 2.,
3214                                                        0)
3215                                       << " with no rotation";
3216 #endif
3217         }
3218 
3219         DDName bTankWaName(ddname(backCoolTankWaName() + std::to_string(iMod + 1)));
3220         DDSolid backCoolTankWaSolid(DDSolidFactory::box(bTankWaName,
3221                                                         backCoolTankHeight / 2. - backCoolTankThick() / 2.,
3222                                                         backCoolTankWaWidth() / 2.,
3223                                                         halfZTank - backCoolTankThick() / 2.));
3224 #ifdef EDM_ML_DEBUG
3225         edm::LogVerbatim("EBGeom") << bTankWaName << " Box " << (backCoolTankHeight / 2. - backCoolTankThick() / 2.)
3226                                    << ":" << backCoolTankWaWidth() / 2. << ":"
3227                                    << (halfZTank - backCoolTankThick() / 2.);
3228 #endif
3229         const DDLogicalPart backCoolTankWaLog(bTankWaName, backCoolTankWaMat(), backCoolTankWaSolid);
3230         cpv.position(backCoolTankWaLog, bTankName, copyOne, DDTranslation(0, 0, 0), DDRotation());
3231 #ifdef EDM_ML_DEBUG
3232         edm::LogVerbatim("EBGeomX") << backCoolTankWaLog.name() << ":" << copyOne << " positioned in " << bTankName
3233                                     << " at " << DDTranslation(0, 0, 0) << " with no rotation";
3234 #endif
3235 
3236         DDName bBracketName(ddname(backBracketName() + std::to_string(iMod + 1)));
3237         DDSolid backBracketSolid(
3238             DDSolidFactory::box(bBracketName, backBracketHeight() / 2., backCoolTankWidth() / 2., halfZTank));
3239 #ifdef EDM_ML_DEBUG
3240         edm::LogVerbatim("EBGeom") << bBracketName << " Box " << backBracketHeight() / 2. << ":"
3241                                    << backCoolTankWidth() / 2. << ":" << halfZTank;
3242 #endif
3243         const DDLogicalPart backBracketLog(bBracketName, backBracketMat(), backBracketSolid);
3244         if (0 != backCoolTankHere()) {
3245           cpv.position(backBracketLog,
3246                        backCName,
3247                        copyOne,
3248                        DDTranslation(backCoolBarHeight() - backCoolHeight / 2. - backBracketHeight() / 2. + bottomThick,
3249                                      -backCoolBarWidth() / 2. - backCoolTankWidth() / 2.,
3250                                      0),
3251                        DDRotation());
3252 #ifdef EDM_ML_DEBUG
3253           edm::LogVerbatim("EBGeomX") << backBracketLog.name() << ":" << copyOne << " positioned in " << backCName
3254                                       << " at "
3255                                       << DDTranslation(backCoolBarHeight() - backCoolHeight / 2. -
3256                                                            backBracketHeight() / 2. + bottomThick,
3257                                                        -backCoolBarWidth() / 2. - backCoolTankWidth() / 2.,
3258                                                        0)
3259                                       << " with no rotation";
3260 #endif
3261         }
3262 
3263         /*   cpv.position( backBracketLog,
3264         backCName, 
3265         copyTwo, 
3266         DDTranslation( backCoolBarHeight() - backCoolHeight/2. - backBracketHeight()/2.,
3267                    backCoolBarWidth()/2. + backCoolTankWidth()/2., 0),
3268                    DDRotation() ) ;*/
3269 
3270         //===
3271 
3272         DDTranslation bSumTra(backCoolBarHeight() - backCoolHeight / 2. + bottomThick, 0, 0);
3273         for (unsigned int j(0); j != nMisc; ++j)  // loop over miscellaneous layers
3274         {
3275           const DDName bName(ddname(vecBackMiscName()[iMod * nMisc + j]));
3276 
3277           DDSolid bSolid(DDSolidFactory::box(bName,
3278                                              vecBackMiscThick()[iMod * nMisc + j] / 2,
3279                                              backCoolBarWidth() / 2. + backCoolTankWidth(),
3280                                              halfZBCool));
3281 #ifdef EDM_ML_DEBUG
3282           edm::LogVerbatim("EBGeom") << bName << " Box " << vecBackMiscThick()[iMod * nMisc + j] / 2 << ":"
3283                                      << backCoolBarWidth() / 2. + backCoolTankWidth() << ":" << halfZBCool;
3284 #endif
3285 
3286           const DDLogicalPart bLog(bName, ddmat(vecBackMiscMat()[iMod * nMisc + j]), bSolid);
3287 
3288           const DDTranslation bTra(vecBackMiscThick()[iMod * nMisc + j] / 2, 0 * mm, 0 * mm);
3289 
3290           if (0 != backMiscHere()) {
3291             cpv.position(bLog, backCName, copyOne, bSumTra + bTra, DDRotation());
3292 #ifdef EDM_ML_DEBUG
3293             edm::LogVerbatim("EBGeomX") << bLog.name() << ":" << copyOne << " positioned in " << backCName << " at "
3294                                         << (bSumTra + bTra) << " with no rotation";
3295 #endif
3296           }
3297           bSumTra += 2 * bTra;
3298         }
3299 
3300         const double bHalfWidth(backCoolBarWidth() / 2. + backCoolTankWidth());
3301 
3302         if (0 != mBLyrHere()) {
3303           DDTranslation mTra(-backCoolHeight / 2. + mBCoolTubeOutDiam(), 0, 0);
3304           for (unsigned int j(0); j != vecMBLyrThick().size(); ++j)  // loop over MB layers
3305           {
3306             const DDName mName(ddname(vecMBLyrName()[j] + "_" + std::to_string(iMod + 1)));
3307 
3308             DDSolid mSolid(DDSolidFactory::box(mName, vecMBLyrThick()[j] / 2, bHalfWidth, halfZBCool));
3309 #ifdef EDM_ML_DEBUG
3310             edm::LogVerbatim("EBGeom") << mName << " Box " << vecMBLyrThick()[j] / 2 << ":" << bHalfWidth << ":"
3311                                        << halfZBCool;
3312 #endif
3313 
3314             const DDLogicalPart mLog(mName, ddmat(vecMBLyrMat()[j]), mSolid);
3315 
3316             mTra += DDTranslation(vecMBLyrThick()[j] / 2.0, 0 * mm, 0 * mm);
3317             cpv.position(mLog, backCName, copyOne, mTra, DDRotation());
3318 #ifdef EDM_ML_DEBUG
3319             edm::LogVerbatim("EBGeomX") << mLog.name() << ":" << copyOne << " positioned in " << backCName << " at "
3320                                         << mTra << " with no rotation";
3321 #endif
3322             mTra += DDTranslation(vecMBLyrThick()[j] / 2.0, 0 * mm, 0 * mm);
3323           }
3324         }
3325 
3326         if (0 != mBCoolTubeHere()) {
3327           const DDName mBName(ddname(mBCoolTubeName() + "_" + std::to_string(iMod + 1)));
3328 
3329           DDSolid mBCoolTubeSolid(
3330               DDSolidFactory::tubs(mBName, halfZBCool, 0, mBCoolTubeOutDiam() / 2, 0 * deg, 360 * deg));
3331 #ifdef EDM_ML_DEBUG
3332           edm::LogVerbatim("EBGeom") << mBName << " Tubs " << halfZBCool << ":0:" << mBCoolTubeOutDiam() / 2
3333                                      << ":0:360";
3334 #endif
3335           const DDLogicalPart mBLog(mBName, mBCoolTubeMat(), mBCoolTubeSolid);
3336 
3337           const DDName mBWaName(ddname(mBCoolTubeName() + "Wa_" + std::to_string(iMod + 1)));
3338           DDSolid mBCoolTubeWaSolid(
3339               DDSolidFactory::tubs(mBWaName, halfZBCool, 0, mBCoolTubeInnDiam() / 2, 0 * deg, 360 * deg));
3340 #ifdef EDM_ML_DEBUG
3341           edm::LogVerbatim("EBGeom") << mBWaName << " Tubs " << halfZBCool << ":0:" << mBCoolTubeInnDiam() / 2
3342                                      << ":0:360";
3343 #endif
3344           const DDLogicalPart mBWaLog(mBWaName, backPipeWaterMat(), mBCoolTubeWaSolid);
3345           cpv.position(mBWaLog, mBName, copyOne, DDTranslation(0, 0, 0), DDRotation());
3346 #ifdef EDM_ML_DEBUG
3347           edm::LogVerbatim("EBGeomX") << mBWaLog.name() << ":" << copyOne << " positioned in " << mBName << " at "
3348                                       << DDTranslation(0, 0, 0) << " with no rotation";
3349 #endif
3350           for (unsigned int j(0); j != mBCoolTubeNum(); ++j)  // loop over all MB cooling circuits
3351           {
3352             cpv.position(
3353                 mBLog,
3354                 backCName,
3355                 2 * j + 1,
3356                 DDTranslation(
3357                     -backCoolHeight / 2.0 + mBCoolTubeOutDiam() / 2., -bHalfWidth + (j + 1) * bHalfWidth / 5, 0),
3358                 DDRotation());
3359 #ifdef EDM_ML_DEBUG
3360             edm::LogVerbatim("EBGeomX") << mBLog.name() << ":" << (2 * j + 1) << " positioned in " << backCName
3361                                         << " at "
3362                                         << DDTranslation(-backCoolHeight / 2.0 + mBCoolTubeOutDiam() / 2.,
3363                                                          -bHalfWidth + (j + 1) * bHalfWidth / 5,
3364                                                          0)
3365                                         << " with no rotation";
3366 #endif
3367           }
3368         }
3369 
3370         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3371         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3372         //!!!!!!!!!!!!!! Begin Back Water Pipes   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3373         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3374         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3375         if (0 != backPipeHere() && 0 != iMod) {
3376           DDName bPipeName(ddname(backPipeName() + "_" + std::to_string(iMod + 1)));
3377           DDName bInnerName(ddname(backPipeName() + "_H2O_" + std::to_string(iMod + 1)));
3378 
3379           DDSolid backPipeSolid(
3380               DDSolidFactory::tubs(bPipeName, pipeLength / 2, 0 * mm, vecBackPipeDiam()[iMod] / 2, 0 * deg, 360 * deg));
3381 #ifdef EDM_ML_DEBUG
3382           edm::LogVerbatim("EBGeom") << bPipeName << " Tubs " << pipeLength / 2 << ":0:" << vecBackPipeDiam()[iMod] / 2
3383                                      << ":0:360";
3384 #endif
3385 
3386           DDSolid backInnerSolid(DDSolidFactory::tubs(bInnerName,
3387                                                       pipeLength / 2,
3388                                                       0 * mm,
3389                                                       vecBackPipeDiam()[iMod] / 2 - vecBackPipeThick()[iMod],
3390                                                       0 * deg,
3391                                                       360 * deg));
3392 #ifdef EDM_ML_DEBUG
3393           edm::LogVerbatim("EBGeom") << bInnerName << " Tubs " << pipeLength / 2
3394                                      << ":0:" << vecBackPipeDiam()[iMod] / 2 - vecBackPipeThick()[iMod] << ":0:360";
3395 #endif
3396 
3397           const DDLogicalPart backPipeLog(bPipeName, backPipeMat(), backPipeSolid);
3398 
3399           const DDLogicalPart backInnerLog(bInnerName, backPipeWaterMat(), backInnerSolid);
3400 
3401           const DDTranslation bPipeTra1(
3402               backXOff() + backSideHeight() - 0.7 * vecBackPipeDiam()[iMod],
3403               backYOff() + backPlateWidth() / 2 - backSideWidth() - 0.7 * vecBackPipeDiam()[iMod],
3404               pipeZPos);
3405 
3406           cpv.position(backPipeLog, spmName(), copyOne, bPipeTra1, DDRotation());
3407 #ifdef EDM_ML_DEBUG
3408           edm::LogVerbatim("EBGeomX") << backPipeLog.name() << ":" << copyOne << " positioned in " << spmName()
3409                                       << " at " << bPipeTra1 << " with no rotation";
3410 #endif
3411 
3412           const DDTranslation bPipeTra2(bPipeTra1.x(),
3413                                         backYOff() - backPlateWidth() / 2 + backSideWidth() + vecBackPipeDiam()[iMod],
3414                                         bPipeTra1.z());
3415 
3416           cpv.position(backPipeLog, spmName(), copyTwo, bPipeTra2, DDRotation());
3417 #ifdef EDM_ML_DEBUG
3418           edm::LogVerbatim("EBGeomX") << backPipeLog.name() << ":" << copyTwo << " positioned in " << spmName()
3419                                       << " at " << bPipeTra2 << " with no rotation";
3420 #endif
3421           cpv.position(backInnerLog, bPipeName, copyOne, DDTranslation(), DDRotation());
3422 #ifdef EDM_ML_DEBUG
3423           edm::LogVerbatim("EBGeomX") << backInnerLog.name() << ":" << copyOne << " positioned in " << bPipeName
3424                                       << " at " << DDTranslation() << " with no rotation";
3425 #endif
3426         }
3427         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3428         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3429         //!!!!!!!!!!!!!! End Back Water Pipes   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3430         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3431         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3432 
3433         //=================================================
3434 
3435         if (0 != dryAirTubeHere()) {
3436           DDName dryAirTubName(ddname(dryAirTubeName() + std::to_string(iMod + 1)));
3437 
3438           DDSolid dryAirTubeSolid(DDSolidFactory::tubs(
3439               dryAirTubName, pipeLength / 2, dryAirTubeInnDiam() / 2, dryAirTubeOutDiam() / 2, 0 * deg, 360 * deg));
3440 #ifdef EDM_ML_DEBUG
3441           edm::LogVerbatim("EBGeom") << dryAirTubName << " Tubs " << pipeLength / 2 << ":" << dryAirTubeInnDiam() / 2
3442                                      << ":" << dryAirTubeOutDiam() / 2 << ":0:360";
3443 #endif
3444 
3445           const DDLogicalPart dryAirTubeLog(dryAirTubName, dryAirTubeMat(), dryAirTubeSolid);
3446 
3447           const DDTranslation dryAirTubeTra1(
3448               backXOff() + backSideHeight() - 0.7 * dryAirTubeOutDiam() - vecBackPipeDiam()[iMod],
3449               backYOff() + backPlateWidth() / 2 - backSideWidth() - 1.2 * dryAirTubeOutDiam(),
3450               pipeZPos);
3451 
3452           cpv.position(dryAirTubeLog, spmName(), copyOne, dryAirTubeTra1, DDRotation());
3453 #ifdef EDM_ML_DEBUG
3454           edm::LogVerbatim("EBGeomX") << dryAirTubeLog.name() << ":" << copyOne << " positioned in " << spmName()
3455                                       << " at " << dryAirTubeTra1 << " with no rotation";
3456 #endif
3457 
3458           const DDTranslation dryAirTubeTra2(
3459               dryAirTubeTra1.x(),
3460               backYOff() - backPlateWidth() / 2 + backSideWidth() + 0.7 * dryAirTubeOutDiam(),
3461               dryAirTubeTra1.z());
3462 
3463           cpv.position(dryAirTubeLog, spmName(), copyTwo, dryAirTubeTra2, DDRotation());
3464 #ifdef EDM_ML_DEBUG
3465           edm::LogVerbatim("EBGeomX") << dryAirTubeLog.name() << ":" << copyTwo << " positioned in " << spmName()
3466                                       << " at " << dryAirTubeTra2 << " with no rotation";
3467 #endif
3468         }
3469         //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3470 
3471         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3472         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3473         //!!!!!!!!!!!!!! Begin Placement of Cooling + VFE Cards          !!!!!!
3474         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3475         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3476 
3477         DDTranslation cTra(backCoolBarHeight() / 2. - backCoolHeight / 2. + bottomThick, 0, -halfZTank + halfZCoolVFE);
3478         const unsigned int numSec(static_cast<unsigned int>(vecBackCoolNSec()[iMod]));
3479         for (unsigned int jSec(0); jSec != numSec; ++jSec) {
3480           const unsigned int nMax(static_cast<unsigned int>(vecBackCoolNPerSec()[iNSec++]));
3481           for (unsigned int iBar(0); iBar != nMax; ++iBar) {
3482             cpv.position(backCoolVFELog, backCName, iCVFECopy++, cTra, DDRotation());
3483 #ifdef EDM_ML_DEBUG
3484             edm::LogVerbatim("EBGeomX") << backCoolVFELog.name() << ":" << iCVFECopy << " positioned in " << backCName
3485                                         << " at " << cTra << " with no rotation";
3486 #endif
3487             cTra += DDTranslation(0, 0, backCBStdSep());
3488           }
3489           cTra -= DDTranslation(0, 0, backCBStdSep());  // backspace to previous
3490           if (jSec != numSec - 1)
3491             cTra += DDTranslation(0, 0, vecBackCoolSecSep()[iSep++]);  // now take atypical step
3492         }
3493         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3494         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3495         //!!!!!!!!!!!!!! End Placement of Cooling + VFE Cards            !!!!!!
3496         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3497         //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3498       }
3499 
3500       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3501       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3502       //!!!!!!!!!!!!!! End Placement of Readout & Cooling by Module    !!!!!!
3503       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3504       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3505 
3506       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3507       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3508       //!!!!!!!!!!!!!! Begin Patch Panel   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3509       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3510       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3511 
3512       double patchHeight(0);
3513       for (unsigned int iPatch(0); iPatch != vecPatchPanelThick().size(); ++iPatch) {
3514         patchHeight += vecPatchPanelThick()[iPatch];
3515       }
3516 
3517       DDSolid patchSolid(DDSolidFactory::box(patchPanelName(),
3518                                              patchHeight / 2.,
3519                                              backCoolBarWidth() / 2.,
3520                                              (vecSpmZPts().back() - vecGrilleZOff().back() - grilleThick()) / 2));
3521 #ifdef EDM_ML_DEBUG
3522       edm::LogVerbatim("EBGeom") << patchPanelName() << " Box " << patchHeight / 2. << ":" << backCoolBarWidth() / 2.
3523                                  << ":" << (vecSpmZPts().back() - vecGrilleZOff().back() - grilleThick()) / 2;
3524 #endif
3525 
3526       const std::vector<double>& patchParms(patchSolid.parameters());
3527 
3528       const DDLogicalPart patchLog(patchPanelName(), spmMat(), patchSolid);
3529 
3530       const DDTranslation patchTra(backXOff() + 4 * mm, 0 * mm, vecGrilleZOff().back() + grilleThick() + patchParms[2]);
3531       if (0 != patchPanelHere()) {
3532         cpv.position(patchLog, spmName(), copyOne, patchTra, DDRotation());
3533 #ifdef EDM_ML_DEBUG
3534         edm::LogVerbatim("EBGeomX") << patchLog.name() << ":" << copyOne << " positioned in " << spmName() << " at "
3535                                     << patchTra << " with no rotation";
3536 #endif
3537       }
3538       DDTranslation pTra(-patchParms[0], 0, 0);
3539 
3540       for (unsigned int j(0); j != vecPatchPanelNames().size(); ++j) {
3541         const DDName pName(ddname(vecPatchPanelNames()[j]));
3542 
3543         DDSolid pSolid(DDSolidFactory::box(pName, vecPatchPanelThick()[j] / 2., patchParms[1], patchParms[2]));
3544 #ifdef EDM_ML_DEBUG
3545         edm::LogVerbatim("EBGeom") << pName << " Box " << vecPatchPanelThick()[j] / 2. << ":" << patchParms[1] << ":"
3546                                    << patchParms[2];
3547 #endif
3548         const DDLogicalPart pLog(pName, ddmat(vecPatchPanelMat()[j]), pSolid);
3549 
3550         pTra += DDTranslation(vecPatchPanelThick()[j] / 2, 0 * mm, 0 * mm);
3551 
3552         cpv.position(pLog, patchPanelName(), copyOne, pTra, DDRotation());
3553 #ifdef EDM_ML_DEBUG
3554         edm::LogVerbatim("EBGeomX") << pLog.name() << ":" << copyOne << " positioned in " << patchPanelName() << " at "
3555                                     << pTra << " with no rotation";
3556 #endif
3557         pTra += DDTranslation(vecPatchPanelThick()[j] / 2, 0 * mm, 0 * mm);
3558       }
3559       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3560       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3561       //!!!!!!!!!!!!!! End Patch Panel     !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3562       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3563       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3564 
3565       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3566       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3567       //!!!!!!!!!!!!!! Begin Pincers       !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3568       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3569       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3570 
3571       if (0 != pincerRodHere()) {
3572         // Make hierarchy of rods, envelopes, blocks, shims, and cutouts
3573 
3574         DDSolid rodSolid(
3575             DDSolidFactory::box(pincerRodName(), pincerEnvWidth() / 2., pincerEnvHeight() / 2., ilyLength / 2));
3576 #ifdef EDM_ML_DEBUG
3577         edm::LogVerbatim("EBGeom") << pincerRodName() << " Box " << pincerEnvWidth() / 2. << ":"
3578                                    << pincerEnvHeight() / 2. << ":" << ilyLength / 2;
3579 #endif
3580         const DDLogicalPart rodLog(pincerRodName(), pincerRodMat(), rodSolid);
3581 
3582         DDSolid envSolid(
3583             DDSolidFactory::box(pincerEnvName(), pincerEnvWidth() / 2., pincerEnvHeight() / 2., pincerEnvLength() / 2));
3584 #ifdef EDM_ML_DEBUG
3585         edm::LogVerbatim("EBGeom") << pincerEnvName() << " Box " << pincerEnvWidth() / 2. << ":"
3586                                    << pincerEnvHeight() / 2. << ":" << pincerEnvLength() / 2;
3587 #endif
3588         const DDLogicalPart envLog(pincerEnvName(), pincerEnvMat(), envSolid);
3589         const std::vector<double>& envParms(envSolid.parameters());
3590 
3591         DDSolid blkSolid(
3592             DDSolidFactory::box(pincerBlkName(), pincerEnvWidth() / 2., pincerEnvHeight() / 2., pincerBlkLength() / 2));
3593 #ifdef EDM_ML_DEBUG
3594         edm::LogVerbatim("EBGeom") << pincerBlkName() << " Box " << pincerEnvWidth() / 2. << ":"
3595                                    << pincerEnvHeight() / 2. << ":" << pincerBlkLength() / 2;
3596 #endif
3597         const DDLogicalPart blkLog(pincerBlkName(), pincerBlkMat(), blkSolid);
3598         const std::vector<double>& blkParms(blkSolid.parameters());
3599         cpv.position(blkLog,
3600                      pincerEnvName(),
3601                      copyOne,
3602                      DDTranslation(0, 0, pincerEnvLength() / 2 - pincerBlkLength() / 2),
3603                      DDRotation());
3604 #ifdef EDM_ML_DEBUG
3605         edm::LogVerbatim("EBGeomX") << blkLog.name() << ":" << copyOne << " positioned in " << pincerEnvName() << " at "
3606                                     << DDTranslation(0, 0, pincerEnvLength() / 2 - pincerBlkLength() / 2)
3607                                     << " with no rotation";
3608 #endif
3609 
3610         DDSolid cutSolid(
3611             DDSolidFactory::box(pincerCutName(), pincerCutWidth() / 2., pincerCutHeight() / 2., pincerBlkLength() / 2));
3612 #ifdef EDM_ML_DEBUG
3613         edm::LogVerbatim("EBGeom") << pincerCutName() << " Box " << pincerCutWidth() / 2. << ":"
3614                                    << pincerCutHeight() / 2 << ":" << pincerBlkLength() / 2;
3615 #endif
3616         const DDLogicalPart cutLog(pincerCutName(), pincerCutMat(), cutSolid);
3617         const std::vector<double>& cutParms(cutSolid.parameters());
3618         cpv.position(
3619             cutLog,
3620             pincerBlkName(),
3621             copyOne,
3622             DDTranslation(
3623                 +blkParms[0] - cutParms[0] - pincerShim1Width() + pincerShim2Width(), -blkParms[1] + cutParms[1], 0),
3624             DDRotation());
3625 #ifdef EDM_ML_DEBUG
3626         edm::LogVerbatim("EBGeomX") << cutLog.name() << ":" << copyOne << " positioned in " << pincerBlkName() << " at "
3627                                     << DDTranslation(
3628                                            blkParms[0] - cutParms[0] - pincerShim1Width() + pincerShim2Width(),
3629                                            -blkParms[1] + cutParms[1],
3630                                            0)
3631                                     << " with no rotation";
3632 #endif
3633 
3634         DDSolid shim2Solid(DDSolidFactory::box(
3635             pincerShim2Name(), pincerShim2Width() / 2., pincerShimHeight() / 2., pincerBlkLength() / 2));
3636 #ifdef EDM_ML_DEBUG
3637         edm::LogVerbatim("EBGeom") << pincerShim2Name() << " Box " << pincerShim2Width() / 2. << ":"
3638                                    << pincerShimHeight() / 2. << ":" << pincerBlkLength() / 2;
3639 #endif
3640         const DDLogicalPart shim2Log(pincerShim2Name(), pincerShimMat(), shim2Solid);
3641         const std::vector<double>& shim2Parms(shim2Solid.parameters());
3642         cpv.position(shim2Log,
3643                      pincerCutName(),
3644                      copyOne,
3645                      DDTranslation(+cutParms[0] - shim2Parms[0], -cutParms[1] + shim2Parms[1], 0),
3646                      DDRotation());
3647 #ifdef EDM_ML_DEBUG
3648         edm::LogVerbatim("EBGeomX") << shim2Log.name() << ":" << copyOne << " positioned in " << pincerCutName()
3649                                     << " at "
3650                                     << DDTranslation(+cutParms[0] - shim2Parms[0], -cutParms[1] + shim2Parms[1], 0)
3651                                     << " with no rotation";
3652 #endif
3653 
3654         DDSolid shim1Solid(DDSolidFactory::box(pincerShim1Name(),
3655                                                pincerShim1Width() / 2.,
3656                                                pincerShimHeight() / 2.,
3657                                                (pincerEnvLength() - pincerBlkLength()) / 2));
3658 #ifdef EDM_ML_DEBUG
3659         edm::LogVerbatim("EBGeom") << pincerShim1Name() << " Box " << pincerShim1Width() / 2. << ":"
3660                                    << pincerShimHeight() / 2. << ":" << (pincerEnvLength() - pincerBlkLength()) / 2;
3661 #endif
3662 
3663         const DDLogicalPart shim1Log(pincerShim1Name(), pincerShimMat(), shim1Solid);
3664         const std::vector<double>& shim1Parms(shim1Solid.parameters());
3665         cpv.position(
3666             shim1Log,
3667             pincerEnvName(),
3668             copyOne,
3669             DDTranslation(+envParms[0] - shim1Parms[0], -envParms[1] + shim1Parms[1], -envParms[2] + shim1Parms[2]),
3670             DDRotation());
3671 #ifdef EDM_ML_DEBUG
3672         edm::LogVerbatim("EBGeomX") << shim1Log.name() << ":" << copyOne << " positioned in " << pincerEnvName()
3673                                     << " at "
3674                                     << DDTranslation(+envParms[0] - shim1Parms[0],
3675                                                      -envParms[1] + shim1Parms[1],
3676                                                      -envParms[2] + shim1Parms[2])
3677                                     << " with no rotation";
3678 #endif
3679         for (unsigned int iEnv(0); iEnv != vecPincerEnvZOff().size(); ++iEnv) {
3680           cpv.position(envLog,
3681                        pincerRodName(),
3682                        1 + iEnv,
3683                        DDTranslation(0, 0, -ilyLength / 2. + vecPincerEnvZOff()[iEnv] - pincerEnvLength() / 2.),
3684                        DDRotation());
3685 #ifdef EDM_ML_DEBUG
3686           edm::LogVerbatim("EBGeomX") << envLog.name() << ":" << (1 + iEnv) << " positioned in " << pincerRodName()
3687                                       << " at "
3688                                       << DDTranslation(
3689                                              0, 0, -ilyLength / 2. + vecPincerEnvZOff()[iEnv] - pincerEnvLength() / 2.)
3690                                       << " with no rotation";
3691 #endif
3692         }
3693 
3694         // Place the rods
3695         //   const double radius ( fawRadOff() - pincerEnvHeight()/2 -1*mm ) ;
3696         const double radius(ilyRMin - pincerEnvHeight() / 2 - 1 * mm);
3697 
3698         const DDName xilyName(ddname(ilyName() + std::to_string(vecIlyMat().size() - 1)));
3699 
3700         for (unsigned int iRod(0); iRod != vecPincerRodAzimuth().size(); ++iRod) {
3701           const DDTranslation rodTra(
3702               radius * cos(vecPincerRodAzimuth()[iRod]), radius * sin(vecPincerRodAzimuth()[iRod]), 0);
3703 
3704           cpv.position(rodLog,
3705                        xilyName,
3706                        1 + iRod,
3707                        rodTra,
3708                        myrot(pincerRodName().name() + std::to_string(iRod),
3709                              CLHEP::HepRotationZ(90 * deg + vecPincerRodAzimuth()[iRod])));
3710 #ifdef EDM_ML_DEBUG
3711           edm::LogVerbatim("EBGeomX") << rodLog.name() << ":" << (1 + iRod) << " positioned in " << xilyName << " at "
3712                                       << rodTra << " with rotation";
3713 #endif
3714         }
3715       }
3716       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3717       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3718       //!!!!!!!!!!!!!! End   Pincers       !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3719       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3720       //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3721     }
3722   }
3723 
3724 #ifdef EDM_ML_DEBUG
3725   edm::LogVerbatim("EcalGeom") << "******** DDEcalBarrelAlgo test: end it...";
3726 #endif
3727 }
3728 
3729 ///Create a DDRotation from a string converted to DDName and CLHEP::HepRotation converted to DDRotationMatrix. -- Michael Case
3730 DDRotation DDEcalBarrelNewAlgo::myrot(const std::string& s, const CLHEP::HepRotation& r) const {
3731   return DDrot(
3732       ddname(m_idNameSpace + ":" + s),
3733       std::make_unique<DDRotationMatrix>(r.xx(), r.xy(), r.xz(), r.yx(), r.yy(), r.yz(), r.zx(), r.zy(), r.zz()));
3734 }
3735 
3736 DDMaterial DDEcalBarrelNewAlgo::ddmat(const std::string& s) const { return DDMaterial(ddname(s)); }
3737 
3738 DDName DDEcalBarrelNewAlgo::ddname(const std::string& s) const {
3739   const pair<std::string, std::string> temp(DDSplit(s));
3740   if (temp.second.empty()) {
3741     return DDName(temp.first, m_idNameSpace);
3742   } else {
3743     return DDName(temp.first, temp.second);
3744   }
3745 }
3746 
3747 DDSolid DDEcalBarrelNewAlgo::mytrap(const std::string& s, const EcalTrapezoidParameters& t) const {
3748 #ifdef EDM_ML_DEBUG
3749   edm::LogVerbatim("EBGeom") << DDName(s) << " Trap " << t.theta() / CLHEP::deg << ":" << t.phi() / CLHEP::deg << ":"
3750                              << t.h1() << ":" << t.bl1() << ":" << t.tl1() << ":" << t.alp1() / CLHEP::deg << ":"
3751                              << t.h2() << ":" << t.bl2() << ":" << t.tl2() << ":" << t.alp2() / CLHEP::deg;
3752 #endif
3753   return DDSolidFactory::trap(
3754       ddname(s), t.dz(), t.theta(), t.phi(), t.h1(), t.bl1(), t.tl1(), t.alp1(), t.h2(), t.bl2(), t.tl2(), t.alp2());
3755 }
3756 
3757 void DDEcalBarrelNewAlgo::web(unsigned int iWeb,
3758                               double bWeb,
3759                               double BWeb,
3760                               double LWeb,
3761                               double theta,
3762                               const HepGeom::Point3D<double>& corner,
3763                               const DDLogicalPart& logPar,
3764                               double& zee,
3765                               double side,
3766                               double front,
3767                               double delta,
3768                               DDCompactView& cpv) {
3769   const unsigned int copyOne(1);
3770 
3771   const double LWebx(vecWebLength()[iWeb]);
3772 
3773   const double BWebx(bWeb + (BWeb - bWeb) * LWebx / LWeb);
3774 
3775   const double thick(vecWebPlTh()[iWeb] + vecWebClrTh()[iWeb]);
3776   const Trap trapWebClr(BWebx / 2,     // A/2
3777                         bWeb / 2,      // a/2
3778                         bWeb / 2,      // b/2
3779                         thick / 2,     // H/2
3780                         thick / 2,     // h/2
3781                         LWebx / 2,     // L/2
3782                         90 * deg,      // alfa1
3783                         bWeb - BWebx,  // x15
3784                         0              // y15
3785   );
3786   const DDName webClrDDName(webClrName() + std::to_string(iWeb));
3787   const DDSolid webClrSolid(mytrap(webClrDDName.name(), trapWebClr));
3788   const DDLogicalPart webClrLog(webClrDDName, webClrMat(), webClrSolid);
3789 
3790   const Trap trapWebPl(trapWebClr.A() / 2,               // A/2
3791                        trapWebClr.a() / 2,               // a/2
3792                        trapWebClr.b() / 2,               // b/2
3793                        vecWebPlTh()[iWeb] / 2,           // H/2
3794                        vecWebPlTh()[iWeb] / 2,           // h/2
3795                        trapWebClr.L() / 2.,              // L/2
3796                        90 * deg,                         // alfa1
3797                        trapWebClr.b() - trapWebClr.B(),  // x15
3798                        0                                 // y15
3799   );
3800   const DDName webPlDDName(webPlName() + std::to_string(iWeb));
3801   const DDSolid webPlSolid(mytrap(webPlDDName.fullname(), trapWebPl));
3802   const DDLogicalPart webPlLog(webPlDDName, webPlMat(), webPlSolid);
3803 
3804   cpv.position(webPlLog,  // place plate inside clearance volume
3805                webClrDDName,
3806                copyOne,
3807                DDTranslation(0, 0, 0),
3808                DDRotation());
3809 #ifdef EDM_ML_DEBUG
3810   edm::LogVerbatim("EBGeomX") << webPlLog.name() << ":" << copyOne << " positioned in " << webClrDDName << " at "
3811                               << DDTranslation(0, 0, 0) << " with no rotation";
3812 #endif
3813   const Trap::VertexList vWeb(trapWebClr.vertexList());
3814 
3815   zee += trapWebClr.h() / sin(theta);
3816 
3817   const double beta(theta + delta);
3818 
3819   const double zWeb(zee - front * cos(beta) + side * sin(beta));
3820   const double yWeb(front * sin(beta) + side * cos(beta));
3821 
3822   const Pt3D wedge3(corner + Pt3D(0, -yWeb, zWeb));
3823   const Pt3D wedge2(wedge3 + Pt3D(0, trapWebClr.h() * cos(theta), -trapWebClr.h() * sin(theta)));
3824   const Pt3D wedge1(wedge3 + Pt3D(trapWebClr.a(), 0, 0));
3825 
3826 #ifdef EDM_ML_DEBUG
3827   edm::LogVerbatim("EcalGeom") << "trap1=" << vWeb[0] << ", trap2=" << vWeb[2] << ", trap3=" << vWeb[3];
3828 
3829   edm::LogVerbatim("EcalGeom") << "wedge1=" << wedge1 << ", wedge2=" << wedge2 << ", wedge3=" << wedge3;
3830 #endif
3831   const Tf3D tForm(vWeb[0], vWeb[2], vWeb[3], wedge1, wedge2, wedge3);
3832 
3833   if (0 != webHere()) {
3834     cpv.position(webClrLog,
3835                  logPar,
3836                  copyOne,
3837                  DDTranslation(tForm.getTranslation().x(), tForm.getTranslation().y(), tForm.getTranslation().z()),
3838                  myrot(webClrLog.name().name() + std::to_string(iWeb), tForm.getRotation()));
3839 #ifdef EDM_ML_DEBUG
3840     edm::LogVerbatim("EBGeomX") << webClrLog.name() << ":" << copyOne << " positioned in " << logPar.name() << " at "
3841                                 << DDTranslation(tForm.getTranslation().x(),
3842                                                  tForm.getTranslation().y(),
3843                                                  tForm.getTranslation().z())
3844                                 << " with rotation";
3845 #endif
3846   }
3847 }
3848 
3849 #include "DetectorDescription/Core/interface/DDAlgorithmFactory.h"
3850 
3851 DEFINE_EDM_PLUGIN(DDAlgorithmFactory, DDEcalBarrelNewAlgo, "ecal:DDEcalBarrelNewAlgo");