#include <Selections.h>

Public Types
typedef std::vector< Selection > ::iterator	iterator

Public Member Functions
iterator	begin ()

iterator	end ()

void	print ()

	Selections (const edm::ParameterSet &iConfig, edm::ConsumesCollector &&iC)

Private Attributes
std::map< std::string, Filter * >	filters_

edm::ParameterSet	filtersPSet_

edm::ParameterSet	selectionPSet_

std::vector< Selection >	selections_

Detailed Description

Definition at line 311 of file Selections.h.

Member Typedef Documentation

typedef std::vector<Selection>::iterator Selections::iterator

Definition at line 313 of file Selections.h.

Constructor & Destructor Documentation

Selections::Selections	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &&	iC
	)

inline

Definition at line 315 of file Selections.h.

References begin(), end(), Filter_cff::Filter, Selection< C, Selector, StoreContainer >::filters_, filters_, filtersPSet_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSetNames(), python.multivaluedict::map(), alignCSCRings::s, corrVsCorr::selection, selectionPSet_, selections_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                          :
     filtersPSet_(iConfig.getParameter<edm::ParameterSet>("filters")),
     selectionPSet_(iConfig.getParameter<edm::ParameterSet>("selections"))
   {
     //FIXME. what about nested filters
     // not so needed since we are explicitely spelling all modules
     //make all configured filters
     std::vector<std::string> filterNames;
     unsigned int nF=filtersPSet_.getParameterSetNames(filterNames);
     for (unsigned int iF=0;iF!=nF;iF++){
       edm::ParameterSet pset = filtersPSet_.getParameter<edm::ParameterSet>(filterNames[iF]);
       filters_.insert(std::make_pair(filterNames[iF],new Filter(filterNames[iF],pset, iC))); // this is the global pool of filters
     }
 
     //parse all configured selections
     std::vector<std::string> selectionNames;
     std::map<std::string, std::vector<std::string> > selectionFilters;
     unsigned int nS=selectionPSet_.getParameterSetNames(selectionNames);
     for (unsigned int iS=0;iS!=nS;iS++){
       edm::ParameterSet pset=selectionPSet_.getParameter<edm::ParameterSet>(selectionNames[iS]);
       // JR-2014 : the filters are not expanded here
       selections_.push_back(Selection(selectionNames[iS],pset));
       //      selections_.insert(std::make_pair(selectionNames[iS],Selection(selectionNames[iS],pset)));
       //keep track of list of filters for this selection for further dependency resolution
       selectionFilters[selectionNames[iS]]=pset.getParameter<std::vector<std::string> >("filterOrder");
     }
 
 
     //watch out of recursive dependency
     //    unsigned int nestedDepth=0; //FIXME not taken care of
 
     //resolving dependencies
     for (std::map<std::string, std::vector<std::string> >::iterator sIt= selectionFilters.begin();sIt!=selectionFilters.end();++sIt)
       {
     //parse the vector of filterNames
     for (std::vector<std::string>::iterator fOrS=sIt->second.begin();fOrS!=sIt->second.end();++fOrS)
       {
         if (filters_.find(*fOrS)==filters_.end())
           {
         //not a know filter names uncountered : either Selection of _OR_.
         if (fOrS->find("_OR_") != std::string::npos){
           filters_.insert(std::make_pair((*fOrS),new FilterOR((*fOrS),filters_)));
         }//_OR_ filter
         else{
           // look for a selection name
           std::map<std::string, std::vector<std::string> >::iterator s=selectionFilters.find(*fOrS);
           if (s==selectionFilters.end()){
             //error.
             if ((*fOrS)[0] != '!'){
               edm::LogError("SelectionHelper")<<"unresolved filter/selection name: "<<*fOrS;
             }
           }//not a Selection name.
           else{
             // JR-2014 : don't do anything here, and move on : in fact no, replace it to have the details in the histograming tool
             //remove the occurence
             std::vector<std::string>::iterator newLoc=sIt->second.erase(fOrS);
             //insert the list of filters corresponding to this selection in there
             sIt->second.insert(newLoc,s->second.begin(),s->second.end());
             //decrement selection iterator to come back to it
             sIt--;
             break;
           }//a Selection name
         }
           }//the name is not a simple filter name : either Selection of _OR_.
 
       }//loop over the strings in "filterOrder"
       }//loop over all defined Selection
 
     //finally, configure the Selections
     //loop the selections instanciated
     //    for (std::map<std::string, Selection>::iterator sIt=selections_.begin();sIt!=selections_.end();++sIt)
     //      const std::string & sName=sIt->first;
     //Selection & selection =sIt->second;
     for (std::vector<Selection>::iterator sIt=selections_.begin();sIt!=selections_.end();++sIt){
       const std::string & sName=sIt->name();
       Selection & selection =*sIt;
 
       //parse the vector of filterNames
       std::vector<std::string> & listOfFilters=selectionFilters[sName];
       for (std::vector<std::string>::iterator fIt=listOfFilters.begin();fIt!=listOfFilters.end();++fIt)
     {
       std::string fOsName = *fIt;
       bool inverted=false;
       if (fOsName[0]=='!'){
         inverted=true;
         fOsName = fOsName.substr(1);
       }
       std::map<std::string, Filter*>::iterator filterInstance=filters_.find(fOsName);
       if (filterInstance==filters_.end()){
         // JR-2014 include the selection here, directly !
         bool replaceBySelection=false;
         //find an existing selection that match that name
         for ( std::vector<Selection>::iterator sit=selections_.begin(); sit!= selections_.end() ; ++sit){
           if (fOsName == sit->name_){
         selection.filters_.push_back( SFilter(& (*sit), inverted));
         replaceBySelection=true;
           }
         }
         if (!replaceBySelection){
           //error
         edm::LogError("Selections")<<"cannot resolve: "<<fOsName;
         }
       }
       else{
         //actually increment the filter
         selection.filters_.push_back(SFilter(filterInstance->second,inverted));
       }
     }
     }
 
     for (iterator sIt = begin(); sIt!=end();++sIt)
       sIt->printDetailledPrintoutHeader();
 
   }