DDExpandedView.cc

Go to the documentation of this file.

#include "DetectorDescription/Core/interface/DDExpandedView.h"

#include <memory>
#include <ostream>

#include "DetectorDescription/Core/interface/DDComparator.h"
#include "DetectorDescription/Core/interface/DDLogicalPart.h"
#include "DetectorDescription/Core/interface/DDPosData.h"
#include "DetectorDescription/Core/interface/adjgraph.h"
#include "DetectorDescription/Core/interface/graphwalker.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "Math/GenVector/Cartesian3D.h"
#include "Math/GenVector/DisplacementVector3D.h"
#include "Math/GenVector/Rotation3D.h"

class DDPartSelection;

DDExpandedView::DDExpandedView( const DDCompactView & cpv )
  : walker_(0),
    w2_(cpv.graph(),cpv.root()),
    trans_( DDTranslation()),
    rot_( DDRotationMatrix()),
    depth_( 0 ),
    worldpos_( cpv.worldPosition())
{
  walker_ = &w2_;

  const DDPosData * pd((*walker_).current().second);
  if (!pd)
    pd = worldpos_;
  DDExpandedNode expn((*walker_).current().first,
                      pd,
              trans_,
              rot_,
              0);
  
  // starting point for position calculations, == root of expanded view
  history_.push_back(expn);                       
}

DDExpandedView::~DDExpandedView() { }  

const DDLogicalPart & DDExpandedView::logicalPart() const 
{ 
  return history_.back().logp_;
}


const DDTranslation & DDExpandedView::translation() const 
{ 
  return history_.back().trans_; 
}


const DDRotationMatrix & DDExpandedView::rotation() const 
{ 
  return history_.back().rot_; 
}


const DDGeoHistory & DDExpandedView::geoHistory() const 
{ 
  return history_; 
} 


int DDExpandedView::depth() const
{
  return depth_;
}


int DDExpandedView::copyno() const 
{ 
  return history_.back().copyno();
}

bool DDExpandedView::nextSibling() 
{
  bool result(false);
  if (scope_.size() && history_.back() == scope_.back()) {
   ; // no-next-sibling, if current node is the root of the scope!
  } 
  else {
    if ((*walker_).nextSibling()) {
      DDExpandedNode & expn(history_.back()); // back of history_ is always current node
      DDCompactView::walker_type::value_type curr = (*walker_).current();
      DDPosData const * posdOld = expn.posd_;
      expn.logp_=curr.first;
      expn.posd_=curr.second;
      
      DDGeoHistory::size_type hsize = history_.size();
      
      
      if (hsize>1) {
    const DDExpandedNode & expnBefore(history_[hsize-2]);
    
    // T = T1 + INV[R1] * T2
    expn.trans_  = expnBefore.trans_ + (expnBefore.rot_ * expn.posd_->trans_);
     
    // R = R1*INV[R2]   
    // VI in principle we can do this
    if ( !(expn.posd_->rot()==posdOld->rot()) ) {
      expn.rot_ = expnBefore.rot_ * expn.posd_->rot();//.inverse();
    }
      }
      else {
    expn.trans_ = expn.posd_->trans_;
    expn.rot_ = expn.posd_->rot();//.inverse();
      }   
      ++expn.siblingno_;
      result = true; 
    }
  }
  return result;
}
 
 
bool DDExpandedView::firstChild()
{
  bool result(false);
  bool depthNotReached(true);
  
  // Check for the depth within the scope ...
  if (depth_) {
    if ( (history_.size()-scope_.size())==depth_ ) {
      depthNotReached=false;
    }
  }
  if (depthNotReached) {
    if ((*walker_).firstChild()) {
      DDExpandedNode & expnBefore(history_.back());
      DDCompactView::walker_type::value_type curr = (*walker_).current();
 
      DDPosData * newPosd = curr.second;
    
          // T = ... (see nextSiblinig())
      DDTranslation newTrans = expnBefore.trans_ + expnBefore.rot_ * newPosd->trans_;
    
      // R = ... (see nextSibling())
      DDRotationMatrix newRot =  expnBefore.rot_ *  newPosd->rot();//.inverse();
    
      // create a new Expanded node and push it to the history ...
      DDExpandedNode expn(curr.first, curr.second,
                          newTrans, newRot, 0);
    
      history_.push_back(expn);         
      result = true;                     
    } // if firstChild 
  } // if depthNotReached
  return result;
} 


bool DDExpandedView::parent()
{
  bool result(false);
  bool scopeRoot(false);
  
  // check for a scope
  if (scope_.size()) {
    if (scope_.back() == history_.back()) { 
      // the current node is the root of the scope
      scopeRoot = true;
    }  
  }
  
  if (!scopeRoot) {
    if ((*walker_).parent()) {
      history_.pop_back();
      result = true;
    }
  }   
  
  return result;  
}

// same implementation as in GraphWalker !
bool DDExpandedView::next()
{
  bool res(false);
  if(firstChild()) 
    res=true;
  else if(nextSibling())
    res=true;
  else {
   while(parent()) {
     if(nextSibling()) {
       res=true;
       break;
     }  
   }
  }
  return res;
}


bool DDExpandedView::nextB()
{
   bool res(false);
   return res;  
}


void dump(const DDGeoHistory & history)
{
   edm::LogInfo("DDExpandedView")  << "--GeoHistory-Dump--[" << std::endl;
   int i=0;
   for( const auto& it : history ) {
     edm::LogInfo("DDExpandedView")  << " " << i << it.logicalPart() << std::endl;
     ++i;     
   }
   edm::LogInfo("DDExpandedView")  << "]---------" << std::endl;
}

