/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/DetectorDescription/Core/src/DDFilteredView.cc

Go to the documentation of this file.

#include "DetectorDescription/Core/interface/DDFilteredView.h"
#include "DetectorDescription/Core/interface/DDCompactView.h"

// Message logger.
#include "FWCore/MessageLogger/interface/MessageLogger.h"

DDFilteredView::DDFilteredView(const DDCompactView & cpv)
 : epv_(cpv)
{
   parents_.push_back(epv_.geoHistory());
}


DDFilteredView::~DDFilteredView()
{ }


const DDLogicalPart & DDFilteredView::logicalPart() const
{
  return epv_.logicalPart();
}


void DDFilteredView::addFilter(const DDFilter & f, log_op op)
{
  criteria_.push_back(&f); 
  logOps_.push_back(op);
  //DCOUT('F',"DDQuery::addFilter(): log-op=" << op );
}

  
const DDTranslation & DDFilteredView::translation() const
{
   return epv_.translation();
}

         
const DDRotationMatrix & DDFilteredView::rotation() const                          
{
   return epv_.rotation();
}

   
const DDGeoHistory &  DDFilteredView::geoHistory() const
{
   return epv_.geoHistory();
}


std::vector<const DDsvalues_type * > DDFilteredView::specifics() const
{
  std::vector<const DDsvalues_type * > result; epv_.specificsV(result);
  return result;
}

void  DDFilteredView::specificsV(std::vector<const DDsvalues_type * > & result) const 
{
  epv_.specificsV(result);
}

void  DDFilteredView::mergedSpecificsV(DDsvalues_type & merged) const 
{
  epv_.mergedSpecificsV(merged);
}

DDsvalues_type DDFilteredView::mergedSpecifics() const
{
   DDsvalues_type merged;epv_.mergedSpecificsV(merged);
  return merged;
}


int DDFilteredView::copyno() const
{
  return epv_.copyno();
}


const DDGeoHistory & DDFilteredView::scope() const
{
  return epv_.scope();
}


bool DDFilteredView::setScope(const DDGeoHistory & hist)
{
  bool result = epv_.setScope(hist,0);
  if (result) {
    parents_.clear();
    parents_.push_back(hist);
  }  
  return result;
}  


void DDFilteredView::clearScope()
{
   epv_.clearScope();
   parents_.clear();
   parents_.push_back(epv_.geoHistory());
}


bool DDFilteredView::next()
{
   bool result = false;
   int i=0;
   //epv_.scope_.clear();
   //DCOUT('F', "DDFilteredView::next(): scope of ExpandedView = " << epv_.scope_ );
   while(epv_.next()) {
     //DCOUT('F', " node " << i << " " << epv_.logicalPart().ddname() );
     ++i;
     //DCOUT('F', "DDFilteredView::next() at " << epv_.geoHistory().back() );
     if ( filter() ) {
       result = true;
       //DCOUT('F', "DDFilteredView::next(): filter()==true at " << epv_.geoHistory() );
       break;
     }
   }
   //DCOUT('F', "DDFilteredView::next(): just iterated over " << i << " nodes."); 
   return result;
}


bool DDFilteredView::firstChild() 
{
   bool result = false;
   
   // save the current position
   DDGeoHistory savedPos = epv_.geoHistory();
           
   // save the current scope
   DDGeoHistory savedScope = epv_.scope_;
   int savedDepth = epv_.depth_;
   
   // set current node to be the scope
   epv_.scope_ = epv_.geoHistory();
   epv_.depth_ = 0;
   
   // search the subtree for the first matching node
   if (next()) { 
     result = true;
     epv_.scope_ = savedScope;
     epv_.depth_ = savedDepth;
   }
   else { // restore the starting point
     epv_.scope_ = savedScope;
     epv_.depth_ = savedDepth;
     epv_.goToHistory(savedPos);
   }
   
   if (result) {
     parents_.push_back(epv_.geoHistory());
   }
     
   return result;
}


