d1/d11/DDPixBarLayerAlgo_8cc_source.html

 // File: DDPixBarLayerAlgo.cc
 // Description: Make one layer of pixel barrel detector

 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include "DetectorDescription/Core/interface/DDLogicalPart.h"
 #include "DetectorDescription/Core/interface/DDSolid.h"
 #include "DetectorDescription/Core/interface/DDMaterial.h"
 #include "DetectorDescription/Core/interface/DDCurrentNamespace.h"
 #include "DetectorDescription/Core/interface/DDSplit.h"
 #include "DetectorDescription/Core/interface/DDTypes.h"
 #include "DetectorDescription/Core/interface/DDAlgorithm.h"
 #include "DetectorDescription/Core/interface/DDAlgorithmFactory.h"
 #include "CLHEP/Units/GlobalPhysicalConstants.h"
 #include "CLHEP/Units/GlobalSystemOfUnits.h"

 #include <cmath>
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>

 using namespace std;

 class DDPixBarLayerAlgo : public DDAlgorithm {
 public:
   //Constructor and Destructor
   DDPixBarLayerAlgo();
   ~DDPixBarLayerAlgo() override;

   void initialize(const DDNumericArguments& nArgs,
                   const DDVectorArguments& vArgs,
                   const DDMapArguments& mArgs,
                   const DDStringArguments& sArgs,
                   const DDStringVectorArguments& vsArgs) override;

   void execute(DDCompactView& cpv) override;

 private:
   string idNameSpace;          //Namespace of this and ALL sub-parts
   string genMat;               //Name of general material
   int number;                  //Number of ladders in phi
   double layerDz;              //Length of the layer
   double sensorEdge;           //Distance from edge for a half sensor
   double coolDz;               //Length of the cooling piece
   double coolWidth;            //Width
   double coolSide;             //Side length
   double coolThick;            //Thickness of the shell
   double coolDist;             //Radial distance between centres of 2
   string coolMat;              //Cooling fluid material name
   string tubeMat;              //Cooling piece material name
   vector<string> ladder;       //Names     of ladders
   vector<double> ladderWidth;  //Widths         ...
   vector<double> ladderThick;  //Thickness      ...
 };

 DDPixBarLayerAlgo::DDPixBarLayerAlgo() { LogDebug("PixelGeom") << "DDPixBarLayerAlgo info: Creating an instance"; }

 DDPixBarLayerAlgo::~DDPixBarLayerAlgo() {}

 void DDPixBarLayerAlgo::initialize(const DDNumericArguments& nArgs,
                                    const DDVectorArguments& vArgs,
                                    const DDMapArguments&,
                                    const DDStringArguments& sArgs,
                                    const DDStringVectorArguments& vsArgs) {
   idNameSpace = DDCurrentNamespace::ns();
   DDName parentName = parent().name();

   genMat = sArgs["GeneralMaterial"];
   number = int(nArgs["Ladders"]);
   layerDz = nArgs["LayerDz"];
   sensorEdge = nArgs["SensorEdge"];
   coolDz = nArgs["CoolDz"];
   coolWidth = nArgs["CoolWidth"];
   coolSide = nArgs["CoolSide"];
   coolThick = nArgs["CoolThick"];
   coolDist = nArgs["CoolDist"];
   coolMat = sArgs["CoolMaterial"];
   tubeMat = sArgs["CoolTubeMaterial"];

   LogDebug("PixelGeom") << "DDPixBarLayerAlgo debug: Parent " << parentName << " NameSpace " << idNameSpace << "\n"
                         << "\tLadders " << number << "\tGeneral Material " << genMat << "\tLength " << layerDz
                         << "\tSensorEdge " << sensorEdge << "\tSpecification of Cooling Pieces:\n"
                         << "\tLength " << coolDz << " Width " << coolWidth << " Side " << coolSide
                         << " Thickness of Shell " << coolThick << " Radial distance " << coolDist << " Materials "
                         << coolMat << ", " << tubeMat;

   ladder = vsArgs["LadderName"];
   ladderWidth = vArgs["LadderWidth"];
   ladderThick = vArgs["LadderThick"];

   LogDebug("PixelGeom") << "DDPixBarLayerAlgo debug: Full Ladder " << ladder[0] << " width/thickness " << ladderWidth[0]
                         << ", " << ladderThick[0] << "\tHalf Ladder " << ladder[1] << " width/thickness "
                         << ladderWidth[1] << ", " << ladderThick[1];
 }

 void DDPixBarLayerAlgo::execute(DDCompactView& cpv) {
   DDName mother = parent().name();
   const string& idName = mother.name();

   double dphi = CLHEP::twopi / number;
   double d2 = 0.5 * coolWidth;
   double d1 = d2 - coolSide * sin(0.5 * dphi);
   double x1 = (d1 + d2) / (2. * sin(0.5 * dphi));
   double x2 = coolDist * sin(0.5 * dphi);
   double rmin = (coolDist - 0.5 * (d1 + d2)) * cos(0.5 * dphi) - 0.5 * ladderThick[0];
   double rmax = (coolDist + 0.5 * (d1 + d2)) * cos(0.5 * dphi) + 0.5 * ladderThick[0];
   double rmxh = rmax - 0.5 * ladderThick[0] + ladderThick[1];
   LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: Rmin/Rmax " << rmin << ", " << rmax << " d1/d2 " << d1 << ", " << d2
                         << " x1/x2 " << x1 << ", " << x2;

   double rtmi = rmin + 0.5 * ladderThick[0] - ladderThick[1];
   double rtmx = sqrt(rmxh * rmxh + ladderWidth[1] * ladderWidth[1]);
   DDSolid solid = DDSolidFactory::tubs(DDName(idName, idNameSpace), 0.5 * layerDz, rtmi, rtmx, 0, CLHEP::twopi);
   LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: " << DDName(idName, idNameSpace) << " Tubs made of " << genMat
                         << " from 0 to " << CLHEP::twopi / CLHEP::deg << " with Rin " << rtmi << " Rout " << rtmx
                         << " ZHalf " << 0.5 * layerDz;
   DDName matname(DDSplit(genMat).first, DDSplit(genMat).second);
   DDMaterial matter(matname);
   DDLogicalPart layer(solid.ddname(), matter, solid);

   double rr = 0.5 * (rmax + rmin);
   double dr = 0.5 * (rmax - rmin);
   double h1 = 0.5 * coolSide * cos(0.5 * dphi);
   string name = idName + "CoolTube";
   solid = DDSolidFactory::trap(DDName(name, idNameSpace), 0.5 * coolDz, 0, 0, h1, d2, d1, 0, h1, d2, d1, 0);
   LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: " << solid.name() << " Trap made of " << tubeMat
                         << " of dimensions " << 0.5 * coolDz << ", 0, 0, " << h1 << ", " << d2 << ", " << d1 << ", 0, "
                         << h1 << ", " << d2 << ", " << d1 << ", 0";
   matter = DDMaterial(DDName(DDSplit(tubeMat).first, DDSplit(tubeMat).second));
   DDLogicalPart coolTube(solid.ddname(), matter, solid);

   name = idName + "Coolant";
   h1 -= coolThick;
   d1 -= coolThick;
   d2 -= coolThick;
   solid = DDSolidFactory::trap(DDName(name, idNameSpace), 0.5 * coolDz, 0, 0, h1, d2, d1, 0, h1, d2, d1, 0);
   LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: " << solid.name() << " Trap made of " << coolMat
                         << " of dimensions " << 0.5 * coolDz << ", 0, 0, " << h1 << ", " << d2 << ", " << d1 << ", 0, "
                         << h1 << ", " << d2 << ", " << d1 << ", 0";
   matter = DDMaterial(DDName(DDSplit(coolMat).first, DDSplit(coolMat).second));
   DDLogicalPart cool(solid.ddname(), matter, solid);
   cpv.position(cool, coolTube, 1, DDTranslation(0.0, 0.0, 0.0), DDRotation());
   LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: " << cool.name() << " number 1 positioned in " << coolTube.name()
                         << " at (0,0,0) with no rotation";

   DDName ladderFull(DDSplit(ladder[0]).first, DDSplit(ladder[0]).second);
   DDName ladderHalf(DDSplit(ladder[1]).first, DDSplit(ladder[1]).second);

   int nphi = number / 2, copy = 1, iup = -1;
   double phi0 = 90 * CLHEP::deg;
   for (int i = 0; i < number; i++) {
     double phi = phi0 + i * dphi;
     double phix, phiy, rrr, xx;
     string rots;
     DDTranslation tran;
     DDRotation rot;
     if (i == 0 || i == nphi) {
       rrr = rr + dr + 0.5 * (ladderThick[1] - ladderThick[0]);
       xx = (0.5 * ladderWidth[1] - sensorEdge) * sin(phi);
       tran = DDTranslation(xx, rrr * sin(phi), 0);
       rots = idName + to_string(copy);
       phix = phi - 90 * CLHEP::deg;
       phiy = 90 * CLHEP::deg + phix;
       LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: Creating a new "
                             << "rotation: " << rots << "\t90., " << phix / CLHEP::deg << ", 90.," << phiy / CLHEP::deg
                             << ", 0, 0";
       rot = DDrot(DDName(rots, idNameSpace), 90 * CLHEP::deg, phix, 90 * CLHEP::deg, phiy, 0., 0.);
       cpv.position(ladderHalf, layer, copy, tran, rot);
       LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: " << ladderHalf << " number " << copy << " positioned in "
                             << layer.name() << " at " << tran << " with " << rot;
       copy++;
       iup = -1;
       rrr = rr - dr - 0.5 * (ladderThick[1] - ladderThick[0]);
       tran = DDTranslation(-xx, rrr * sin(phi), 0);
       rots = idName + to_string(copy);
       phix = phi + 90 * CLHEP::deg;
       phiy = 90 * CLHEP::deg + phix;
       LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: Creating a new "
                             << "rotation: " << rots << "\t90., " << phix / CLHEP::deg << ", 90.," << phiy / CLHEP::deg
                             << ", 0, 0";
       rot = DDrot(DDName(rots, idNameSpace), 90 * CLHEP::deg, phix, 90 * CLHEP::deg, phiy, 0., 0.);
       cpv.position(ladderHalf, layer, copy, tran, rot);
       LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: " << ladderHalf << " number " << copy << " positioned in "
                             << layer.name() << " at " << tran << " with " << rot;
       copy++;
     } else {
       iup = -iup;
       rrr = rr + iup * dr;
       tran = DDTranslation(rrr * cos(phi), rrr * sin(phi), 0);
       rots = idName + to_string(copy);
       if (iup > 0)
         phix = phi - 90 * CLHEP::deg;
       else
         phix = phi + 90 * CLHEP::deg;
       phiy = phix + 90. * CLHEP::deg;
       LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: Creating a new "
                             << "rotation: " << rots << "\t90., " << phix / CLHEP::deg << ", 90.," << phiy / CLHEP::deg
                             << ", 0, 0";
       rot = DDrot(DDName(rots, idNameSpace), 90 * CLHEP::deg, phix, 90 * CLHEP::deg, phiy, 0., 0.);
       cpv.position(ladderFull, layer, copy, tran, rot);
       LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: " << ladderFull << " number " << copy << " positioned in "
                             << layer.name() << " at " << tran << " with " << rot;
       copy++;
     }
     rrr = coolDist * cos(0.5 * dphi);
     tran = DDTranslation(rrr * cos(phi) - x2 * sin(phi), rrr * sin(phi) + x2 * cos(phi), 0);
     rots = idName + to_string(i + 100);
     phix = phi + 0.5 * dphi;
     if (iup > 0)
       phix += 180 * CLHEP::deg;
     phiy = phix + 90. * CLHEP::deg;
     LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: Creating a new "
                           << "rotation: " << rots << "\t90., " << phix / CLHEP::deg << ", 90.," << phiy / CLHEP::deg
                           << ", 0, 0";
     rot = DDrot(DDName(rots, idNameSpace), 90 * CLHEP::deg, phix, 90 * CLHEP::deg, phiy, 0., 0.);
     cpv.position(coolTube, layer, i + 1, tran, rot);
     LogDebug("PixelGeom") << "DDPixBarLayerAlgo test: " << coolTube.name() << " number " << i + 1 << " positioned in "
                           << layer.name() << " at " << tran << " with " << rot;
   }
 }

 DEFINE_EDM_PLUGIN(DDAlgorithmFactory, DDPixBarLayerAlgo, "track:DDPixBarLayerAlgo");
