/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/DetectorDescription/Core/interface/DDCompactView.h

Go to the documentation of this file.

#ifndef DDCompactView_h
#define DDCompactView_h

#include <vector>

//#include <memory>

#include "DetectorDescription/Base/interface/Ptr.h"

#include "DetectorDescription/Core/interface/DDAlgo.h"
#include "DetectorDescription/Core/interface/DDCompactViewImpl.h"
#include "DetectorDescription/Core/interface/graphwalker.h"


class DDPartSelector;
class DDPhysicalPart;
namespace DDI {
  class Material;
  class Solid;
  class LogicalPart;
  class Specific;
}


//MEC: these comments are kept from original... Will we ever do this? don't think so.
//FIXME: DDCompactView: check for proper acyclic directed graph structure!!
//FIXME:
//FIXME:         X          [A-X] ... LogicalPart
//FIXME:        / \             | ... PosPart (directed parten to child)
//FIXME:       A   A
//FIXME:       |   | 
//FIXME:       B   C      
//FIXME:
//FIXME:    THIS IS NOT ALLOWED, but currently can be specified using DDL ....
//FIXME:

//typedef TreeNode<DDPhysicalPart,int> expnode_t;
//typedef graph<DDLogicalPart,DDPosData*> graph_type; //:typedef Graph<DDLogicalPart,DDPosData*> graph_type;


class DDCompactView
{
 
public:
  typedef std::vector<DDLogicalPart> logchild_type;
  
  typedef std::vector< std::pair<DDLogicalPart,DDPosData*> > poschildren_type;
  
  typedef std::pair<DDLogicalPart,DDPosData*> pos_type;
  
  //:typedef GraphWalker<DDLogicalPart,DDPosData*> walker_type;
  typedef graphwalker<DDLogicalPart,DDPosData*> walker_type;
  
  //:typedef walker_type::value_type value_type;
  

  typedef ::graph<DDLogicalPart,DDPosData*> graph_type;
    
  explicit DDCompactView();
  
  explicit DDCompactView(const DDLogicalPart & rootnodedata);
  
  ~DDCompactView();
  
  const graph_type & graph() const;

  const DDLogicalPart & root() const;

  double weight(const DDLogicalPart & p) const;

  void algoPosPart(const DDLogicalPart & self,
                   const DDLogicalPart & parent,
                   DDAlgo & algo
                   );
  
  void position (const DDLogicalPart & self,
                 const DDLogicalPart & parent,
                 std::string copyno,
                 const DDTranslation & trans,
                 const DDRotation & rot,
                 const DDDivision * div = NULL);
  
  void position (const DDLogicalPart & self,
                 const DDLogicalPart & parent,
                 int copyno,
                 const DDTranslation & trans,
                 const DDRotation & rot,
                 const DDDivision * div = NULL);
  
  // ************************************************************************
  // UNSTABLE STUFF below! DON'T USE!
  // ************************************************************************
  
  void setRoot(const DDLogicalPart & root);

  walker_type walker() const;

  // ---------------------------------------------------------------
  // +++ DDCore INTERNAL USE ONLY ++++++++++++++++++++++++++++++++++
    
  // to modify the structure! DDCore internal!
  graph_type & writeableGraph();

  void swap( DDCompactView& );

  void lockdown();
  
 protected:
  DDCompactViewImpl* rep_;

 private:
    // 2010-01-27 memory patch
    // for copying and protecting DD Store's after parsing is complete.
    DDI::Store<DDName, DDI::Material*> matStore_;
    DDI::Store<DDName, DDI::Solid*> solidStore_;
    DDI::Store<DDName, DDI::LogicalPart*> lpStore_;
    DDI::Store<DDName, DDI::Specific*> specStore_;
    DDI::Store<DDName, DDRotationMatrix*> rotStore_;    

};

typedef DDCompactView::walker_type walker_type;
#endif