bool DDFilteredView::nextSibling()
{
  //PRE:  the current node A is one matching the filter or the (scoped) root
  //POST: current node is A if no filter has matched, or B with matching filter
  //      B is the firstChild matching the filter in the subtrees of A's siblings
  bool result = false;
  DDGeoHistory savedPos = epv_.geoHistory();
  
  //DDGeoHistory::size_type level = parents_.back().size();
  
  bool flag = true;
  //bool shuffleParent = false;
  while (flag) {
    if (epv_.nextSibling()) {
      if ( filter() ) {
        result = true;
        break;
      }
      else if (firstChild()) {
        result = true;
        // firstChild increases parents!
        parents_.pop_back(); 
        break;
      }
    } // <-- epv_.nextSibling      
    else if (!epv_.parent()) {
      flag = false;
    }
    if (epv_.geoHistory().size() == parents_[parents_.size()-2].size()) {
      flag = false;
    }  
  }   
      
  if (!result)
    epv_.goToHistory(savedPos);
  else
    parents_.back() = epv_.geoHistory();
       
  return result;
}


bool DDFilteredView::parent()
{
   bool result = false;
 
   if (parents_.size()==1) {
     result = false;
   }
   else {
     parents_.pop_back();
     epv_.goToHistory(parents_.back());
     result = true;
   }  
   
   // =====> CHECK WHETHER THE FOLLOWING REMARKS STILL REPRESENT THE IMPLEMENTATION ABOVE <===   
   // case 1: we've reached the (scoped) root of the underlying expanded-view
   //         from the first child of the fitered-view; result must be true
   // case 2: we've reached a parent-node where the filter said 'yes'; 
   //         result must be true
   // case 3: we are already at the (scoped) root of the underlying expanded-view
   //         result must be false
      
   return result;
}


void DDFilteredView::reset()
{
  //while (epv_.parent())
  //  ;
  epv_.reset();
  parents_.clear();
  parents_.push_back(epv_.geoHistory());          
}


bool DDFilteredView::filter()
{
  bool result = true;
  //DCOUT('Q', "Filter: " << epv_.history_);
  criteria_type::const_iterator it = criteria_.begin();
  logops_type::const_iterator logOpIt = logOps_.begin();
  // loop over all user-supplied criteria (==filters)
  for (; it != criteria_.end(); ++it, ++logOpIt) {
    // avoid useless evaluations
    if ( (   result &&(*logOpIt)==OR ) ||
         ( (!result)&&(*logOpIt)==AND) ) continue; 
    
    bool locres = (*it)->accept(epv_);
    // need correction DCOUT('F', " Filter(" << criteria_.end()-it << ") accepted: " << epv_.geoHistory().back());
    
    // now do the logical-operations on the results encountered so far:
    if (*logOpIt==AND) { // AND
      result &= locres; 
    }
    else { // OR
      result |= locres;  
    }
  } // <-- loop over filters     
  return result;
}


DDFilteredView::nav_type DDFilteredView::navPos() const
{
  return epv_.navPos();
}


DDFilteredView::nav_type DDFilteredView::copyNumbers() const
{
  return epv_.copyNumbers();
}


bool DDFilteredView::goTo(const DDFilteredView::nav_type & n)
{
 // WARNING!!!!!!!!!!
 // NOT IMPLEMENTED!!!!!!!
 bool result(false);
 return result;
}


void DDFilteredView::print() {
  edm::LogInfo("DDFliteredView") << "FilteredView Status" << std::endl
       << "-------------------" << std::endl
       << "scope = " << epv_.scope_ << std::endl
       << "parents:" << std::endl;
  for (unsigned int i=0; i<parents_.size(); ++i)
    edm::LogInfo("DDFliteredView") << "  " << parents_[i] << std::endl;
    
}


const std::vector<DDGeoHistory> & DDFilteredView::history() const
{
  return parents_;
}