nphi
const int nphi
Definition: CMTRawAnalyzer.cc:418

initialize
static AlgebraicMatrix initialize()
Definition: BeamSpotTransientTrackingRecHit.cc:24

DDMaterial.h

DDPixBarLayerAlgo::sensorEdge
double sensorEdge
Definition: DDPixBarLayerAlgo.cc:45

mps_fire.i
i
Definition: mps_fire.py:429

DDPixBarLayerAlgo::layerDz
double layerDz
Definition: DDPixBarLayerAlgo.cc:44

DDCompactView::position
void position(const DDLogicalPart &self, const DDLogicalPart &parent, const std::string &copyno, const DDTranslation &trans, const DDRotation &rot, const DDDivision *div=nullptr)
Definition: DDCompactView.cc:76

MessageLogger.h

DDPixBarLayerAlgo::genMat
string genMat
Definition: DDPixBarLayerAlgo.cc:42

findQualityFiles.rr
string rr
Definition: findQualityFiles.py:185

DDMaterial
DDMaterial is used to define and access material information.
Definition: DDMaterial.h:45

DDPixBarLayerAlgo::number
int number
Definition: DDPixBarLayerAlgo.cc:43

DDAlgorithmFactory.h

funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22

DDName
DDName is used to identify DDD entities uniquely.
Definition: DDName.h:17

