DDLogicalPart.cc

Go to the documentation of this file.

#include "DetectorDescription/Core/interface/DDLogicalPart.h"
#include "DetectorDescription/Core/src/LogicalPart.h"
#include "DetectorDescription/Base/interface/DDdebug.h"
#include <ostream>

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

void
DD_NC( const DDName & n )
{
  std::vector<DDName> & ns = LPNAMES::instance()[n.name()];
  typedef std::vector<DDName>::iterator IT;
  bool alreadyIn( false );
  for( IT p = ns.begin(); p != ns.end(); ++p )
  {
    if( p->ns() == n.ns())
    {
      alreadyIn = true;
      break;
    } 
  }
  if( !alreadyIn )
  {
    ns.push_back( n );
  }  
}
  
std::ostream & 
operator<<( std::ostream & os, const DDLogicalPart & part )
{
  DDBase<DDName,DDI::LogicalPart*>::def_type defined( part.isDefined());
  if( defined.first )
  {
    os << *(defined.first) << " ";
    if( defined.second )
    {
      part.rep().stream( os ); 
    }
    else
    {
      os << "* logicalpart not defined * ";  
    }
  }  
  else
  {
    os << "* logicalpart not declared * ";  
  }  
  return os;
}

// =================================================================================

// now inlined... 

DDLogicalPart::DDLogicalPart( const DDName & name )
  : DDBase<DDName, DDI::LogicalPart*>()
{ 
  prep_ = StoreT::instance().create( name );
  DD_NC( name );
}

DDLogicalPart::DDLogicalPart(const DDName & ddname,
                             const DDMaterial & material,
                             const DDSolid & solid,
                     DDEnums::Category cat) 
 : DDBase<DDName,DDI::LogicalPart*>() 
{ 
   DCOUT('C', "create LogicalPart ddname=" << ddname << " mat=" << material.name() << " sol=" << solid.name());
   prep_ = StoreT::instance().create(ddname, new DDI::LogicalPart(material,solid,cat));
   DD_NC(ddname);
}


// private!
/*
DDLogicalPart::DDLogicalPart(DDRedirect<DDLogicalPartImpl>* p, bool dummy)
 : DDMultiRegistered<DDLogicalPartImpl>(p,true)
{ }
*/

DDEnums::Category DDLogicalPart::category() const
{ 
  return rep().category(); 
}


const DDMaterial & DDLogicalPart::material() const 
{
  return rep().material();
}  


const DDSolid & DDLogicalPart::solid() const
{
  return rep().solid();
}


/* 
   The weight must be calculated by using the method DDCompactView::weight().
   For the weight calculation the full subtree of children is expanded. As a 
   usefull side-effect the weight of all LogicalParts of the children is calculated
   as well.
   This method will return 0, if the weight has not yet been calculated 
   using the DDCompactView, otherwise the weight of the component and all
   its sub-components.
   \todo In future DDLogicalPart::weight() will be sufficient for weight calculations
   \todo make the method 'const'
*/  
double & DDLogicalPart::weight() 
{
  return rep().weight();
}    


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


DDsvalues_type DDLogicalPart::mergedSpecifics() const
{
  DDsvalues_type  result;
  rep().mergedSpecificsV(result);
  return result;
}  

// for internal use only
void DDLogicalPart::addSpecifics(const std::pair<DDPartSelection*,DDsvalues_type*> & s)
{
   DCOUT('S', "lp=" << name());
   rep().addSpecifics(s);
}
void DDLogicalPart::removeSpecifics(const std::pair<DDPartSelection*,DDsvalues_type*> & s)
{
   rep().removeSpecifics(s);
}
bool DDLogicalPart::hasDDValue(const DDValue & v) const
{
  return rep().hasDDValue(v);
}

// finds out whether a DDLogicalPart is registered & already valid (initialized)
// - returns (true,""), if so; result holds the corresponding DDLogicalPart
// - returns (false,"some status message") otherwise
// - nm corresponds to a regular expression, but will be anchored ( ^regexp$ )
// - ns corresponds to a regular expression, but will be anchored ( ^regexp$ )
#include <regex.h>
#include <set>

namespace
{
  struct Regex
  {
    explicit Regex( const std::string & s )
      : m_ok( false ),
    me( s )
      {
    size_t p = me.find(".");
    m_ok = p != std::string::npos;
    if( m_ok )
    {
      if( p > 0 )
      {
        m_range.first = me.substr( 0, p );
        m_range.second = m_range.first + "{"; // '{' is 'z'+1
      }
      me = "^" + me + "$";
      regcomp( &m_regex, me.c_str(), 0 );
    }
      } 

    ~Regex( void ) { if( m_ok ) regfree( &m_regex ); }

    bool empty( void ) const { return me.empty(); }

    bool notRegex( void ) const { return !m_ok; }

    const std::string & value( void ) const { return me;}

    bool match( const std::string & s ) const {
      if( m_ok )
    return !regexec( &m_regex, s.c_str(), 0, 0, 0 );
      else
    return me == s;
    }

