---

DDPersToDDDFactory.cc

Go to the documentation of this file.

#include <DetectorDescription/PersistentDDDObjects/interface/DDPersToDDDFactory.h>
#include <CondFormats/IdealGeometryObjects/interface/PersistentDDDObjects.h>

#include <DetectorDescription/Base/interface/DDException.h>
#include <DetectorDescription/Core/interface/DDSolid.h>
#include <DetectorDescription/Core/interface/DDSolidShapes.h>
#include <DetectorDescription/Core/interface/DDPosPart.h>
#include <DetectorDescription/Core/interface/DDMaterial.h>
#include <DetectorDescription/Core/interface/DDRoot.h>
#include <DetectorDescription/Core/interface/DDSpecifics.h>

#include <iostream>
#include <vector>
#include <algorithm>

namespace std { } using namespace std;
  
DDSolid DDPersToDDDFactory::solid ( const PSolid* sol ) {
  return solid ( *sol );
}

DDMaterial DDPersToDDDFactory::material ( const PMaterial* mat ) {
  return material ( *mat );
}

DDRotation DDPersToDDDFactory::rotation ( const PRotation* rot ) {
  return rotation ( *rot );
}

DDLogicalPart DDPersToDDDFactory::logicalPart ( const PLogicalPart* lp ) {
  return logicalPart ( *lp );
}

void DDPersToDDDFactory::position ( const PPosPart*  posPart ) {
  position ( *posPart );
}

DDSolid DDPersToDDDFactory::solid ( const PSolid& sol ) {
  //  std::cout << "solid type = " << sol.pShapeType << std::endl;
  DDSolid mysol;
  //  std::cout << "about to set DDSolidShape s" << std::endl;
  DDSolidShape s = DDSolidShapesName::index(sol.pShapeType);
  //  std::cout << "about to enter the switch" << std::endl;
  //  std::cout << "DDSolidShape is..." << s << std::endl;
  switch (s) 
    {
    case ddbox:
    case ddtubs:
    case ddcons:
    case ddpseudotrap:
    case ddtrunctubs:
    case ddtrap:
    case ddpolyhedra_rz: 
    case ddpolyhedra_rrz:
    case ddpolycone_rz:
    case ddpolycone_rrz:
    case ddtorus:
      {
        mysol = DDSolid( DDName( (*pstrs)[sol.pName] ), s, sol.pPars );
        break;
      }
    case ddshapeless:
      mysol = DDSolidFactory::shapeless( DDName( (*pstrs)[sol.pName]) );
      break;
    case ddunion:
      {
        DDTranslation t;
        if ( sol.pPars.size() != 0 ) {
          t = DDTranslation( sol.pPars[0], sol.pPars[1], sol.pPars[2] );
        } else {
          t = DDTranslation( 0.0, 0.0, 0.0 );
        }
        
        mysol = DDSolidFactory::unionSolid( DDName( (*pstrs)[sol.pName])
                                            , DDSolid(DDName( (*pstrs)[sol.pSolid1]) )
                                            , DDSolid(DDName( (*pstrs)[sol.pSolid2]) )
                                            , t //DDTranslation(sol.pPars[0], sol.pPars[1], sol.pPars[2])
                                            , DDRotation(DDName( (*pstrs)[sol.pRotation]) )
                                            );
        break;
      }
    case ddsubtraction: 
      {
        //       std::cout << "got subtraction... make solid1 "; // << std::endl;
        //        DDSolid s1(DDName(sol.pSolid1));
        //        std::cout << s1 << std::endl << "make solid2 "; // << std::endl;
        //        DDSolid s2(DDName(sol.pSolid2));
        //        std::cout << s2 << std::endl << "make translation "; // << std::endl;
        //        std::cout << "size of pPars = " << sol.pPars.size() << std::endl;
        DDTranslation t;
        if ( sol.pPars.size() != 0 ) {
          t = DDTranslation( sol.pPars[0], sol.pPars[1], sol.pPars[2] );
        } else {
          t = DDTranslation( 0.0, 0.0, 0.0 );
        }
        //        std::cout << t << std::endl << "make rotation "; // << std::endl;
        //        DDRotation r(DDName(sol.pRotation));
        //        std::cout << r << std::endl << "about to make subtraction" << std::endl;
        mysol = DDSolidFactory::subtraction( DDName( (*pstrs)[sol.pName] )
                                             //, s1, s2, t, r );
                                             , DDSolid(DDName( (*pstrs)[sol.pSolid1] ))
                                             , DDSolid(DDName( (*pstrs)[sol.pSolid2] ))
                                             , t //DDTranslation(sol.pPars[0], sol.pPars[1], sol.pPars[2])
                                             , DDRotation(DDName( (*pstrs)[sol.pRotation] ))
                                             );
        break;
      }
    case ddintersection:
      {
        DDTranslation t;
        if ( sol.pPars.size() != 0 ) {
          t = DDTranslation( sol.pPars[0], sol.pPars[1], sol.pPars[2] );
        } else {
          t = DDTranslation( 0.0, 0.0, 0.0 );
        }
        
        mysol = DDSolidFactory::intersection( DDName( (*pstrs)[sol.pName] )
                                              , DDSolid(DDName( (*pstrs)[sol.pSolid1] ))
                                              , DDSolid(DDName( (*pstrs)[sol.pSolid2] ))
                                              , t //DDTranslation(sol.pPars[0], sol.pPars[1], sol.pPars[2])
                                              , DDRotation(DDName( (*pstrs)[sol.pRotation] ))
                                              );
        break;
      }
    case dd_not_init:
    default:
      throw DDException("DDSolid::DDSolid(DDName,DDSolidShape,vector<double>: wrong shape");   
    }
  //  std::cout << "solid : " << mysol << std::endl;
  return mysol;
}

