---

DDDToPersFactory.cc

Go to the documentation of this file.

#include <DetectorDescription/PersistentDDDObjects/interface/DDDToPersFactory.h>

#include <DetectorDescription/Core/interface/DDSolid.h>
#include <DetectorDescription/Core/interface/DDMaterial.h>

#include <DetectorDescription/Core/interface/DDSpecifics.h>
#include <DetectorDescription/Core/interface/DDPartSelection.h>

#include <sstream>
//#include <iostream>

PSolid* DDDToPersFactory::solid ( const DDSolid& solid ) {
  //  std::cout << solid.name() << std::endl;
  switch (solid.shape()) 
    {
    case ddunion:
    case ddsubtraction:
    case ddintersection: 
      {      
        DDBooleanSolid boolSolid(solid);
        // if translation is == identity there are no parameters.
        // if there is no rotation the name will be ":"
        std::string rotName = boolSolid.rotation().toString();
        if (rotName == ":") {
          rotName = "generatedForDB:IDENTITYDB";
        }
        return new PSolid( pstrs(boolSolid.toString())
                           , boolSolid.parameters()
                           , boolSolid.shape()
                           , pstrs(boolSolid.solidA().toString())
                           , pstrs(boolSolid.solidB().toString())
                           , pstrs(rotName) );
        break;
      }
    case ddreflected:
      { 
        DDReflectionSolid ref(solid);
        return new PSolid( pstrs(ref.unreflected().toString()), solid.parameters()
                           , solid.shape(), pstrs(""), pstrs(""), pstrs(""), true);
        break;
      }
    case ddbox:
    case ddtubs:
    case ddtrap:
    case ddcons:
    case ddpolycone_rz:
    case ddpolyhedra_rz:
    case ddpolycone_rrz:
    case ddpolyhedra_rrz:
    case ddpseudotrap:
    case ddtrunctubs:
    case ddshapeless:
    case ddtorus:
      return new PSolid( pstrs(solid.toString()), solid.parameters()
                         , solid.shape(), pstrs(""), pstrs(""), pstrs("") );
      break;
      
    case dd_not_init:
    default:
      throw DDException("DDDToPersFactory::solid(...) either not inited or no such solid.");
      break;
    }
  return 0;
}
  
PMaterial* DDDToPersFactory::material ( const DDMaterial& material ) {
  //  std::cout << "got here!" << std::endl;
  PMaterial* temp = new PMaterial( pstrs(material.toString()), material.density()
                                   , material.z(), material.a() );
  int noc = material.noOfConstituents();
  int j=0;
  for (; j<noc; ++j) {
    temp->addConstituent ( pstrs(material.constituent(j).first.toString())
                          , material.constituent(j).second );
      //    DCOUT('y', "  write-const-material=" << m.constituent(j).first.name());
      //      os << ' ';
      //      nameout(os,m.constituent(j).first.name());
      //      os << ' ' << m.constituent(j).second;
    }
    //    os << std::endl;

  return temp;
}

PRotation* DDDToPersFactory::rotation ( DDRotation& rotation ) {
  double tol = 1.0e-3; // Geant4 compatible
  DD3Vector x,y,z; 
  rotation.matrix()->GetComponents(x,y,z); 
  double check = (x.Cross(y)).Dot(z); // in case of a LEFT-handed orthogonal system 
  // this must be -1
  bool reflection((1.-check)>tol);
  std::string rotName=rotation.toString();
//   DDRotation rotn(DDName("IDENTITYDB","generatedForDB"));
//   if ( rotName == ":" ) {
//     // build a name somehow this only happens once and IS the identity!
//     std::cout << "DDDToPersFactory::rotation( ... ) with no name!" << std::endl;
//   std::cout << "rotation named: " << rotName;
//   std::cout << "          theta -------------- phi " << std::endl;
//   std::cout << "x  " << (rotation.matrix()->thetaX())/deg << ", " << (rotation.matrix()->phiX())/deg << std::endl;
//   std::cout << "y  " << (rotation.matrix()->thetaY())/deg << ", " << (rotation.matrix()->phiY())/deg << std::endl;
//   std::cout << "z  " << (rotation.matrix()->thetaZ())/deg << ", " << (rotation.matrix()->phiZ())/deg << std::endl;
     //     rotName = rotn.toString();
//   } else {
//     //    std::cout << "Rotation name: " << rotName << std::endl;
//   }
//  std::cout << "okay, about to return a PRotation..." << std::endl;
  return new PRotation( pstrs(rotName)
                        ,  x.theta(), x.phi()
                        ,  y.theta(), y.phi()
                        ,  z.theta(), z.phi()
                        , reflection );
}

