#include <Fireworks/Geometry/interface/TGeoMgrFromDdd.h>

Inheritance diagram for TGeoMgrFromDdd:

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

Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair< DataKey, edm::propagate_const< std::shared_ptr< DataProxy > > > >	KeyedProxies

typedef std::vector< EventSetupRecordKey >	Keys

typedef std::map< EventSetupRecordKey, KeyedProxies >	RecordProxies

Public Member Functions
ReturnType	produce (const DisplayGeomRecord &)

	TGeoMgrFromDdd (const edm::ParameterSet &)

	~TGeoMgrFromDdd () override

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

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer ()(false) override

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

void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval) override
	overrides DataProxyProvider method More...

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

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)

const TGeoMgrFromDdd &	operator= (const TGeoMgrFromDdd &)

	TGeoMgrFromDdd (const TGeoMgrFromDdd &)

Private Attributes
int	m_level

std::string	m_TGeoName

std::string	m_TGeoTitle

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_

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::ESProducer
	ESProducer (const ESProducer &)=delete

ESProducer const &	operator= (const ESProducer &)=delete

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 TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

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

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

void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList) override
	override DataProxyProvider method More...

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

Detailed Description

Description: [one line class summary]

Usage: <usage>

Definition at line 47 of file TGeoMgrFromDdd.h.

Member Typedef Documentation

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

Definition at line 53 of file TGeoMgrFromDdd.h.

Constructor & Destructor Documentation

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

Definition at line 49 of file TGeoMgrFromDdd.cc.

References edm::ESProducer::setWhatProduced().

   : m_level( pset.getUntrackedParameter<int> ( "level", 10 )),
     m_verbose( pset.getUntrackedParameter<bool>( "verbose", false ))
 {
    // The following line is needed to tell the framework what data is
    // being produced.
    setWhatProduced( this );
 }

TGeoMgrFromDdd::~TGeoMgrFromDdd ( void )

override

Definition at line 58 of file TGeoMgrFromDdd.cc.

References allElectronIsolations_cfi::elements, alignCSCRings::r, and lumiQTWidget::t.

59 {}

TGeoMgrFromDdd::TGeoMgrFromDdd ( const TGeoMgrFromDdd & )

private

Member Function Documentation

TGeoManager* TGeoMgrFromDdd::createManager ( int level )

private

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

private

Definition at line 696 of file TGeoMgrFromDdd.cc.

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

Referenced by createVolume().

 {
    std::string   mat_name = iMaterial.name().fullname();
    TGeoMaterial *mat      = nameToMaterial_[mat_name];
 
    if (mat == nullptr)
    {
       if (iMaterial.noOfConstituents() > 0)
       {
          TGeoMixture *mix = new TGeoMixture(mat_name.c_str(),
                                             iMaterial.noOfConstituents(),
                                             iMaterial.density()*cm3/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()*mole/g, iMaterial.z(),
                                 iMaterial.density()*cm3/g);
       }
       nameToMaterial_[mat_name] = mat;
    }
 
    return mat;
 }

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

private

Definition at line 225 of file TGeoMgrFromDdd.cc.

References funct::abs(), alpha, DDPseudoTrap::atMinusZ(), MessageLogger_cfi::cerr, popcon2dropbox::copy(), funct::cos(), DDTruncTubs::cutAtDelta(), DDTruncTubs::cutAtStart(), DDTruncTubs::cutInside(), edmIntegrityCheck::d, ddbox, ddcons, ddcuttubs, ddellipticaltube, ddextrudedpolygon, ddintersection, ddpolycone_rrz, ddpolyhedra_rrz, ddpseudotrap, ddsubtraction, ddtorus, ddtrap, ddtrunctubs, ddtubs, ddunion, delta, hiPixelPairStep_cff::deltaPhi, DDTruncTubs::deltaPhi(), DDTorus::deltaPhi(), Exception, DDName::fullname(), h, DDPseudoTrap::halfZ(), mps_fire::i, LogDebug, DDRotation::matrix(), DDName::name(), dataset::name, DDBase< N, C >::name(), nameToShape_, EnergyCorrector::pt, dttmaxenums::R, alignCSCRings::r, DDPseudoTrap::radius(), DDTruncTubs::rIn(), DDTorus::rMax(), DDTorus::rMin(), makeMuonMisalignmentScenario::rot, DDBooleanSolid::rotation(), DDTruncTubs::rOut(), DDTorus::rTorus(), alignCSCRings::s, funct::sin(), DDBooleanSolid::solidA(), DDBooleanSolid::solidB(), mathSSE::sqrt(), DDTruncTubs::startPhi(), DDTorus::startPhi(), AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, create_public_lumi_plots::transform, DDBooleanSolid::translation(), groupFilesInBlocks::tt, x, DDPseudoTrap::x1(), DDPseudoTrap::x2(), DDExtrudedPolygon::xVec(), y, DDPseudoTrap::y1(), DDPseudoTrap::y2(), DDExtrudedPolygon::yVec(), z, DDTruncTubs::zHalf(), DDExtrudedPolygon::zscaleVec(), DDExtrudedPolygon::zVec(), DDExtrudedPolygon::zxVec(), and DDExtrudedPolygon::zyVec().