cond::impl::to_string
std::string to_string(const V &value)
Definition: OMSAccess.h:71

DDPixBarLayerAlgo::coolDz
double coolDz
Definition: DDPixBarLayerAlgo.cc:46

std
Definition: JetResolutionObject.h:76

DDCurrentNamespace::ns
static std::string & ns()
Definition: DDCurrentNamespace.cc:3

DDCompactView
Compact representation of the geometrical detector hierarchy.
Definition: DDCompactView.h:81

DDPixBarLayerAlgo::execute
void execute(DDCompactView &cpv) override
Definition: DDPixBarLayerAlgo.cc:98

DDPixBarLayerAlgo
Definition: DDPixBarLayerAlgo.cc:26

DDSolid
A DDSolid represents the shape of a part.
Definition: DDSolid.h:39

DDPixBarLayerAlgo::idNameSpace
string idNameSpace
Definition: DDPixBarLayerAlgo.cc:41

DDSolid.h

contentValuesFiles.number
number
Definition: contentValuesFiles.py:53

DDRotation
Represents a uniquely identifyable rotation matrix.
Definition: DDTransform.h:57

edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222

ReadMapType< double >

DDPixBarLayerAlgo::ladderWidth
vector< double > ladderWidth
Definition: DDPixBarLayerAlgo.cc:54