PLogicalPart* DDDToPersFactory::logicalPart ( const DDLogicalPart& lp ) {
  return new PLogicalPart( pstrs(lp.toString())
                           , pstrs(lp.solid().toString())
                           , pstrs(lp.material().toString()) );
}

// What is bad about this implementation is that the factory 
// actually needs to know about the default Identity matrix :-(.
PPosPart* DDDToPersFactory::position ( const DDLogicalPart& parent
                                       , const DDLogicalPart& child
                                       , DDPosData* edgeToChild 
                                       , PIdealGeometry& geom
                                       , int& rotNameSeed ) {
  std::string rotName = edgeToChild->rot_.toString();
  DDRotationMatrix myIDENT;
  if ( *(edgeToChild->rot_.matrix()) == myIDENT ) {
    rotName = "generatedForDB:IDENTITYDB";
    //    std::cout << "USING " << rotName << " for " << parent << " to " << child << std::endl;
//   }  else if ( rotName != ":" ) {
//     DDRotation rotn( DDName(edgeToChild->rot_.name().name(), edgeToChild->rot_.name().ns()) );
//     if ( rotn.isValid() ) {
//       //      rotName = rotn.toString();
//       // rotName STAYS AS IS!
//     } else {
//       // MIKE: if I got no ELSE then get rid of this whole thing and ONLY keep the
//       // next else as else if ( rotName == ":" );
//     }
  } else if ( rotName == ":" ) {
      std::ostringstream namestr;
      namestr << "rotName" << rotNameSeed;
      ++rotNameSeed;
      rotName = namestr.str();
      DDRotationMatrix* dmr = new DDRotationMatrix( *edgeToChild->rot_.matrix() );
      DDRotation frot = DDrot ( DDName ( rotName, "generatedForDB" ), dmr );
      PRotation* pr;
//       std::cout << "generated... " << rotName << std::endl;
//       std::cout << frot << std::endl;
//       std::cout << "done displaying frot" << std::endl;
      pr = rotation( frot );
      geom.pRotations.push_back( *pr );
      rotName = frot.toString();
  }
//   std::cout << parent.toString() << " " << child.toString() << " " << rotName << std::endl;
//   std::cout << "about to write edgeToChild..." << std::endl;
//   std::cout << edgeToChild->translation().x() << std::endl;
//   std::cout << edgeToChild->translation().y() << std::endl;
//   std::cout << edgeToChild->translation().z() << std::endl;
//   std::cout << edgeToChild->copyno_ << std::endl;
//   std::cout << "done writing edgeToChild..." << std::endl;
  return new PPosPart( pstrs(parent.toString())
                       , pstrs(child.toString())
                       , pstrs(rotName)
                       , edgeToChild->translation().x()
                       , edgeToChild->translation().y()
                       , edgeToChild->translation().z()
                       , edgeToChild->copyno_
                       );
}


PSpecPar* DDDToPersFactory::specpar ( const DDSpecifics& sp ) {

  //  std::cout << "Entering  DDDToPersFactory::specpar " << sp.toString() << std::endl;
  PSpecPar* psp = new PSpecPar();
  psp->pName = pstrs(sp.toString());
  
  std::vector<DDPartSelection>::const_iterator sit(sp.selection().begin()), sed(sp.selection().end());
  
  // ========... copy all the selection strings out as strings by using the DDPartSelection's ostream function...
  for (; sit != sed; ++sit) {
    std::ostringstream selStringStream;
    selStringStream << *sit;
    psp->pSpecSelections.push_back ( selStringStream.str() );
    //    std::cout << "selection " << selStringStream.str() << std::endl;
  }
  // =========  ... and iterate over all DDValues...
  //  std::cout << "About to iterate over DDValues " << std::endl;
  DDsvalues_type::const_iterator vit(sp.specifics().begin()), ved(sp.specifics().end());
  for (; vit != ved; ++vit) {
    const DDValue & v = vit->second;
    //    std::cout << " make entry with name " << v.name();
    psp->newSpecParEntry ( pstrs(v.name()), v.isEvaluated() );
    size_t s=v.size();
    //    std::cout << " and size " << v.size() << std::endl;
    size_t i=0;
    // ============  ... and copy all actual values with the same name
    const std::vector<std::string>& strvec = v.strings();
    if ( v.isEvaluated() ) {
      for (; i<s; ++i) {
        psp->addToCurrentSpecPar ( pstrs(strvec[i]), v[i] );
      }
    } else {
      for (; i<s; ++i ) {
        psp->addToCurrentSpecPar ( pstrs(strvec[i]) );
      }
    }
    
    //std::cout << sp.toString() << " variable name " << v.name() << " set evaluated to 0 (false) " << std::endl;
  }
  return psp;
}

---