DDMaterial DDPersToDDDFactory::material ( const PMaterial& mat ) {
 DDMaterial mymat;
 // std::cout << "Make a PersMaterial" << std::endl;
 mymat = DDMaterial( DDName( (*pstrs)[mat.pName] )
                     , mat.pZ
                     , mat.pA
                     , mat.pDensity );
 if ( mat.pNumberOfConstituents != 0 ) {
   for ( size_t constituent = 0; constituent < mat.pCN.size(); ++constituent ) {
     mymat.addMaterial( DDName( (*pstrs)[mat.pCN[constituent]]), mat.pCF[constituent] );
   }
 }
 // std::cout << "material " << mymat << std::endl;
 return mymat;
}

DDRotation DDPersToDDDFactory::rotation ( const PRotation& rot ) {
//   std::cout << "rotation named: " << rot.pName;
//   std::cout << "  theta -- phi " << std::endl;
//   std::cout << "x  " << rot.pThetaX/deg << ", " << rot.pPhiX/deg << std::endl;
//   std::cout << "y  " << rot.pThetaY/deg << ", " << rot.pPhiY/deg << std::endl;
//   std::cout << "z  " << rot.pThetaZ/deg << ", " << rot.pPhiZ/deg << std::endl;

  DDRotation defrot;
  //  std::cout << " reflection? 1=true " << rot.pReflection << std::endl;
  //  std::cout << "size of pStrings = " << (*pstrs).size() << std::endl;
  //  std::cout << "rotation name index = " << rot.pName << std::endl;
  //  std::cout << "so the name is pStrings[" << rot.pName << "] = " << (*pstrs)[rot.pName] << std::endl;
  if ( rot.pReflection == 1) {
    //    std::cout << "make reflection" << std::endl;
    DDRotation myrot = DDrotReflect ( DDName( (*pstrs)[rot.pName] )
                                      , rot.pThetaX, rot.pPhiX
                                      , rot.pThetaY, rot.pPhiY
                                      , rot.pThetaZ, rot.pPhiZ );
    return myrot;
  } else {
    //    std::cout << "make rotation" << std::endl;
    DDRotation myrot = DDrot ( DDName( (*pstrs)[rot.pName] )
                               , rot.pThetaX, rot.pPhiX
                               , rot.pThetaY, rot.pPhiY
                               , rot.pThetaZ, rot.pPhiZ );
    return myrot;
  }
  return defrot;
}

DDLogicalPart DDPersToDDDFactory::logicalPart ( const PLogicalPart& lp ) {
  std::string lpn = (*pstrs)[lp.pName];
  std::string pmn = (*pstrs)[lp.pMaterial];
  std::string psn = (*pstrs)[lp.pSolid];
  DDLogicalPart mylp = DDLogicalPart( DDName( lpn )
                                      , DDMaterial(DDName( pmn ))
                                      , DDSolid(DDName( psn )) );

//   std::cout << mylp.toString() << " " << mylp.solid().toString() << " "
//        << mylp.material().toString() << std::endl;

  return mylp;
}

void DDPersToDDDFactory::position ( const PPosPart&  posPart ) {
  DDpos( DDLogicalPart(DDName( (*pstrs)[posPart.pChildLP] ))
         , DDLogicalPart(DDName( (*pstrs)[posPart.pParentLP] ))
         , posPart.pCopyNo
         , DDTranslation (posPart.pX, posPart.pY, posPart.pZ)
         , DDRotation (DDName( (*pstrs)[posPart.pRotation] )));
}


void DDPersToDDDFactory::specPar ( const PSpecPar& specPar ) {

  // first, build DDValue and DDsvalues
  DDsvalues_type svt;

  size_t numPars = specPar.pValues.pNames.size();
  size_t currPar = 0;
  //  std::cout << " rebuilding specpar " << specPar.pName << " with " << numPars << " number of parameters." << std::endl;
  for ( ; currPar < numPars ; ++currPar ) {
    std::vector <DDValuePair> vvp;

    size_t currVal = specPar.pValues.pOffset[currPar].pOneOffset;
    size_t numVals = specPar.pValues.pOffset[currPar].pSize + currVal;
    //    std::cout << "numVals = " << numVals << " and currVal = " << currVal << std::endl;
    for ( ; currVal < numVals ; ++currVal ) {
      vvp.push_back(DDValuePair( (*pstrs)[specPar.pValues.pValuePairs[currVal].pStr], specPar.pValues.pValuePairs[currVal].pDbl));
    }
    
    DDValue val ( (*pstrs)[specPar.pValues.pNames[currPar]], vvp );
    val.setEvalState(specPar.pValues.pOffset[currPar].pIsEvaluated);
    svt.push_back(DDsvalues_Content_type(val,val));
  }
  std::sort(svt.begin(),svt.end());

  DDSpecifics ds( (*pstrs)[specPar.pName], specPar.pSpecSelections, svt, false );
  //  std::cout << ds << std::endl;

}

void DDPersToDDDFactory::setRoot (const std::string& rootName) {
  DDRootDef::instance().set(DDName(rootName));
}

---