#include <Specific.h>

Public Member Functions
std::pair< bool, DDExpandedView >	node () const
	gives the geometrical history of a fully specified PartSelector More...

const std::vector< DDPartSelection > &	selection () const

	Specific (const std::vector< std::string > &selections, const DDsvalues_type &specs, bool doRegex=true)

	Specific (const std::vector< DDPartSelection > &selections, const DDsvalues_type &specs)

const DDsvalues_type &	specifics () const

void	stream (std::ostream &) const

void	tokenize ()

void	updateLogicalPart (std::vector< std::pair< DDLogicalPart, std::pair< const DDPartSelection , const DDsvalues_type > > > &) const

	~Specific ()

Protected Member Functions
void	addSelectionLevel (std::vector< DDLogicalPart > &lpv, int copyno, ddselection_type st, std::vector< DDPartSelection > &selv)

void	createPartSelections (const std::string &selString)

Protected Attributes
bool	doRegex_

std::vector< DDPartSelection >	partSelections_

DDsvalues_type	specifics_

bool	valid_

Detailed Description

Definition at line 21 of file Specific.h.

Constructor & Destructor Documentation

DDI::Specific::Specific	(	const std::vector< std::string > &	selections,
		const DDsvalues_type &	specs,
		bool	doRegex = `true`
	)

Definition at line 19 of file Specific.cc.

References createPartSelections().

      : specifics_(specs), 
        partSelections_(0), 
        valid_(false),
        doRegex_(doRegex)            
    {
      for( const auto& it : selections ) {
        createPartSelections( it );
      }
    }

DDI::Specific::Specific	(	const std::vector< DDPartSelection > &	selections,
		const DDsvalues_type &	specs
	)

Definition at line 32 of file Specific.cc.

34 : specifics_(specs), partSelections_(selections), valid_(false), doRegex_(false)

35 { }

DDI::Specific::partSelections_

std::vector< DDPartSelection > partSelections_

Definition: Specific.h:50

DDI::Specific::valid_

bool valid_

Definition: Specific.h:51

DDI::Specific::specifics_

DDsvalues_type specifics_

Definition: Specific.h:49

DDI::Specific::doRegex_

bool doRegex_

Definition: Specific.h:52

SiPixelPhase1DigisV_cfi.specs

specs

Definition: SiPixelPhase1DigisV_cfi.py:13

DDI::Specific::~Specific ( )

inline

Definition at line 31 of file Specific.h.

References selection(), tokenize(), and updateLogicalPart().

31 { }

Member Function Documentation

void DDI::Specific::addSelectionLevel	(	std::vector< DDLogicalPart > &	lpv,
		int	copyno,
		ddselection_type	st,
		std::vector< DDPartSelection > &	selv
	)

protected

Definition at line 68 of file Specific.cc.

References mps_fire::result.

Referenced by createPartSelections(), and specifics().

    {
       if (selv.empty()) { // create one, no entry yet!
          selv.emplace_back(DDPartSelection());
       }
       typedef std::vector<DDLogicalPart>::size_type lpv_sizetype;
       typedef std::vector<DDPartSelection>::size_type ps_sizetype;
       ps_sizetype ps_sz = selv.size();
       lpv_sizetype lpv_sz = lpv.size();
       lpv_sizetype lpv_i = 0;
       std::vector<DDPartSelection> result;
       for (; lpv_i < lpv_sz; ++lpv_i) {
          std::vector<DDPartSelection>::const_iterator ps_it = selv.begin();
          for (; ps_it != selv.end(); ++ps_it) {
             result.emplace_back(*ps_it);
          }
       }
       ps_sizetype ps_i = 0;
       for(lpv_i=0; lpv_i < lpv_sz; ++lpv_i) {
          for(ps_i = ps_sz*lpv_i; ps_i < ps_sz*(lpv_i+1); ++ps_i) {
             result[ps_i].emplace_back(DDPartSelectionLevel(lpv[lpv_i],copyno,st));
          }
       }    
       selv = result;
    }               

void DDI::Specific::createPartSelections ( const std::string & selString )

protected

Definition at line 37 of file Specific.cc.

References addSelectionLevel(), DDIsValid(), DDTokenize2(), doRegex_, mps_alisetup::msg, partSelections_, AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by Specific(), and specifics().

    {      
       std::vector<DDPartSelRegExpLevel> regv;
       std::vector<DDPartSelection> temp;
       DDTokenize2(selString,regv);
       
       if (regv.empty()) throw cms::Exception("DDException")
               << "Could not evaluate the selection-std::string ->"
               << selString << "<-";
       
       std::pair<bool,std::string> res;
       for( const auto& it : regv ) {
          std::vector<DDLogicalPart> lpv;
          res = DDIsValid( it.ns_, it.nm_, lpv, doRegex_ );
          if (!res.first) {
             std::string msg("Could not process q-name of a DDLogicalPart, reason:\n"+res.second);
             msg+="\nSpecPar selection is:\n" + selString + "\n";
             //throw cms::Exception("DDException") << "Could not process q-name of a DDLogicalPart, reason:\n" << res.second;
             edm::LogError("Specific") << msg;
             break; //EXIT for loop
          }
          addSelectionLevel( lpv, it.copyno_, it.selectionType_, temp );
       }
       if ( res.first ) { // i.e. it wasn't "thrown" out of the loop
          partSelections_.reserve(temp.size() + partSelections_.size());
          for( const auto& iit : temp ) {
             partSelections_.emplace_back( iit );
          } 
       }
    }

