Inheritance diagram for TGeoMgrFromDdd:

Public Types
using	ReturnType = std::unique_ptr< TGeoManager >

Public Member Functions
const TGeoMgrFromDdd &	operator= (const TGeoMgrFromDdd &)=delete

ReturnType	produce (const DisplayGeomRecord &)

	TGeoMgrFromDdd (const edm::ParameterSet &)

	TGeoMgrFromDdd (const TGeoMgrFromDdd &)=delete

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

	ESProducer (ESProducer &&)=delete

ESResolverIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer &	operator= (const ESProducer &)=delete

ESProducer &	operator= (ESProducer &&)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProductResolverFactoryProducer
	ESProductResolverFactoryProducer ()

	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete

const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete

	~ESProductResolverFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
TGeoManager *	createManager (int level)

TGeoMaterial *	createMaterial (const DDMaterial &iMaterial)

TGeoShape *	createShape (const std::string &iName, const DDSolid &iSolid)

TGeoVolume *	createVolume (const std::string &iName, const DDSolid &iSolid, const DDMaterial &iMaterial)

Private Attributes
const bool	m_fullname

const int	m_level

std::string	m_TGeoName

std::string	m_TGeoTitle

const bool	m_verbose

std::map< std::string, TGeoMaterial * >	nameToMaterial_

std::map< std::string, TGeoMedium * >	nameToMedium_

std::map< std::string, TGeoShape * >	nameToShape_

std::map< std::string, TGeoVolume * >	nameToVolume_

const edm::ESGetToken< DDCompactView, IdealGeometryRecord >	viewToken_

Additional Inherited Members
Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>

Protected Member Functions inherited from edm::ESProducer
ESConsumesInfo *	consumesInfoPushBackNew ()

unsigned int	consumesInfoSize () const

template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList , const TRecord iRecord, const es::Label &iLabel)

template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null , const TRecord , const es::Label &)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TDecorator >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Definition at line 52 of file TGeoMgrFromDdd.cc.

Member Typedef Documentation

◆ ReturnType

using TGeoMgrFromDdd::ReturnType = std::unique_ptr<TGeoManager>

Definition at line 58 of file TGeoMgrFromDdd.cc.

Constructor & Destructor Documentation

◆ TGeoMgrFromDdd() [1/2]

TGeoMgrFromDdd::TGeoMgrFromDdd ( const edm::ParameterSet & pset )

Definition at line 93 of file TGeoMgrFromDdd.cc.

     : m_level(pset.getUntrackedParameter<int>("level")),
       m_verbose(pset.getUntrackedParameter<bool>("verbose")),
       m_fullname(pset.getUntrackedParameter<bool>("fullName")),
       viewToken_(setWhatProduced(this).consumes()) {}

◆ TGeoMgrFromDdd() [2/2]

TGeoMgrFromDdd::TGeoMgrFromDdd ( const TGeoMgrFromDdd & )

delete

Member Function Documentation

◆ createManager()

TGeoManager* TGeoMgrFromDdd::createManager ( int level )

private

◆ createMaterial()

TGeoMaterial * TGeoMgrFromDdd::createMaterial ( const DDMaterial & iMaterial )

private

Definition at line 618 of file TGeoMgrFromDdd.cc.

References DDMaterial::a(), DDMaterial::constituent(), DDMaterial::density(), DDName::fullname(), g, mps_fire::i, m_fullname, reco_application_tbsim_DetSim-Digi_cfg::mix, DDName::name(), DDBase< N, C >::name(), nameToMaterial_, DDMaterial::noOfConstituents(), AlCaHLTBitMon_QueryRunRegistry::string, and DDMaterial::z().