std::vector< const DDsvalues_type *>  DDExpandedView::specifics() const
{
  // backward compatible
  std::vector<const DDsvalues_type * > result;
  specificsV(result);
  return result;
}

void
DDExpandedView::specificsV(std::vector<const DDsvalues_type * > & result) const
{
  const auto & specs = logicalPart().attachedSpecifics();
  if( specs.size())
  {
    result.reserve(specs.size());
    for( const auto& it : specs ) {
      // a part selection
      const DDPartSelection & psel = *(it.first);
      const DDGeoHistory & hist = geoHistory();
      
      if (DDCompareEqual(hist, psel)()) 
    result.push_back( it.second );
    }
  }  
}
                               
DDsvalues_type DDExpandedView::mergedSpecifics() const {
  DDsvalues_type merged;
  mergedSpecificsV(merged);
  return merged;
}

void DDExpandedView::mergedSpecificsV(DDsvalues_type & merged) const
{
  merged.clear();
  const auto& specs = logicalPart().attachedSpecifics();
  if (specs.empty()) return;
  const DDGeoHistory & hist = geoHistory();
  for( const auto& it : specs ) {
    if (DDCompareEqual(hist, *it.first)())
      merge(merged,*it.second);
  }
}

const DDGeoHistory & DDExpandedView::scope() const
{
   return scope_;
}   

void DDExpandedView::clearScope()
{
  scope_.clear();
  depth_=0;
}

void DDExpandedView::reset()
{
   clearScope();
   while(parent()) 
     ;
}


bool DDExpandedView::setScope(const DDGeoHistory & sc, int depth)
{
  bool result(false);
  
  DDGeoHistory buf = scope_; // save current scope
  scope_.clear(); // sets scope to global (full) scope

  while (parent()) ; // move up to the root of the expanded-view
  
  if (descend(sc)) { // try to move down the given scope-history ...
    scope_ = sc;
    depth_ = depth;
    result = true;
  }  
  else {
    scope_ = buf;
  }
  
  return result;  
}


bool DDExpandedView::goToHistory(const DDGeoHistory & pos)
{
  bool result = true;
  int tempD = depth_;
  DDGeoHistory tempScope = scope_;
  reset();
  DDGeoHistory::size_type s = pos.size();
  for( DDGeoHistory::size_type j=1; j<s; ++j) {
    if (! firstChild()) {
      result = false;
      break;
    }  
    int i=0;
    for (; i<pos[j].siblingno(); ++i) {
      if (! nextSibling()) {
    result = false;
      } 
    }
  }
  
  if (!result) {
    reset();
    setScope(tempScope, tempD);
  } 
  else {
    scope_ = tempScope;
    depth_ = tempD;
  }

  return result;
}

bool DDExpandedView::descend(const DDGeoHistory & sc) 
{
  DDGeoHistory::size_type mxx = sc.size();
  DDGeoHistory::size_type cur = 0;
  bool result(false);
  
  /* algo: compare currerent node in expanded-view with current-node in sc
           if matching:
         (A)go to first child in expanded-view, go one level deeper in sc
         iterate over all children in expanded-view until one of them
         matches the current node in sc. 
         if no one matches, return false
         else continue at (A)
       else return false
  */       
  const DDExpandedNode & curNode = history_.back();
  
  if (sc.size()) {
    if (curNode==sc[cur]) {
      bool res(false);
      while(cur+1 < mxx && firstChild()) {
        ++cur;
        if (!(history_.back()==sc[cur])) {
      while(nextSibling()) {
        if (history_.back()==sc[cur]) {
          res=true;
          break;
        }  
      }
    }  
    else {
      res=true;
    }
    if (res==false) 
      break;  
      }
      result = res;
    }     
  }
  return result; 
}


bool DDExpandedView::goTo(const nav_type & newpos) {
  return goTo(&newpos.front(),newpos.size());

}

bool DDExpandedView::goTo(NavRange newpos) {
  return goTo(newpos.first,newpos.second);
}

bool DDExpandedView::goTo(int const * newpos, size_t sz)
{
  bool result(false);
  
  // save the current position
  DDGeoHistory savedPos = history_;
   
  // reset to root node 
  //FIXME: reset to root of scope!!
  reset();
  
  // try to navigate down to the newpos
  for (size_t i = 1; i < sz; ++i) {
    result = firstChild();
    if (result) {
      int pos = newpos[i];
      for(int k=0; k<pos; ++k) {
        result = nextSibling();
      }
    }
    else {
      break;
    }   
  }
  
  if (!result) {
    goToHistory(savedPos);
  }
  return result;
}

DDExpandedView::nav_type DDExpandedView::navPos() const
{
  DDGeoHistory::size_type i=0;
  DDGeoHistory::size_type j=history_.size();
  nav_type pos(j);  
  
  for (;i<j;++i)
    pos[i] = history_[i].siblingno();
    
  return pos;   
}

DDExpandedView::nav_type DDExpandedView::copyNumbers() const
{
  DDGeoHistory::size_type it = 0;
  DDGeoHistory::size_type sz = history_.size();
  nav_type result(sz);
  
  for (; it < sz; ++it) {
    result[it] = history_[it].copyno();
  }
  return result;
}

std::string printNavType(int const * n, size_t sz){
  std::ostringstream oss;
  oss << '(' ;
  for (int const * it=n; it != n+sz; ++it) {
    oss << *it << ',';
  }
  oss << ')';
  return oss.str();
}