    const std::pair< std::string, std::string> & range( void ) const { return m_range; }
  private:
    bool m_ok;
    regex_t m_regex;
    std::string me;
    // range of me in a collating sequence
    std::pair<std::string, std::string> m_range;
  };
}

std::pair<bool, std::string>
DDIsValid( const std::string & ns, const std::string & nm, std::vector<DDLogicalPart> & result, bool doRegex )
{
  if( !doRegex )
  {
    DDName ddnm( nm, ns );
    result.push_back( DDLogicalPart( ddnm ));
    return std::make_pair( true, "" );
  }
  std::string status;
  Regex aRegex( nm );
  Regex aNsRegex( ns );
  bool emptyNs = aNsRegex.empty();
  
  // THIS IS THE SLOW PART: I have to compare every namespace & name of every
  // logical part with a regex-comparison .... a linear search always through the
  // full range of logical parts!!!!
  /*
    Algorithm description:
    x. empty nm and ns argument of method means: use all matching regex ^.*$
    a. iterate over all logical part names, match against regex for names
    b. iterate over all namespaces of names found in a & match against regex for namespaces   
  */
  LPNAMES::value_type::const_iterator bn(LPNAMES::instance().begin()),
                                      ed(LPNAMES::instance().end());
  typedef std::vector< LPNAMES::value_type::const_iterator> Candidates;
  Candidates candidates;
  if ( aRegex.notRegex() ) {
    LPNAMES::value_type::const_iterator it = LPNAMES::instance().find(aRegex.value());
    if (it!=ed) candidates.push_back(it);
  }
  else {
    if ( !aRegex.range().first.empty()) {
      bn =  LPNAMES::instance().lower_bound(aRegex.range().first);
      ed =  LPNAMES::instance().upper_bound(aRegex.range().second);
    }
    for (LPNAMES::value_type::const_iterator it=bn; it != ed; ++it)
      if(aRegex.match(it->first)) candidates.push_back(it);
  }
  for (int i=0; i<int(candidates.size()); ++i) {
    LPNAMES::value_type::const_iterator it = candidates[i];
    //if (doit)  edm::LogInfo("DDLogicalPart") << "rgx: " << aName << ' ' << it->first << ' ' << doit << std::endl;
    std::vector<DDName>::size_type sz = it->second.size(); // no of 'compatible' namespaces
    if ( emptyNs && (sz==1) ) { // accept all logical parts in all the namespaces
      result.push_back(it->second[0]);
      //std::vector<DDName>::const_iterator nsIt(it->second.begin()), nsEd(it->second.end());
      //for(; nsIt != nsEd; ++nsIt) {
      //   result.push_back(DDLogicalPart(*nsIt));
      //   edm::LogInfo("DDLogicalPart") << "DDD-WARNING: multiple namespaces match (in SpecPars PartSelector): " << *nsIt << std::endl;
      //}
    }
    else if ( !emptyNs ) { // only accept matching namespaces
      std::vector<DDName>::const_iterator nsit(it->second.begin()), nsed(it->second.end());
      for (; nsit !=nsed; ++nsit) {
    //edm::LogInfo("DDLogicalPart") << "comparing " << aNs << " with " << *nsit << std::endl;
    bool another_doit = aNsRegex.match(nsit->ns());
    if ( another_doit ) {
      //temp.push_back(std::make_pair(it->first,*nsit));
      result.push_back(DDLogicalPart(*nsit));
    }
      }
    }
    else { // emtpyNs and sz>1 -> error, too ambigous
      std::string message = "DDLogicalPart-name \"" + it->first +"\" matching regex \""
    + nm + "\" has been found at least in following namespaces:\n";
      std::vector<DDName>::const_iterator vit = it->second.begin();
      for(; vit != it->second.end(); ++vit) {
    message += vit->ns();
    message += " "; 
      } 
    message += "\nQualify the name with a regexp for the namespace, i.e \".*:name-regexp\" !";
    return std::make_pair(false,message);        
    }
  }
  bool flag=true;    
  std::string message;
  
  // check whether the found logical-parts are also defined (i.e. have material, solid ...)
  if (result.size()) {
    std::vector<DDLogicalPart>::const_iterator lpit(result.begin()), lped(result.end());
    for (; lpit != lped; ++lpit) { 
      // std::cout << "VI- " << std::string(lpit->name()) << std::endl;
      if (!lpit->isDefined().second) {
         message = message + "LogicalPart " + lpit->name().fullname() + " not (yet) defined!\n";
     flag = false;
      }
    }
  }
  else {
    flag = false;
    message = "No regex-match for namespace=" + ns + "  name=" + nm + "\n";
  }

  return std::make_pair(flag,message);
}

const std::vector< std::pair<DDPartSelection*,DDsvalues_type*> > & 
DDLogicalPart::attachedSpecifics( void ) const
{
  return rep().attachedSpecifics();
}