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

Public Member Functions
TGeoManager *	getGeoManager ()

void	postBeginRun (const edm::Run &, const edm::EventSetup &)

void	postEndRun (const edm::Run &, const edm::EventSetup &)

	TGeoFromDddService (const edm::ParameterSet &, edm::ActivityRegistry &)

virtual	~TGeoFromDddService ()

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 TGeoFromDddService &	operator= (const TGeoFromDddService &)=delete

	TGeoFromDddService (const TGeoFromDddService &)=delete

Private Attributes
const edm::EventSetup *	m_eventSetup

TGeoManager *	m_geoManager

int	m_level

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_

Detailed Description

Description: [one line class summary]

Usage: <usage>

Definition at line 48 of file TGeoFromDddService.h.

Constructor & Destructor Documentation

TGeoFromDddService::TGeoFromDddService	(	const edm::ParameterSet &	pset,
		edm::ActivityRegistry &	ar
	)

Definition at line 59 of file TGeoFromDddService.cc.

References postBeginRun(), postEndRun(), edm::ActivityRegistry::watchPostBeginRun(), and edm::ActivityRegistry::watchPostEndRun().

                                                                                            :
    m_level      (pset.getUntrackedParameter<int> ("level", 10)),
    m_verbose    (pset.getUntrackedParameter<bool>("verbose",false)),
    m_eventSetup (nullptr),
    m_geoManager (nullptr)
 {
    ar.watchPostBeginRun(this, &TGeoFromDddService::postBeginRun);
    ar.watchPostEndRun  (this, &TGeoFromDddService::postEndRun);
 }

TGeoFromDddService::~TGeoFromDddService ( )

virtual

Definition at line 69 of file TGeoFromDddService.cc.

References m_geoManager.

 {
    if (m_geoManager)
    {
       delete m_geoManager;
    }
 }

TGeoFromDddService::TGeoFromDddService ( const TGeoFromDddService & )

privatedelete

Member Function Documentation

TGeoManager * TGeoFromDddService::createManager ( int level )

private

Definition at line 152 of file TGeoFromDddService.cc.

References gather_cfg::cout, createVolume(), math::GraphWalker< N, E >::current(), edm::EventSetup::get(), DDCompactView::graph(), mps_fire::i, info(), edm::ESHandleBase::isValid(), m_eventSetup, m_verbose, DDSolidShapesName::name(), nameToMaterial_, nameToMedium_, nameToShape_, nameToVolume_, and DDCompactView::root().

Referenced by getGeoManager().

 {
    using namespace edm;
 
    ESTransientHandle<DDCompactView> viewH;
    m_eventSetup->get<IdealGeometryRecord>().get(viewH);
 
    if ( ! viewH.isValid() )
    {
       return nullptr;
    }
 
    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" << std::endl;
    auto walker = math::GraphWalker<DDLogicalPart, DDPosData*>( viewH->graph(), viewH->root());
    auto info = walker.current();
 
    // The top most item is actually the volume holding both the
    // geometry AND the magnetic field volumes!
    walker.firstChild();
 
    TGeoVolume *top = createVolume(info.first.name().fullname(),
                   info.first.solid(),
                                   info.first.material());
    if (top == nullptr)
    {
       
       return nullptr;
    }
 
    geo_mgr->SetTopVolume(top);
    // ROOT chokes unless colors are assigned
    top->SetVisibility(kFALSE);
    top->SetLineColor(kBlue);
 
    std::vector<TGeoVolume*> parentStack;
    parentStack.push_back(top);
 
    if( ! walker.firstChild() ) {
       return nullptr;
    }
 
    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 || 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 geo_mgr;
 }

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

private

Definition at line 579 of file TGeoFromDddService.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 * TGeoFromDddService::createShape	(	const std::string &	iName,
		const DDSolid &	iSolid
	)

private

Definition at line 284 of file TGeoFromDddService.cc.

References DDPseudoTrap::atMinusZ(), MessageLogger_cfi::cerr, popcon2dropbox::copy(), edmIntegrityCheck::d, ddbox, ddcons, ddcuttubs, ddextrudedpolygon, ddintersection, ddpolycone_rrz, ddpolyhedra_rrz, ddpseudotrap, ddsubtraction, ddtrap, ddtubs, ddunion, delta, Exception, DDName::fullname(), h, DDPseudoTrap::halfZ(), mps_fire::i, DDRotation::matrix(), DDName::name(), DDBase< N, C >::name(), nameToShape_, DDSolid::parameters(), EnergyCorrector::pt, alignCSCRings::r, DDPseudoTrap::radius(), DDBooleanSolid::rotation(), DDSolid::shape(), DDBooleanSolid::solidA(), DDBooleanSolid::solidB(), mathSSE::sqrt(), groupFilesInBlocks::temp, create_public_lumi_plots::transform, DDBooleanSolid::translation(), x, DDPseudoTrap::x1(), DDPseudoTrap::x2(), DDExtrudedPolygon::xVec(), y, DDPseudoTrap::y1(), DDPseudoTrap::y2(), DDExtrudedPolygon::yVec(), z, DDExtrudedPolygon::zscaleVec(), DDExtrudedPolygon::zVec(), DDExtrudedPolygon::zxVec(), and DDExtrudedPolygon::zyVec().