Referenced by createVolume().

                                                                         {
   std::string mat_name = m_fullname ? iMaterial.name().fullname() : iMaterial.name().name();
   edm::LogVerbatim("TGeoMgrFromDdd") << "createMaterial with name: " << mat_name;
   TGeoMaterial* mat = nameToMaterial_[mat_name];
 
   if (mat == nullptr) {
     if (iMaterial.noOfConstituents() > 0) {
       TGeoMixture* mix =
           new TGeoMixture(mat_name.c_str(), iMaterial.noOfConstituents(), iMaterial.density() * CLHEP::cm3 / CLHEP::g);
       for (int i = 0; i < iMaterial.noOfConstituents(); ++i) {
         mix->AddElement(createMaterial(iMaterial.constituent(i).first), iMaterial.constituent(i).second);
       }
       mat = mix;
     } else {
       mat = new TGeoMaterial(mat_name.c_str(),
                              iMaterial.a() * CLHEP::mole / CLHEP::g,
                              iMaterial.z(),
                              iMaterial.density() * CLHEP::cm3 / CLHEP::g);
     }
     nameToMaterial_[mat_name] = mat;
   }
 
   return mat;
 }

◆ createShape()

TGeoShape * TGeoMgrFromDdd::createShape	(	const std::string &	iName,
		const DDSolid &	iSolid
	)

private

Definition at line 239 of file TGeoMgrFromDdd.cc.

