/data/refman/pasoursint/CMSSW_4_1_8_patch9/src/DetectorDescription/Core/src/DDCompactView.cc

Go to the documentation of this file.

#include "DetectorDescription/Core/interface/DDCompactView.h"
#include "DetectorDescription/Core/interface/DDLogicalPart.h"
#include "DetectorDescription/Core/interface/DDMaterial.h"
#include "DetectorDescription/Core/interface/DDSolid.h"
#include "DetectorDescription/Core/interface/DDRoot.h"
#include "DetectorDescription/Core/interface/DDName.h"
#include "DetectorDescription/Core/interface/DDAlgo.h"
#include "DetectorDescription/ExprAlgo/interface/AlgoPos.h"
#include "DetectorDescription/Base/interface/DDdebug.h"
#include "DetectorDescription/Base/interface/DDException.h"

#include "DetectorDescription/Core/interface/DDSpecifics.h"
#include "DetectorDescription/Base/interface/DDRotationMatrix.h"

#include "DetectorDescription/Core/src/Material.h"
#include "DetectorDescription/Core/src/Solid.h"
#include "DetectorDescription/Core/src/LogicalPart.h"
#include "DetectorDescription/Core/src/Specific.h"

#include <iostream>

//DDCompactViewmpl * DDCompactView::global_ = 0;

// 
DDCompactView::DDCompactView(const DDLogicalPart & rootnodedata)
  : rep_(new DDCompactViewImpl(rootnodedata))
{
  // 2010-01-27 I am leaving this here so that we are sure the global stores
  // are open when a new DDCompactView is being made.  Eventually I want to
  // get rid of the need for this somehow? think about it...
  DDMaterial::StoreT::instance().setReadOnly(false);
  DDSolid::StoreT::instance().setReadOnly(false);
  DDLogicalPart::StoreT::instance().setReadOnly(false);
  DDSpecifics::StoreT::instance().setReadOnly(false);
  DDRotation::StoreT::instance().setReadOnly(false);
}

DDCompactView::~DDCompactView() 
{  
  if (rep_ != 0) {
    delete rep_;
  }
}

const DDCompactView::graph_type & DDCompactView::graph() const 
{ 
  return rep_->graph(); 
}

DDCompactView::graph_type & DDCompactView::writeableGraph() 
{
  return const_cast<graph_type&>(rep_->graph());
}

const DDLogicalPart & DDCompactView::root() const
{ 
  return rep_->root(); 
} 


DDCompactView::walker_type DDCompactView::walker() const
{
  return rep_->walker();
}

    
double DDCompactView::weight(const DDLogicalPart & p) const
{
  return rep_->weight(p);
}  

void DDCompactView::algoPosPart(const DDLogicalPart & self,
                                const DDLogicalPart & parent,
                                DDAlgo & algo
                                ) {
  static int cnt_=0;
  ++cnt_;
  if (algo.rep().numRegistered() == 0) {
    std::string e;
    e = "DDalgoPosPart: algorithmic positioning\n";
    e += "\t[" + algo.name().ns() 
               + ":" 
               + algo.name().name() 
               + "] is not defined!\n";
    throw DDException(e);
  }
  
  LogDebug ("AlgoPos")  << "DDCompactView, algo=" << std::endl << algo << std::endl;
  int inner=0;
  do { 
    ++inner;
    DDRotationMatrix * rmp = new DDRotationMatrix(algo.rotation());
    DDRotation anonymRot = DDanonymousRot(rmp);
    DDTranslation tr(algo.translation());
    position(self, parent, algo.label(), tr, anonymRot); 
    algo.next();
  } 
  while(algo.go());

}

void DDCompactView::position (const DDLogicalPart & self, 
                              const DDLogicalPart & parent,
                              std::string copyno,
                              const DDTranslation & trans,
                              const DDRotation & rot,
                              const DDDivision * div)
{
  int cpno = atoi(copyno.c_str());
  position(self,parent,cpno,trans,rot, div);
}

void DDCompactView::position (const DDLogicalPart & self,
                              const DDLogicalPart & parent,
                              int copyno,
                              const DDTranslation & trans,
                              const DDRotation & rot,
                              const DDDivision * div)
{
  rep_->position( self, parent, copyno, trans, rot, div );
}


// >>---==========================<()>==========================---<<

// UNSTABLE STUFF below ...
void DDCompactView::setRoot(const DDLogicalPart & root)
{
  rep_->setRoot(root);
}  

void DDCompactView::swap( DDCompactView& repToSwap ) {
  rep_->swap ( *(repToSwap.rep_) );
}

DDCompactView::DDCompactView() : rep_(new DDCompactViewImpl) { }

void DDCompactView::lockdown() {
  // at this point we should have a valid store of DDObjects and we will move these
  // to the local storage area using swaps with the existing Singleton<Store...>'s
  // 2010-01-27 memory patch
  DDMaterial::StoreT::instance().swap(matStore_);
  DDSolid::StoreT::instance().swap(solidStore_);
  DDLogicalPart::StoreT::instance().swap(lpStore_);
  DDSpecifics::StoreT::instance().swap(specStore_);
  DDRotation::StoreT::instance().swap(rotStore_);

  // 2010-01-27 memory patch
  // not sure this will stay, but for now we want to explicitely lock the global stores.
  // lock the global stores.
  DDMaterial::StoreT::instance().setReadOnly(false);
  DDSolid::StoreT::instance().setReadOnly(false);
  DDLogicalPart::StoreT::instance().setReadOnly(false);
  DDSpecifics::StoreT::instance().setReadOnly(false);
  DDRotation::StoreT::instance().setReadOnly(false);

}