std::pair< bool, DDExpandedView > DDI::Specific::node ( ) const

gives the geometrical history of a fully specified PartSelector

node() will only work, if

there is only one PartSelection std::string
the PartSelection std::string specifies exactly one full path concatenating always direct children including their copy-number and will return (true,const DDGeoHistory&) if the std::string matches an expanded-part in the ExpandedView, else it will return (false, xxx), whereas xxx is a history which is not valid.

Definition at line 148 of file Specific.cc.

References EnergyCorrector::c, DDExpandedView::copyno(), ddanyposp, ddchildposp, MillePedeFileConverter_cfg::e, DDExpandedView::firstChild(), DDExpandedView::logicalPart(), DDExpandedView::nextSibling(), partSelections_, and mps_fire::result.

Referenced by specifics().

    {
       DDCompactView c;
       DDExpandedView e(c);
       
       if (partSelections_.size() != 1) {
          edm::LogError("Specific") << " >> more or less than one part-selector, currently NOT SUPPORTED! <<" << std::endl;
          return std::make_pair(false,e);
       }
       const DDPartSelection & ps = partSelections_[0];
       
       DDPartSelection::const_iterator it = ps.begin();
       DDPartSelection::const_iterator ed = ps.end();
       if ( (it != ed) && ( it->selectionType_ != ddanyposp) ) {
          edm::LogError("Specific") << " >> part-selector must start with //Name[no] ! << " << std::endl;
          return std::make_pair(false,e);
       }
       ++it;
       for (; it != ps.end(); ++it) {
          if ( it->selectionType_ != ddchildposp ) {
             edm::LogError("Specific") << " >> part-selector must be a concatenation of direct children\n"
             << "   including their copy-number only, CURRENT LIMITATION! <<" << std::endl;
             return std::make_pair(false,e);     
          }  
       } 
       
       it = ps.begin();
       bool result = true;
       for (; it != ed; ++it) {
          while(result) {
             if( (it->copyno_ == e.copyno()) && (it->lp_ == e.logicalPart())) {
                break;
             }
             else {
                result = e.nextSibling();
             }
          }
          if ((ed-it)>1) {
             result = e.firstChild();  
          }  
       }
       return std::make_pair(result,e);
    }

const std::vector< DDPartSelection > & DDI::Specific::selection ( ) const

Definition at line 95 of file Specific.cc.

References partSelections_.

Referenced by Vispa.Plugins.ConfigEditor.CodeTableView.CodeTableView::keyPressEvent(), trackingPlots.Iteration::modules(), Vispa.Views.AbstractView.AbstractView::restoreSelection(), and ~Specific().

    {
       return partSelections_; 
    }  

const DDsvalues_type& DDI::Specific::specifics ( void ) const

inline

Definition at line 39 of file Specific.h.

References addSelectionLevel(), createPartSelections(), node(), specifics_, stream(), and AlCaHLTBitMon_QueryRunRegistry::string.

39 { return specifics_; }

DDI::Specific::specifics_

DDsvalues_type specifics_

Definition: Specific.h:49

void DDI::Specific::stream ( std::ostream & os ) const

Definition at line 100 of file Specific.cc.

References mps_fire::i, DDValue::isEvaluated(), DDValue::name(), partSelections_, alignCSCRings::s, DDValue::size(), specifics_, DDValue::strings(), and findQualityFiles::v.

Referenced by specifics().

    {
       os << " Size: " << specifics_.size() << std::endl;
       os << "\tSelections:" << std::endl;
       for( const auto& pit : partSelections_ ) {
          os << pit << std::endl;
       }
       for( const auto& vit : specifics_ ) {
          const DDValue & v = vit.second;
          os << "\tParameter name= \"" << v.name() << "\" " << std::endl;
          os << "\t\t Value pairs: " << std::endl;
          size_t s=v.size();
          size_t i=0;
          if ( v.isEvaluated() ) {
             for( ; i<s; ++i) {
                os << "\t\t\t\"" << v[i].first << "\"" << ", " << v[i].second << std::endl;
             }
          } else { // v is not evaluated
             for( const auto& i : v.strings()) {
                os << "\t\t\t\"" << i << "\"" << ", not evaluated" << std::endl;
             }
          }
       } 
    }

void DDI::Specific::tokenize ( )

Referenced by ~Specific().

void DDI::Specific::updateLogicalPart ( std::vector< std::pair< DDLogicalPart, std::pair< const DDPartSelection *, const DDsvalues_type * > > > & result ) const

Definition at line 125 of file Specific.cc.

References partSelections_, mps_fire::result, and specifics_.

Referenced by ~Specific().

    {
       if (!partSelections_.empty()) {
          const DDsvalues_type* sv = (&specifics_);
          for( const auto& it : partSelections_ ) {
             DDLogicalPart logp = it.back().lp_; 
             const DDPartSelection * ps = (&it);
             assert(ps); 
             assert(sv);
             std::pair<const DDPartSelection*,const DDsvalues_type*> pssv(ps,sv);
             result.emplace_back(std::make_pair(logp,pssv));
          }  
       }  
    }