Referenced by createVolume().

 {
    TGeoShape* rSolid= nameToShape_[iName];
    if (rSolid == nullptr)
    {
       const std::vector<double>& params = iSolid.parameters();
       //      std::cout <<"  shape "<<iSolid<<std::endl;
       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
         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);
         assert(pt.radius() < 0);
         double x=0;
         double r = fabs(pt.radius());
         if( pt.atMinusZ()) {
            x=pt.x1();
         } else {
            x=pt.x2();
         }
         double openingAngle = 2.0*asin(x/r);
         double h=pt.y1()<pt.y2()? pt.y2() :pt.y1();
         h+=h/20.;
         double displacement=0;
         double startPhi = 0;
         double delta = sqrt((r+x)*(r-x));
         if(pt.atMinusZ()) {
            displacement=-pt.halfZ() - delta;
            startPhi = 270.-openingAngle/deg/2.0;
         }else {
            displacement = pt.halfZ() + delta;
            startPhi = 90. - openingAngle/deg/2.;
         }
         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.,
                                r/cm,
                                h/cm,
                                startPhi,
                                openingAngle) );
         TGeoSubtraction* sub = new TGeoSubtraction(trap.release(),
                                tubs.release(),
                                createPlacement(s_rot,
                                        DDTranslation(0.,
                                              0.,
                                              displacement)));
         rSolid = new TGeoCompositeShape(iName.c_str(),
                         sub);
         
         
         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(),
                               gGeoIdentity,
                               createPlacement(
                                                                           boolSolid.rotation().matrix(),
                                                                           boolSolid.translation()));
            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(),
                         gGeoIdentity,
                         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(),
                                   gGeoIdentity,
                                   createPlacement(
                                                                               boolSolid.rotation().matrix(),
                                                                               boolSolid.translation()));
            rSolid = new TGeoCompositeShape(iName.c_str(),
                            boolS);
         }
         break;
      }
      default:
         break;
       }
       nameToShape_[iName]=rSolid;
    }
    if (rSolid == nullptr)
    {
       std::cerr <<"COULD NOT MAKE "<<iName<<std::endl;
    }
    return rSolid;
 }

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

private

Definition at line 550 of file TGeoFromDddService.cc.

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

Referenced by createManager().

 {
    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;
 }

TGeoManager * TGeoFromDddService::getGeoManager ( )

Definition at line 104 of file TGeoFromDddService.cc.

References createManager(), allElectronIsolations_cfi::elements, m_eventSetup, m_geoManager, m_level, alignCSCRings::r, and lumiQTWidget::t.

 {
    if (m_geoManager == nullptr)
    {
       if (m_eventSetup == nullptr)
          edm::LogError("TGeoFromDddService") << "getGeoManager() -- EventSetup not present.\n";
       else
       {
          m_geoManager = createManager(m_level);
          if (m_geoManager == nullptr)
             edm::LogError("TGeoFromDddService") << "getGeoManager() -- creation failed.\n";
       }
    }
    gGeoManager = m_geoManager;
    return m_geoManager;
 }

const TGeoFromDddService& TGeoFromDddService::operator= ( const TGeoFromDddService & )

privatedelete

void TGeoFromDddService::postBeginRun	(	const edm::Run &	,
		const edm::EventSetup &	es
	)

Definition at line 82 of file TGeoFromDddService.cc.

References m_eventSetup.

Referenced by TGeoFromDddService().

 {
    printf("TGeoFromDddService::postBeginRun\n");
 
    m_eventSetup = &es;
 }

void TGeoFromDddService::postEndRun	(	const edm::Run &	,
		const edm::EventSetup &
	)

Definition at line 89 of file TGeoFromDddService.cc.

References m_eventSetup.

Referenced by TGeoFromDddService().

 {
    printf("TGeoFromDddService::postEndRun\n");
 
    // Construction of geometry fails miserably on second attempt ...
    /*
    if (m_geoManager)
    {
       delete m_geoManager;
       m_geoManager = 0;
    }
    */
    m_eventSetup = nullptr;
 }