References funct::abs(), isotrackApplyRegressor::alpha, filterCSVwithJSON::copy, funct::cos(), dd4hep::createPlacement(), ztail::d, ddbox, ddcons, ddcuttubs, ddellipticaltube, ddextrudedpolygon, ddintersection, ddpolycone_rrz, ddpolyhedra_rrz, ddpseudotrap, ddsubtraction, ddtorus, ddtrap, ddtrunctubs, ddtubs, ddunion, dumpMFGeometry_cfg::delta, srCondWrite_cfg::deltaPhi, DDTorus::deltaPhi(), Exception, DDName::fullname(), h, mps_fire::i, DDBase< N, C >::isDefined(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, m_fullname, DDRotation::matrix(), DDName::name(), DDBase< N, C >::name(), mergeVDriftHistosByStation::name, nameToShape_, DDSolid::parameters(), submitPVValidationJobs::params, DiDispStaMuonMonitor_cfi::pt, dttmaxenums::R, alignCSCRings::r, DDTorus::rMax(), DDTorus::rMin(), makeMuonMisalignmentScenario::rot, DDBooleanSolid::rotation(), DDTorus::rTorus(), alignCSCRings::s, DDSolid::shape(), funct::sin(), DDBooleanSolid::solidA(), DDBooleanSolid::solidB(), mathSSE::sqrt(), DDTorus::startPhi(), AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, HcalDetIdTransform::transform(), DDBooleanSolid::translation(), groupFilesInBlocks::tt, x, DDExtrudedPolygon::xVec(), y, DDExtrudedPolygon::yVec(), z, DDExtrudedPolygon::zscaleVec(), DDExtrudedPolygon::zVec(), DDExtrudedPolygon::zxVec(), and DDExtrudedPolygon::zyVec().

Referenced by createVolume().

                                                                                     {
   edm::LogVerbatim("TGeoMgrFromDdd") << "createShape with name: " << iName
                                      << " and solid: " << iSolid.name().fullname();
 
   DDBase<DDName, DDI::Solid*>::def_type defined(iSolid.isDefined());
   if (!defined.first)
     throw cms::Exception("TGeoMgrFromDdd::createShape * solid " + iName + " is not declared * ");
   if (!defined.second)
     throw cms::Exception("TGeoMgrFromDdd::createShape * solid " + defined.first->name() + " is not defined *");
 
   TGeoShape* rSolid = nameToShape_[iName];
   if (rSolid == nullptr) {
     const std::vector<double>& params = iSolid.parameters();
     switch (iSolid.shape()) {
       case DDSolidShape::ddbox:
         rSolid = new TGeoBBox(iName.c_str(), params[0] / cm, params[1] / cm, params[2] / cm);
         break;
       case DDSolidShape::ddcons:
         rSolid = new TGeoConeSeg(iName.c_str(),
                                  params[0] / cm,
                                  params[1] / cm,
                                  params[2] / cm,
                                  params[3] / cm,
                                  params[4] / cm,
                                  params[5] / deg,
                                  params[6] / deg + params[5] / deg);
         break;
       case DDSolidShape::ddtubs:
         //Order in params is  zhalf,rIn,rOut,startPhi,deltaPhi
         rSolid = new TGeoTubeSeg(iName.c_str(),
                                  params[1] / cm,
                                  params[2] / cm,
                                  params[0] / cm,
                                  params[3] / deg,
                                  params[3] / deg + params[4] / deg);
         break;
       case DDSolidShape::ddcuttubs:
         //Order in params is  zhalf,rIn,rOut,startPhi,deltaPhi,lx,ly,lz,tx,ty,tz
         rSolid = new TGeoCtub(iName.c_str(),
                               params[1] / cm,
                               params[2] / cm,
                               params[0] / cm,
                               params[3] / deg,
                               params[3] / deg + params[4] / deg,
                               params[5],
                               params[6],
                               params[7],
                               params[8],
                               params[9],
                               params[10]);
         break;
       case DDSolidShape::ddtrap:
         rSolid = new TGeoTrap(iName.c_str(),
                               params[0] / cm,     //dz
                               params[1] / deg,    //theta
                               params[2] / deg,    //phi
                               params[3] / cm,     //dy1
                               params[4] / cm,     //dx1
                               params[5] / cm,     //dx2
                               params[6] / deg,    //alpha1
                               params[7] / cm,     //dy2
                               params[8] / cm,     //dx3
                               params[9] / cm,     //dx4
                               params[10] / deg);  //alpha2
         break;
       case DDSolidShape::ddpolycone_rrz:
         rSolid = new TGeoPcon(iName.c_str(), params[0] / deg, params[1] / deg, (params.size() - 2) / 3);
         {
           std::vector<double> temp(params.size() + 1);
           temp.reserve(params.size() + 1);
           temp[0] = params[0] / deg;
           temp[1] = params[1] / deg;
           temp[2] = (params.size() - 2) / 3;
           std::copy(params.begin() + 2, params.end(), temp.begin() + 3);
           for (std::vector<double>::iterator it = temp.begin() + 3; it != temp.end(); ++it) {
             *it /= cm;
           }
           rSolid->SetDimensions(&(*(temp.begin())));
         }
         break;
       case DDSolidShape::ddpolyhedra_rrz:
         rSolid = new TGeoPgon(
             iName.c_str(), params[1] / deg, params[2] / deg, static_cast<int>(params[0]), (params.size() - 3) / 3);
         {
           std::vector<double> temp(params.size() + 1);
           temp[0] = params[1] / deg;
           temp[1] = params[2] / deg;
           temp[2] = params[0];
           temp[3] = (params.size() - 3) / 3;
           std::copy(params.begin() + 3, params.end(), temp.begin() + 4);
           for (std::vector<double>::iterator it = temp.begin() + 4; it != temp.end(); ++it) {
             *it /= cm;
           }
           rSolid->SetDimensions(&(*(temp.begin())));
         }
         break;
       case DDSolidShape::ddextrudedpolygon: {
         DDExtrudedPolygon extrPgon(iSolid);
         std::vector<double> x = extrPgon.xVec();
         std::transform(x.begin(), x.end(), x.begin(), [](double d) { return d / cm; });
         std::vector<double> y = extrPgon.yVec();
         std::transform(y.begin(), y.end(), y.begin(), [](double d) { return d / cm; });
         std::vector<double> z = extrPgon.zVec();
         std::vector<double> zx = extrPgon.zxVec();
         std::vector<double> zy = extrPgon.zyVec();
         std::vector<double> zscale = extrPgon.zscaleVec();
 
         TGeoXtru* mySolid = new TGeoXtru(z.size());
         mySolid->DefinePolygon(x.size(), &(*x.begin()), &(*y.begin()));
         for (size_t i = 0; i < params[0]; ++i) {
           mySolid->DefineSection(i, z[i] / cm, zx[i] / cm, zy[i] / cm, zscale[i]);
         }
 
         rSolid = mySolid;
       } break;
       case DDSolidShape::ddpseudotrap: {
         //implementation taken from SimG4Core/Geometry/src/DDG4SolidConverter.cc
         const static DDRotationMatrix s_rot(ROOT::Math::RotationX(90. * deg));
         DDPseudoTrap pt(iSolid);
 
         double r = pt.radius();
         bool atMinusZ = pt.atMinusZ();
         double x = 0;
         double h = 0;
         bool intersec = false;  // union or intersection solid
 
         if (atMinusZ) {
           x = pt.x1();  // tubs radius
         } else {
           x = pt.x2();  // tubs radius
         }
         double halfOpeningAngle = asin(x / std::abs(r)) / deg;
         double displacement = 0;
         double startPhi = 0;
         /* calculate the displacement of the tubs w.r.t. to the trap,
            determine the opening angle of the tubs */
         double delta = sqrt(r * r - x * x);
         std::string name = m_fullname ? pt.name().fullname() : pt.name().name();
 
         if (r < 0 && std::abs(r) >= x) {
           intersec = true;                            // intersection solid
           h = pt.y1() < pt.y2() ? pt.y2() : pt.y1();  // tubs half height
           h += h / 20.;                               // enlarge a bit - for subtraction solid
           if (atMinusZ) {
             displacement = -pt.halfZ() - delta;
             startPhi = 90. - halfOpeningAngle;
           } else {
             displacement = pt.halfZ() + delta;
             startPhi = -90. - halfOpeningAngle;
           }
         } else if (r > 0 && std::abs(r) >= x) {
           if (atMinusZ) {
             displacement = -pt.halfZ() + delta;
             startPhi = 270. - halfOpeningAngle;
             h = pt.y1();
           } else {
             displacement = pt.halfZ() - delta;
             startPhi = 90. - halfOpeningAngle;
             h = pt.y2();
           }
         } else {
           throw cms::Exception("Check parameters of the PseudoTrap! name=" + name);
         }
 
         std::unique_ptr<TGeoShape> trap(
             new TGeoTrd2(name.c_str(), pt.x1() / cm, pt.x2() / cm, pt.y1() / cm, pt.y2() / cm, pt.halfZ() / cm));
 
         std::unique_ptr<TGeoShape> tubs(new TGeoTubeSeg(name.c_str(),
                                                         0.,
                                                         std::abs(r) / cm,  // radius cannot be negative!!!
                                                         h / cm,
                                                         startPhi,
                                                         startPhi + halfOpeningAngle * 2.));
         if (intersec) {
           TGeoSubtraction* sub = new TGeoSubtraction(
               trap.release(), tubs.release(), nullptr, createPlacement(s_rot, DDTranslation(0., 0., displacement)));
           rSolid = new TGeoCompositeShape(iName.c_str(), sub);
         } else {
           std::unique_ptr<TGeoShape> box(new TGeoBBox(1.1 * x / cm, 1.1 * h / cm, sqrt(r * r - x * x) / cm));
 
           TGeoSubtraction* sub = new TGeoSubtraction(
               tubs.release(), box.release(), nullptr, createPlacement(s_rot, DDTranslation(0., 0., 0.)));
 
           std::unique_ptr<TGeoShape> tubicCap(new TGeoCompositeShape(iName.c_str(), sub));
 
           TGeoUnion* boolS = new TGeoUnion(
               trap.release(), tubicCap.release(), nullptr, createPlacement(s_rot, DDTranslation(0., 0., displacement)));
 
           rSolid = new TGeoCompositeShape(iName.c_str(), boolS);
         }
 
         break;
       }
       case DDSolidShape::ddtorus: {
         DDTorus solid(iSolid);
         rSolid = new TGeoTorus(iName.c_str(),
                                solid.rTorus() / cm,
                                solid.rMin() / cm,
                                solid.rMax() / cm,
                                solid.startPhi() / deg,
                                solid.deltaPhi() / deg);
         break;
       }
       case DDSolidShape::ddsubtraction: {
         DDBooleanSolid boolSolid(iSolid);
         if (!boolSolid) {
           throw cms::Exception("GeomConvert") << "conversion to DDBooleanSolid failed";
         }
 
         std::string nameA = m_fullname ? boolSolid.solidA().name().fullname() : boolSolid.solidA().name().name();
         std::string nameB = m_fullname ? boolSolid.solidB().name().fullname() : boolSolid.solidB().name().name();
         std::unique_ptr<TGeoShape> left(createShape(nameA, boolSolid.solidA()));
         std::unique_ptr<TGeoShape> right(createShape(nameB, boolSolid.solidB()));
         if (nullptr != left.get() && nullptr != right.get()) {
           TGeoSubtraction* sub =
               new TGeoSubtraction(left.release(),
                                   right.release(),
                                   nullptr,
                                   createPlacement(boolSolid.rotation().matrix(), boolSolid.translation()));
           rSolid = new TGeoCompositeShape(iName.c_str(), sub);
         }
         break;
       }
       case DDSolidShape::ddtrunctubs: {
         DDTruncTubs tt(iSolid);
         if (!tt) {
           throw cms::Exception("GeomConvert") << "conversion to DDTruncTubs failed";
         }
         double rIn(tt.rIn());
         double rOut(tt.rOut());
         double zHalf(tt.zHalf());
         double startPhi(tt.startPhi());
         double deltaPhi(tt.deltaPhi());
         double cutAtStart(tt.cutAtStart());
         double cutAtDelta(tt.cutAtDelta());
         bool cutInside(bool(tt.cutInside()));
         std::string name = m_fullname ? tt.name().fullname() : tt.name().name();
 
         // check the parameters
         if (rIn <= 0 || rOut <= 0 || cutAtStart <= 0 || cutAtDelta <= 0) {
           std::string s = "TruncTubs " + name + ": 0 <= rIn,cutAtStart,rOut,cutAtDelta,rOut violated!";
           throw cms::Exception(s);
         }
         if (rIn >= rOut) {
           std::string s = "TruncTubs " + name + ": rIn<rOut violated!";
           throw cms::Exception(s);
         }
         if (startPhi != 0.) {
           std::string s = "TruncTubs " + name + ": startPhi != 0 not supported!";
           throw cms::Exception(s);
         }
 
         startPhi = 0.;
         double r(cutAtStart);
         double R(cutAtDelta);
 
         // Note: startPhi is always 0.0
         std::unique_ptr<TGeoShape> tubs(
             new TGeoTubeSeg(name.c_str(), rIn / cm, rOut / cm, zHalf / cm, startPhi, deltaPhi / deg));
 
         double boxX(rOut), boxY(rOut);  // exaggerate dimensions - does not matter, it's subtracted!
 
         // width of the box > width of the tubs
         double boxZ(1.1 * zHalf);
 
         // angle of the box w.r.t. tubs
         double cath = r - R * cos(deltaPhi);
         double hypo = sqrt(r * r + R * R - 2. * r * R * cos(deltaPhi));
         double cos_alpha = cath / hypo;
         double alpha = -acos(cos_alpha);
 
         // rotationmatrix of box w.r.t. tubs
         TGeoRotation rot;
         rot.RotateX(90);
         rot.RotateZ(alpha / deg);
 
         // center point of the box
         double xBox;
         if (!cutInside) {
           xBox = r + boxX / sin(fabs(alpha));
         } else {
           xBox = -(boxX / sin(fabs(alpha)) - r);
         }
         std::unique_ptr<TGeoShape> box(new TGeoBBox(name.c_str(), boxX / cm, boxZ / cm, boxY / cm));
 
         TGeoTranslation trans(xBox / cm, 0., 0.);
 
         TGeoSubtraction* sub =
             new TGeoSubtraction(tubs.release(), box.release(), nullptr, new TGeoCombiTrans(trans, rot));
 
         rSolid = new TGeoCompositeShape(iName.c_str(), sub);
         break;
       }
       case DDSolidShape::ddunion: {
         DDBooleanSolid boolSolid(iSolid);
         if (!boolSolid) {
           throw cms::Exception("GeomConvert") << "conversion to DDBooleanSolid failed";
         }
 
         std::string nameA = m_fullname ? boolSolid.solidA().name().fullname() : boolSolid.solidA().name().name();
         std::string nameB = m_fullname ? boolSolid.solidB().name().fullname() : boolSolid.solidB().name().name();
         std::unique_ptr<TGeoShape> left(createShape(nameA, boolSolid.solidA()));
         std::unique_ptr<TGeoShape> right(createShape(nameB, boolSolid.solidB()));
         //DEBUGGING
         //break;
         if (nullptr != left.get() && nullptr != right.get()) {
           TGeoUnion* boolS = new TGeoUnion(left.release(),
                                            right.release(),
                                            nullptr,
                                            createPlacement(boolSolid.rotation().matrix(), boolSolid.translation()));
           rSolid = new TGeoCompositeShape(iName.c_str(), boolS);
         }
         break;
       }
       case DDSolidShape::ddintersection: {
         DDBooleanSolid boolSolid(iSolid);
         if (!boolSolid) {
           throw cms::Exception("GeomConvert") << "conversion to DDBooleanSolid failed";
         }
 
         std::string nameA = m_fullname ? boolSolid.solidA().name().fullname() : boolSolid.solidA().name().name();
         std::string nameB = m_fullname ? boolSolid.solidB().name().fullname() : boolSolid.solidB().name().name();
         std::unique_ptr<TGeoShape> left(createShape(nameA, boolSolid.solidA()));
         std::unique_ptr<TGeoShape> right(createShape(nameB, boolSolid.solidB()));
         if (nullptr != left.get() && nullptr != right.get()) {
           TGeoIntersection* boolS =
               new TGeoIntersection(left.release(),
                                    right.release(),
                                    nullptr,
                                    createPlacement(boolSolid.rotation().matrix(), boolSolid.translation()));
           rSolid = new TGeoCompositeShape(iName.c_str(), boolS);
         }
         break;
       }
       case DDSolidShape::ddellipticaltube: {
         DDEllipticalTube eSolid(iSolid);
         if (!eSolid) {
           throw cms::Exception("GeomConvert") << "conversion to DDEllipticalTube failed";
         }
         rSolid = new TGeoEltu(iName.c_str(), params[0] / cm, params[1] / cm, params[2] / cm);
         break;
       }
       default:
         break;
     }
     nameToShape_[iName] = rSolid;
   }
   if (rSolid == nullptr) {
     edm::LogError("TGeoMgrFromDdd") << "COULD NOT MAKE " << iName << " of a shape " << iSolid;
   }
 
   edm::LogVerbatim("TGeoMgrFromDdd") << "solid " << iName << " has been created.";
 
   return rSolid;
 }

◆ createVolume()

TGeoVolume * TGeoMgrFromDdd::createVolume	(	const std::string &	iName,
		const DDSolid &	iSolid,
		const DDMaterial &	iMaterial
	)

private

Definition at line 595 of file TGeoMgrFromDdd.cc.

References createMaterial(), createShape(), DDName::fullname(), m_fullname, DDName::name(), DDBase< N, C >::name(), nameToMedium_, nameToVolume_, AlCaHLTBitMon_QueryRunRegistry::string, and findQualityFiles::v.

Referenced by produce().

                                                                                                                    {
   edm::LogVerbatim("TGeoMgrFromDdd") << "createVolume with name: " << iName
                                      << " and solid: " << iSolid.name().fullname() << " and material "
                                      << iMaterial.name().fullname();
   TGeoVolume* v = nameToVolume_[iName];
   if (v == nullptr) {
     TGeoShape* solid =
         m_fullname ? createShape(iSolid.name().fullname(), iSolid) : createShape(iSolid.name().name(), iSolid);
     std::string mat_name = m_fullname ? iMaterial.name().fullname() : iMaterial.name().name();
     TGeoMedium* geo_med = nameToMedium_[mat_name];
     if (geo_med == nullptr) {
       TGeoMaterial* geo_mat = createMaterial(iMaterial);
       geo_med = new TGeoMedium(mat_name.c_str(), 0, geo_mat);
       nameToMedium_[mat_name] = geo_med;
     }
     if (solid) {
       v = new TGeoVolume(iName.c_str(), solid, geo_med);
     }
     nameToVolume_[iName] = v;
   }
   return v;
 }

◆ fillDescriptions()

void TGeoMgrFromDdd::fillDescriptions ( edm::ConfigurationDescriptions & conf )

static

Definition at line 99 of file TGeoMgrFromDdd.cc.

References edm::ConfigurationDescriptions::add(), and submitPVResolutionJobs::desc.

                                                                         {
   edm::ParameterSetDescription desc;
   desc.addUntracked<int>("level", 10)->setComment("How deep into the geometry hierarchy should the conversion go.");
   desc.addUntracked<bool>("verbose", false);
   desc.addUntracked<bool>("fullName", true)->setComment("use fillname() instead of name() when generating node names");
 
   conf.add("TGeoMgrFromDdd", desc);
 }

◆ operator=()

const TGeoMgrFromDdd& TGeoMgrFromDdd::operator= ( const TGeoMgrFromDdd & )

delete

◆ produce()

TGeoMgrFromDdd::ReturnType TGeoMgrFromDdd::produce ( const DisplayGeomRecord & iRecord )

Definition at line 129 of file TGeoMgrFromDdd.cc.

References dd4hep::createPlacement(), createVolume(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getTransientHandle(), info(), edm::ESHandleBase::isValid(), m_fullname, m_level, m_verbose, DDSolidShapesName::name(), mergeVDriftHistosByStation::name, nameToMaterial_, nameToMedium_, nameToShape_, nameToVolume_, EgammaValidation_cff::num, DDCompactView::root(), AlCaHLTBitMon_QueryRunRegistry::string, viewToken_, and DDCompactView::walker().

                                                                                  {
   using namespace edm;
 
   ESTransientHandle<DDCompactView> viewH = iRecord.getTransientHandle(viewToken_);
 
   if (!viewH.isValid()) {
     return std::unique_ptr<TGeoManager>();
   }
 
   TGeoManager* geo_mgr = new TGeoManager("cmsGeo", "CMS Detector");
   // NOTE: the default constructor does not create the identity matrix
   if (gGeoIdentity == nullptr) {
     gGeoIdentity = new TGeoIdentity("Identity");
   }
 
   edm::LogVerbatim("TGeoMgrFromDdd") << "about to initialize the DDCompactView walker with a root node "
                                      << viewH->root() << std::endl;
 
   auto walker = viewH->walker();
   auto info = walker.current();
 
   // The top most item is actually the volume holding both the
   // geometry AND the magnetic field volumes!
   walker.firstChild();
   if (!walker.firstChild()) {
     return std::unique_ptr<TGeoManager>();
   }
 
   TGeoVolume* top = (m_fullname ? createVolume(info.first.name().fullname(), info.first.solid(), info.first.material())
                                 : createVolume(info.first.name().name(), info.first.solid(), info.first.material()));
 
   if (top == nullptr) {
     return std::unique_ptr<TGeoManager>();
   }
 
   geo_mgr->SetTopVolume(top);
   // ROOT chokes unless colors are assigned
   top->SetVisibility(kFALSE);
   top->SetLineColor(kBlue);
 
   std::vector<TGeoVolume*> parentStack;
   parentStack.push_back(top);
 
   do {
     auto info = walker.current();
 
     if (m_verbose) {
       edm::LogVerbatim("TGeoMgrFromDdd") << "parentStack of size " << parentStack.size();
       auto num = (info.second != nullptr) ? info.second->copyno() : 0;
       edm::LogVerbatim("TGeoMgrFromDdd") << info.first.name() << " " << num << " "
                                          << DDSolidShapesName::name(info.first.solid().shape());
     }
 
     std::string name = m_fullname ? info.first.name().fullname() : info.first.name().name();
     bool childAlreadyExists = (nullptr != nameToVolume_[name]);
     TGeoVolume* child = createVolume(name, info.first.solid(), info.first.material());
     if (nullptr != child && info.second != nullptr) {
       parentStack.back()->AddNode(
           child, info.second->copyno(), createPlacement(info.second->rotation(), info.second->translation()));
       child->SetLineColor(kBlue);
     } else {
       if (info.second == nullptr) {
         break;
       }
     }
     if (nullptr == child || childAlreadyExists || m_level == int(parentStack.size())) {
       if (nullptr != child) {
         child->SetLineColor(kRed);
       }
       //stop descending
       if (!walker.nextSibling()) {
         while (walker.parent()) {
           parentStack.pop_back();
           if (walker.nextSibling()) {
             break;
           }
         }
       }
     } else {
       if (walker.firstChild()) {
         parentStack.push_back(child);
       } else {
         if (!walker.nextSibling()) {
           while (walker.parent()) {
             parentStack.pop_back();
             if (walker.nextSibling()) {
               break;
             }
           }
         }
       }
     }
   } while (!parentStack.empty());
 
   geo_mgr->CloseGeometry();
 
   geo_mgr->DefaultColors();
 
   nameToShape_.clear();
   nameToVolume_.clear();
   nameToMaterial_.clear();
   nameToMedium_.clear();
 
   return std::unique_ptr<TGeoManager>(geo_mgr);
 }

Member Data Documentation

◆ m_fullname

const bool TGeoMgrFromDdd::m_fullname

private

Definition at line 81 of file TGeoMgrFromDdd.cc.

Referenced by createMaterial(), createShape(), createVolume(), and produce().

◆ m_level

const int TGeoMgrFromDdd::m_level

private

Definition at line 79 of file TGeoMgrFromDdd.cc.

Referenced by produce().

◆ m_TGeoName

std::string TGeoMgrFromDdd::m_TGeoName

private

Definition at line 82 of file TGeoMgrFromDdd.cc.

◆ m_TGeoTitle

std::string TGeoMgrFromDdd::m_TGeoTitle

private

Definition at line 83 of file TGeoMgrFromDdd.cc.

◆ m_verbose

const bool TGeoMgrFromDdd::m_verbose

private

Definition at line 80 of file TGeoMgrFromDdd.cc.

Referenced by produce().

◆ nameToMaterial_

std::map<std::string, TGeoMaterial*> TGeoMgrFromDdd::nameToMaterial_

private

Definition at line 87 of file TGeoMgrFromDdd.cc.

Referenced by createMaterial(), and produce().

◆ nameToMedium_

std::map<std::string, TGeoMedium*> TGeoMgrFromDdd::nameToMedium_

private

Definition at line 88 of file TGeoMgrFromDdd.cc.

Referenced by createVolume(), and produce().

◆ nameToShape_

std::map<std::string, TGeoShape*> TGeoMgrFromDdd::nameToShape_

private

Definition at line 85 of file TGeoMgrFromDdd.cc.

Referenced by createShape(), and produce().

◆ nameToVolume_

std::map<std::string, TGeoVolume*> TGeoMgrFromDdd::nameToVolume_

private

Definition at line 86 of file TGeoMgrFromDdd.cc.

Referenced by createVolume(), and produce().

◆ viewToken_

const edm::ESGetToken<DDCompactView, IdealGeometryRecord> TGeoMgrFromDdd::viewToken_

private

Definition at line 90 of file TGeoMgrFromDdd.cc.

Referenced by produce().

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ReturnType

Constructor & Destructor Documentation

◆ TGeoMgrFromDdd() [1/2]

◆ TGeoMgrFromDdd() [2/2]

Member Function Documentation

◆ createManager()

◆ createMaterial()

◆ createShape()

◆ createVolume()

◆ fillDescriptions()

◆ operator=()

◆ produce()

Member Data Documentation

◆ m_fullname

◆ m_level

◆ m_TGeoName

◆ m_TGeoTitle

◆ m_verbose

◆ nameToMaterial_

◆ nameToMedium_

◆ nameToShape_

◆ nameToVolume_

◆ viewToken_