versionedElectronIDProducer_cfi.idName
idName
Definition: versionedElectronIDProducer_cfi.py:11

DDName::name
const std::string & name() const
Returns the name.
Definition: DDName.cc:41

createfilelist.int
int
Definition: createfilelist.py:10

edmplugin::PluginFactory
Definition: PluginFactory.h:35

mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19

funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22

DDCurrentNamespace.h

DDPixBarLayerAlgo::coolMat
string coolMat
Definition: DDPixBarLayerAlgo.cc:51

DDLogicalPart
A DDLogicalPart aggregates information concerning material, solid and sensitveness ...
Definition: DDLogicalPart.h:93

DDrot
DDRotation DDrot(const DDName &name, std::unique_ptr< DDRotationMatrix > rot)
Definition of a uniquely identifiable rotation matrix named by DDName name.
Definition: DDRotation.cc:67

DDSolidFactory::tubs
static DDSolid tubs(const DDName &name, double zhalf, double rIn, double rOut, double startPhi, double deltaPhi)
Definition: DDSolid.cc:667

DDPixBarLayerAlgo::~DDPixBarLayerAlgo
~DDPixBarLayerAlgo() override
Definition: DDPixBarLayerAlgo.cc:60

DDSolidFactory::trap
static DDSolid trap(const DDName &name, double pDz, double pTheta, double pPhi, double pDy1, double pDx1, double pDx2, double pAlp1, double pDy2, double pDx3, double pDx4, double pAlp2)
Definition: DDSolid.cc:609

filterCSVwithJSON.copy
copy
Definition: filterCSVwithJSON.py:36

DDBase::name
const N & name() const
Definition: DDBase.h:59

geometryCSVtoXML.xx
xx
Definition: geometryCSVtoXML.py:19

DDPixBarLayerAlgo::initialize
void initialize(const DDNumericArguments &nArgs, const DDVectorArguments &vArgs, const DDMapArguments &mArgs, const DDStringArguments &sArgs, const DDStringVectorArguments &vsArgs) override
Definition: DDPixBarLayerAlgo.cc:62

DDPixBarLayerAlgo::coolWidth
double coolWidth
Definition: DDPixBarLayerAlgo.cc:47

DDPixBarLayerAlgo::ladder
vector< string > ladder
Definition: DDPixBarLayerAlgo.cc:53

DDPixBarLayerAlgo::tubeMat
string tubeMat
Definition: DDPixBarLayerAlgo.cc:52

DDBase::ddname
const N & ddname() const
Definition: DDBase.h:61

DDPixBarLayerAlgo::ladderThick
vector< double > ladderThick
Definition: DDPixBarLayerAlgo.cc:55

dqmdumpme.first
first
Definition: dqmdumpme.py:55

DDLogicalPart.h

DDPixBarLayerAlgo::coolSide
double coolSide
Definition: DDPixBarLayerAlgo.cc:48

DDAlgorithm.h

DDPixBarLayerAlgo::coolThick
double coolThick
Definition: DDPixBarLayerAlgo.cc:49

class-composition.parent
parent
Definition: class-composition.py:99

DEFINE_EDM_PLUGIN
#define DEFINE_EDM_PLUGIN(factory, type, name)
Definition: PluginFactory.h:123

DDSplit.h

DDPixBarLayerAlgo::coolDist
double coolDist
Definition: DDPixBarLayerAlgo.cc:50

d1
static constexpr float d1
Definition: L1EGammaCrystalsEmulatorProducer.cc:82

DDTypes.h

DDSplit
std::pair< std::string, std::string > DDSplit(const std::string &n)
split into (name,namespace), separator = &#39;:&#39;
Definition: DDSplit.cc:3

DDTranslation
ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< double > > DDTranslation
Definition: DDTranslation.h:7

DDPixBarLayerAlgo::DDPixBarLayerAlgo
DDPixBarLayerAlgo()
Definition: DDPixBarLayerAlgo.cc:58

makeMuonMisalignmentScenario.rot
rot
Definition: makeMuonMisalignmentScenario.py:322

PVValHelper::ladder
Definition: PVValidationHelpers.h:73

Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17

LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233