Referenced by createVolume().

 {
    LogDebug("TGeoMgrFromDdd::createShape") << "with name: " << iName << " and solid: " << iSolid;
 
    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 );
 
         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=" + pt.name().name());   
         }
 
         std::unique_ptr<TGeoShape> trap( new TGeoTrd2( pt.name().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( pt.name().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::unique_ptr<TGeoShape> left( createShape(boolSolid.solidA().name().fullname(),
                                boolSolid.solidA()) );
         std::unique_ptr<TGeoShape> right( createShape(boolSolid.solidB().name().fullname(),
                             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 = tt.name().name();
         
         // check the parameters
         if( rIn <= 0 || rOut <=0 || cutAtStart <=0 || cutAtDelta <= 0 )
         {
           std::string s = "TruncTubs " + std::string( tt.name().fullname()) + ": 0 <= rIn,cutAtStart,rOut,cutAtDelta,rOut violated!";
           throw cms::Exception( s );
         }
         if( rIn >= rOut )
         {
           std::string s = "TruncTubs " + std::string( tt.name().fullname()) + ": rIn<rOut violated!";
           throw cms::Exception(s);
         }
         if( startPhi != 0. )
         {
           std::string s= "TruncTubs " + std::string( tt.name().fullname()) + ": 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::unique_ptr<TGeoShape> left( createShape(boolSolid.solidA().name().fullname(),
                                boolSolid.solidA()) );
         std::unique_ptr<TGeoShape> right( createShape(boolSolid.solidB().name().fullname(),
                             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::unique_ptr<TGeoShape> left( createShape(boolSolid.solidA().name().fullname(),
                                boolSolid.solidA()) );
         std::unique_ptr<TGeoShape> right( createShape(boolSolid.solidB().name().fullname(),
                             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)
    {
       std::cerr <<"COULD NOT MAKE "<<iName<<" of a shape "<<iSolid<<std::endl;
    }
 
    LogDebug("TGeoMgrFromDdd::createShape") << "solid " << iName << " has been created.";
 
    return rSolid;
 }

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

private

Definition at line 667 of file TGeoMgrFromDdd.cc.

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

Referenced by produce().

 {
    TGeoVolume* v=nameToVolume_[iName];
    if (v == nullptr)
    {
       TGeoShape* solid     = createShape(iSolid.name().fullname(),
                                          iSolid);
       std::string mat_name = iMaterial.name().fullname();
       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;
 }

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

private

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

Definition at line 89 of file TGeoMgrFromDdd.cc.

References gather_cfg::cout, createVolume(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), mps_fire::i, info(), edm::ESHandleBase::isValid(), m_level, m_verbose, DDSolidShapesName::name(), nameToMaterial_, nameToMedium_, nameToShape_, nameToVolume_, DDCompactView::root(), and DDCompactView::walker().

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

 {
    using namespace edm;
 
    ESTransientHandle<DDCompactView> viewH;
    iRecord.getRecord<IdealGeometryRecord>().get(viewH);
 
    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");
    }
 
    std::cout << "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 = createVolume(info.first.name().fullname(),
                   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)
       {
      for(unsigned int i=0; i<parentStack.size();++i) {
         std::cout <<" ";
      }
      std::cout << info.first.name() <<" "<<info.second->copyno()<<" "
            << DDSolidShapesName::name(info.first.solid().shape())<<std::endl;
       }
 
       bool childAlreadyExists = (nullptr != nameToVolume_[info.first.name().fullname()]);
       TGeoVolume *child = createVolume(info.first.name().fullname(),
                        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

int TGeoMgrFromDdd::m_level

private

Definition at line 79 of file TGeoMgrFromDdd.h.

Referenced by produce().

std::string TGeoMgrFromDdd::m_TGeoName

private

Definition at line 81 of file TGeoMgrFromDdd.h.

std::string TGeoMgrFromDdd::m_TGeoTitle

private

Definition at line 82 of file TGeoMgrFromDdd.h.

bool TGeoMgrFromDdd::m_verbose

private

Definition at line 80 of file TGeoMgrFromDdd.h.

Referenced by produce().

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

private

Definition at line 86 of file TGeoMgrFromDdd.h.

Referenced by createMaterial(), and produce().

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

private

Definition at line 87 of file TGeoMgrFromDdd.h.

Referenced by createVolume(), and produce().

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

private

Definition at line 84 of file TGeoMgrFromDdd.h.

Referenced by createShape(), and produce().

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

private

Definition at line 85 of file TGeoMgrFromDdd.h.

Referenced by createVolume(), and produce().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation