TrigConf::HLTTEUtils Class Reference

HLTUtils is renamed in r22 to HLTTEUtils. More...

#include <HLTUtils.h>

Collaboration diagram for TrigConf::HLTTEUtils:

Static Public Member Functions
static std::vector< unsigned int >	allTEsProducedInLevel (const std::string &level, const HLTChainList &chainList, const HLTSequenceList &sequenceList)
	returns list of TEids which can be poduced at given level (L2 or EF) in currecnt configuration
static std::vector< std::string >	explicitChainTEs (const HLTChain &ch)
	returns list of TEids which are specified by Chain signatures
static std::vector< std::string >	implicitChainTEs (const HLTChain &ch, const HLTSequenceList &sequenceList)
	returns list of TEids which are specified by Chain signatures and which are needed by this signatures
static std::set< std::string >	inputTEs (const std::set< std::string > &TEs, const TrigConf::HLTSequenceList &sequenceList)
	returns set of input TEs for given set of TEs
static std::set< std::string >	allTEsProducedInL2Chain (const TrigConf::HLTChain &chain, const TrigConf::HLTSequenceList &sequenceList)
static std::set< std::string >	allTEsProducedInEFChain (const TrigConf::HLTChain &chain, const TrigConf::HLTSequenceList &sequenceList, const std::set< std::string > &l2tes)
static std::set< std::string >	allTEsProducedInL2 (const TrigConf::HLTFrame &frame)
static std::set< std::string >	allTEsProducedInEF (const TrigConf::HLTFrame &frame, std::set< std::string > *l2tes=0)
static std::set< std::string >	allTEsProduced (const TrigConf::HLTFrame &frame)
static std::string	ChainCondenseDisplay (const HLTChain &chain, const HLTFrame &frame)
static std::vector< std::string >	splitGroups (const std::string &s)
static HLTSequence *	buildSequence (const std::string &desc)
static void	mergeHLTChainList (TrigConf::HLTFrame &frame)
static void	mergeHLTChainList2 (TrigConf::HLTFrame &frame)
static void	mergeL2EFPrescales (TrigConf::HLTChain *hltchain, const TrigConf::HLTPrescale &l2ps, const TrigConf::HLTPrescale &efps)

Detailed Description

HLTUtils is renamed in r22 to HLTTEUtils.

The hashing functionality remains in HLTUtils, which moves to the standalone HLTUtils package

Definition at line 26 of file TrigConfHLTData/TrigConfHLTData/HLTUtils.h.

Member Function Documentation

allTEsProduced()

std::set< std::string > TrigConf::HLTTEUtils::allTEsProduced ( const TrigConf::HLTFrame & frame )

static

Definition at line 211 of file TrigConfHLTData/Root/HLTUtils.cxx.

{
   using std::set; using std::string; using std::vector;
 
   set<string> tes = allTEsProducedInL2( frame );
   set<string> eftes = allTEsProducedInEF( frame, &tes );
 
   std::copy(eftes.begin(),eftes.end(),
             std::inserter(tes,tes.begin()));
   return tes;
}

allTEsProducedInEF()

std::set< std::string > TrigConf::HLTTEUtils::allTEsProducedInEF ( const TrigConf::HLTFrame & frame, std::set< std::string > * l2tes = 0 )

static

Definition at line 191 of file TrigConfHLTData/Root/HLTUtils.cxx.

{
   const HLTChainList& chainList = frame.getHLTChainList();
   const HLTSequenceList& sequenceList = frame.getHLTSequenceList();
 
   set<string> level2TEs = l2tes?*l2tes:allTEsProducedInL2(frame);
 
   set<string> eftes;
   for( HLTChain* chain : chainList ) {
      if ( chain->level() == "L2" ) continue;
      set<string> tes = allTEsProducedInEFChain( *chain, sequenceList, level2TEs);
      copy(tes.begin(), tes.end(), std::inserter(eftes,eftes.begin()));
   }
   return eftes;
}

allTEsProducedInEFChain()

std::set< std::string > TrigConf::HLTTEUtils::allTEsProducedInEFChain ( const TrigConf::HLTChain & chain, const TrigConf::HLTSequenceList & sequenceList, const std::set< std::string > & l2tes )

static

Definition at line 297 of file TrigConfHLTData/Root/HLTUtils.cxx.

{
   using std::set; using std::string; using std::vector;
 
   set<string> eftes;
   // explicitly produced TEs
   const vector< HLTSignature * >& sigVec = chain.signatureList();
   for ( vector< HLTSignature * >::const_iterator sig = sigVec.begin(); sig != sigVec.end(); ++sig ) {
      const vector< HLTTriggerElement * >& teVec = (*sig)->outputTEs();
      for ( vector< HLTTriggerElement * >::const_iterator te = teVec.begin(); te != teVec.end(); ++te)
         eftes.insert((*te)->name());
   }
 
   // get the input TEs
   set<string> inputTEs;
   for(set<string>::iterator outTEIt = eftes.begin(); outTEIt != eftes.end(); ++outTEIt) {
      TrigConf::HLTSequence* seq = sequenceList.getSequence(*outTEIt);
      if(seq==0) {
         std::stringstream str;
         str << "TE " << *outTEIt << " is not produced by any sequence " << std::endl;
         throw std::runtime_error(str.str());
      }
      seq->setEF();
      for(vector<HLTTriggerElement*>::const_iterator teIt = seq->inputTEs().begin(); teIt != seq->inputTEs().end(); ++teIt)
         inputTEs.insert((*teIt)->name());
   }
 
   // still to check
   set<string> check;
   std::set_difference(inputTEs.begin(),inputTEs.end(), eftes.begin(), eftes.end(), std::inserter(check,check.begin()));
 
   for(const string& te : check)
      recursivelyFindOutputTEs( te, sequenceList, eftes, 3, &l2tes );
 
   return eftes;
}

allTEsProducedInL2()

std::set< std::string > TrigConf::HLTTEUtils::allTEsProducedInL2 ( const TrigConf::HLTFrame & frame )

static

Definition at line 174 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                                              {
 
   const HLTChainList& chainList = frame.getHLTChainList();
   const HLTSequenceList& sequenceList = frame.getHLTSequenceList();
 
   set<string> l2tes;
   for( HLTChain* chain : chainList ) {
      if ( chain->level() == "EF" ) continue;
      set<string> tes = allTEsProducedInL2Chain( *chain, sequenceList);
      copy(tes.begin(), tes.end(), std::inserter(l2tes,l2tes.begin()));
   }
   return l2tes;
}

allTEsProducedInL2Chain()

std::set< std::string > TrigConf::HLTTEUtils::allTEsProducedInL2Chain ( const TrigConf::HLTChain & chain, const TrigConf::HLTSequenceList & sequenceList )

static

Definition at line 254 of file TrigConfHLTData/Root/HLTUtils.cxx.

{
   using std::set; using std::string; using std::vector;
 
   set<string> l2tes;
   // explicitly produced TEs
   const vector< HLTSignature * >& sigVec = chain.signatureList();
   for ( vector< HLTSignature * >::const_iterator sig = sigVec.begin(); sig != sigVec.end(); ++sig ) {
      const vector< HLTTriggerElement * >& teVec = (*sig)->outputTEs();
      for ( vector< HLTTriggerElement * >::const_iterator te = teVec.begin(); te != teVec.end(); ++te)
         l2tes.insert((*te)->name());
   }
 
   // get the input TEs
   set<string> inputTEs;
   for(set<string>::iterator outTEIt = l2tes.begin(); outTEIt != l2tes.end(); ++outTEIt) {
      TrigConf::HLTSequence* seq = sequenceList.getSequence(*outTEIt);
      if(seq==0) {
         std::stringstream str;
         str << "TE " << *outTEIt << " is not produced by any sequence " << std::endl;
         throw std::runtime_error(str.str());
      }
      seq->setL2();
      for(vector<HLTTriggerElement*>::const_iterator teIt = seq->inputTEs().begin(); teIt != seq->inputTEs().end(); ++teIt)
         inputTEs.insert((*teIt)->name());
   }
 
   // still to check
   set<string> check;
   std::set_difference(inputTEs.begin(),inputTEs.end(), l2tes.begin(),l2tes.end(), std::inserter(check,check.begin()));
 
   for(set<string>::iterator teIt = check.begin(); teIt != check.end(); ++teIt)
      recursivelyFindOutputTEs( *teIt, sequenceList, l2tes, 2 );
 
   return l2tes;
}

allTEsProducedInLevel()

std::vector< unsigned int > HLTTEUtils::allTEsProducedInLevel ( const std::string & level, const HLTChainList & chainList, const HLTSequenceList & sequenceList )

static

returns list of TEids which can be poduced at given level (L2 or EF) in currecnt configuration

Warning

this method is dooing quite extensive menu inspection so it should not be executed to often ...

Parameters

level	L2 or EF name of trigger level
chainsList	list of configuration chains
sequenceList	list of configuration sequences

Returns

list of TE ids which according to the given configuration will be produced at level

Definition at line 115 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                                                        {
   
 
   set<unsigned int> outTEs;
   for( HLTChain* ch : chainList) {
      if ( ch->level() != level ) continue;
      for( HLTSignature* sig : ch->signatureList() ) {
         for( HLTTriggerElement* te : sig->outputTEs() )
            outTEs.insert( te->hashId() );
      }
   }
   // we have now big list of TEs mentioned in chains ... what with this which are not mentioned
   // but are executed because recursion in sequences
   std::vector<unsigned int> newTEs;
   for( unsigned int teId : outTEs ) 
      recursivelyFindInputTEs(teId, sequenceList, newTEs);
   copy(newTEs.begin(), newTEs.end(),inserter(outTEs,outTEs.begin()));
 
   // now turn into vector and order (unnecessary) but I don't want to break the interface
   std::vector<unsigned int> tes;
   copy(outTEs.begin(), outTEs.end(), inserter(tes,tes.begin()));
   sort(tes.begin(), tes.end());
   return tes;
}

buildSequence()

TrigConf::HLTSequence * TrigConf::HLTTEUtils::buildSequence ( const std::string & desc )

static

Definition at line 442 of file TrigConfHLTData/Root/HLTUtils.cxx.

{
   // builds a sequence from a string "inputTE1,inputTE2,outputTE", (can be just "outputTE")
   std::vector<std::string> tes = TrigConf::split(desc,",");
   
   vector<TrigConf::HLTTriggerElement*> input;
   for(std::vector<std::string>::iterator teit = tes.begin(); teit!=tes.end(); ++teit) {
      input.push_back(new TrigConf::HLTTriggerElement(0,*teit));
   }
   TrigConf::HLTTriggerElement* outte = input.back(); input.pop_back();
 
   TrigConf::HLTSequence* seq = new TrigConf::HLTSequence( input, outte, vector<string>());
 
   return seq;
}

ChainCondenseDisplay()

std::string TrigConf::HLTTEUtils::ChainCondenseDisplay ( const HLTChain & chain, const HLTFrame & frame )

static

Definition at line 341 of file TrigConfHLTData/Root/HLTUtils.cxx.

{
   using std::string; using std::set; using std::vector; using TrigConf::HLTTriggerElement;
   using TrigConf::HLTSignature; using TrigConf::HLTSequenceList;
 
   const HLTSequenceList& sequenceList = frame.getHLTSequenceList();
 
   std::string teCat("");
 
   set<string> writtenOutput;
   set<string> neededInput;
  
   unsigned int currentSigPos = 1;
 
   const vector<HLTSignature*> & signatures = chain.signatureList();
   vector<HLTSignature*>::const_iterator sigIt = signatures.begin();
   for(; sigIt!=signatures.end(); ++sigIt) {
      unsigned int sigCounter = (*sigIt)->signature_counter();
      while(sigCounter>currentSigPos) {
         teCat +=";"; // separate signature by ';'
         currentSigPos++;
      }
      const vector<HLTTriggerElement*> & outputTEs = (*sigIt)->outputTEs();
      vector<HLTTriggerElement*>::const_iterator teIt = outputTEs.begin();
      for(;teIt!=outputTEs.end();++teIt) {
         if(teIt!=outputTEs.begin()) teCat +=","; // separate sequences by ','
         const std::string& outTEName((*teIt)->name());
         const TrigConf::HLTSequence* seq = sequenceList.getSequence(outTEName);
         if(seq==0) {
            std::stringstream str;
            str << "Chain " << chain.chain_name() << " at step " << sigCounter
                << " requires TE " << outTEName << ", which is not produced by any sequence " << std::endl;
            throw std::runtime_error(str.str());
         }
         teCat += seq->concise();
 
         // store info about input and output TE's
         for(vector<HLTTriggerElement*>::const_iterator teIt = seq->inputTEs().begin(); teIt != seq->inputTEs().end(); ++teIt)
            neededInput.insert((*teIt)->name());
         writtenOutput.insert(seq->outputTE()->name());
      }
   }
 
   teCat = "|" + teCat;
 
   set<string> stillToWrite;
   std::set_difference(neededInput.begin(),neededInput.end(),
                       writtenOutput.begin(),writtenOutput.end(),
                       std::inserter(stillToWrite,stillToWrite.begin()));
 
   set<string> allStillToWrite(stillToWrite);
   int ilevel = (chain.level()=="L2")?2:3;
   for( const string& te : stillToWrite)
      recursivelyFindOutputTEsWithLevelFromSequence( te, sequenceList, allStillToWrite, ilevel );
   //this is unused if the in-loop usage is commented 
   for(set<string>::iterator teIt = allStillToWrite.begin(); teIt != allStillToWrite.end(); ++teIt) {
      const std::string& outTEName(*teIt);
      const TrigConf::HLTSequence* seq = sequenceList.getSequence(outTEName);
      if(seq==0) continue;
      teCat = seq->concise() + teCat;
   }
   return teCat;
}

explicitChainTEs()

vector< string > HLTTEUtils::explicitChainTEs ( const HLTChain & ch )

static

returns list of TEids which are specified by Chain signatures

Definition at line 144 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                               {
   vector<string> tes;
   for( HLTSignature* sig : ch.signatureList() ) {
      for( HLTTriggerElement* te : sig->outputTEs() )
         tes.push_back( te->name() );
   } 
   sort(tes.begin(), tes.end());
   std::vector<std::string>::iterator l = unique(tes.begin(), tes.end());
   tes.erase(l, tes.end());
   return tes;
}

implicitChainTEs()

std::vector< std::string > HLTTEUtils::implicitChainTEs ( const HLTChain & ch, const HLTSequenceList & sequenceList )

static

returns list of TEids which are specified by Chain signatures and which are needed by this signatures

Definition at line 158 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                                                                    {
   vector<string> tes = explicitChainTEs(ch);
 
   vector<string> newTes;
   for(const string& teId : tes )
      recursivelyFindInputTEs(teId, sequenceList, newTes);
  
   sort(tes.begin(), tes.end());
   vector<string>::iterator l = unique(tes.begin(), tes.end());
   tes.erase(l, tes.end());
   return tes;
}

inputTEs()

std::set< std::string > TrigConf::HLTTEUtils::inputTEs ( const std::set< std::string > & TEs, const TrigConf::HLTSequenceList & sequenceList )

static

returns set of input TEs for given set of TEs

Definition at line 230 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                                                           {
 
   using std::set; using std::string;
 
   // get the input TEs
   set<string> inputTEs;
   for(set<string>::iterator te = TEs.begin(); te != TEs.end(); ++te) {
      const TrigConf::HLTSequence* seq = sequenceList.getSequence(*te);
      if(seq==0) {
         std::stringstream str;
         str << "TE " << *te << " is not produced by any sequence " << std::endl;
         throw std::runtime_error(str.str());
      }
      for(vector<HLTTriggerElement*>::const_iterator teIt = seq->inputTEs().begin(); teIt != seq->inputTEs().end(); ++teIt)
         inputTEs.insert((*teIt)->name());
   }
   return inputTEs;
}

mergeHLTChainList()

void TrigConf::HLTTEUtils::mergeHLTChainList ( TrigConf::HLTFrame & frame )

static

Definition at line 460 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                                           {
 
   if(! frame.mergedHLT()) return;
  
   vector<HLTChain*>       tmpL2chains; 
   vector<HLTChain*>       tmpEFchains; 
   for( TrigConf::HLTChain* aChain : frame.theHLTChainList() ){
      if  (aChain->level() == "L2"){
         tmpL2chains.push_back( aChain ); //add in the tmp list
      }
      else if  (aChain->level() == "EF"){
         tmpEFchains.push_back( aChain ); //add in the tmp list
      }
   }
   //delete the current chainlist content
   frame.theHLTChainList().clear();
 
   // for (  vector<HLTChain*>::iterator aChain = frame.getHLTChainList().begin(); aChain != frame.getHLTChainList().end(); ) {
   //   if  ((*aChain)->level() == "L2"){
   //     tmpL2chains.push_back( *aChain ); //add in the tmp list
   //     frame.getHLTChainList().chains().erase(aChain); // erase L2 chains pointers
   //   }
   //   else aChain++; //iterate if not erase
   // }
 
 
   for (  vector<HLTChain*>::iterator cEF = tmpEFchains.begin(); cEF != tmpEFchains.end(); ++cEF ) {
      //  for (  vector<HLTChain*>::iterator cEF = frame.getHLTChainList().begin(); cEF != frame.getHLTChainList().end(); ++cEF ) {
      // iterator of the signature list
      std::vector<TrigConf::HLTSignature*>::iterator it = (*cEF)->signatureList().begin();       
      string cname = (*cEF)->chain_name();
      if ( size_t index = ((*cEF)->chain_name().find("EF_")) != std::string::npos ){
         cname.replace(index-1, 3, "HLT_");// why index must be scaled by 1 ?
         (*cEF)->set_chain_name(cname);
      }
      (*cEF)->set_level("HLT");
      (*cEF)->set_EB_after_step(0);//in case EF chain is not seeded by any L2 chain
      for (  vector<HLTChain*>::iterator cL2 = tmpL2chains.begin(); cL2 != tmpL2chains.end(); ++cL2 ) {
         if ((*cL2)->chain_name() == (*cEF)->lower_chain_name()){
            // insert the L2 signatures:
            (*cEF)->signatureList().insert (it,(*cL2)->signatureList().begin(),(*cL2)->signatureList().end()); // add the L2 signatures, before EF   
            // update the EF signature counters
            for (unsigned int sig=0; sig < (*cEF)->signatureList().size(); sig++){
               (*cEF)->signatureList()[ sig ]->set_signature_counter( sig + 1 );
            }
            // set the lower chain name as the L2 lower
            (*cEF)->set_lower_chain_name((*cL2)->lower_chain_name());
            (*cEF)->set_lower_chain_counter((*cL2)->lower_chain_counter());
            // set the prescales, rerun_prescales and pass_through
            int prescale(0);
            if ((*cL2)->prescale()==-1. || (*cEF)->prescale()==-1.) prescale=-1.;
            else prescale=(*cL2)->prescale()*(*cEF)->prescale();
            (*cEF)->set_prescale(prescale);
            int rerun_prescale(0);
            if (((*cL2)->rerun_prescale("")).second<0 || ((*cEF)->rerun_prescale("")).second<0) rerun_prescale=-1.;
            else rerun_prescale=((*cL2)->rerun_prescale("")).second * ((*cEF)->rerun_prescale("")).second;
            (*cEF)->set_rerun_prescale(rerun_prescale);
            int pass_through(0);
            if ((*cL2)->pass_through()==-1. || (*cEF)->pass_through()==-1.) pass_through=-1.;
            else pass_through=(*cL2)->pass_through()*(*cEF)->pass_through();
            (*cEF)->set_pass_through(pass_through);
            // add the EB_after_step
            (*cEF)->set_EB_after_step( (*cL2)->signatureList().size());
            /*      std::cout << "FPP: changed name to "  << (*cEF)->chain_name() 
                  << " level to "                     << (*cEF)->level() 
                  << "; set lower_chain_name to "     << (*cEF)->lower_chain_name() 
                  << "; set EB_after_step="           << (*cEF)->EB_after_step() 
                  << "; set prescale="                << (*cEF)->prescale()
                  << "; set rerun_prescale="          << (*cEF)->rerun_prescale()
                  << "; set pass_through="            << (*cEF)->pass_through()
                  << "; added signatures tot="        << (*cEF)->signatureList().size()<< std::endl;  */
            break;
         }
      }
      frame.theHLTChainList().addHLTChain(*cEF);
   }
 
   //std::cout<<"FPP HLTUtils::mergeHLTChains(): frame.getHLTChainList().chains().size()="<<frame.getHLTChainList().size()<<std::endl;
   return;
}

mergeHLTChainList2()

void TrigConf::HLTTEUtils::mergeHLTChainList2 ( TrigConf::HLTFrame & frame )

static

Definition at line 557 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                                       {
 
   if(! frame.mergedHLT()) return;
   
   // we need to keep the steps in sync so first we find the last step in L2
   unsigned int lastL2step(0);
   for( TrigConf::HLTChain* chain : frame.getHLTChainList() ) {
      if(chain->level_enum() != L2) continue;
      lastL2step = max(lastL2step, chain->lastStep());
   }
 
   // now make copies of all EF chains, the steps are
   // 1. make a deep copy of all EF chains
   // 2. give them level HLT and modify the name
   // 3. insert the signatures (deep copies) of the matching L2 chains at the front
   // 4. set the input L1Item condition
   // 5. merge the prescales, streams
 
   vector<HLTChain*> newHLTchains; 
   for( TrigConf::HLTChain* chain : frame.getHLTChainList() ) {
      if( chain->level_enum() != EF ) continue;
 
 
      // make the copy (deep copy of all signatures and output TEs)
      HLTChain * hltChain = new HLTChain(*chain);
      newHLTchains.push_back(hltChain);
 
      // keep track of chain counters (for correct prescale merging)
      hltChain->mergeCounter.ef = hltChain->chain_counter();
 
      // set the name and level to HLT
      // if name starts with EF_ it is replace with HLT_, otherwise HLT_ is prepended
      hltChain->set_level("HLT");
      string oldname = chain->name();
      unsigned int basepos = (oldname.compare(0,3,"EF_")==0)?3:0;
      hltChain->setName( "HLT_" + oldname.substr(basepos) );
 
      
      hltChain->set_EB_after_step(0); //in case EF chain is not seeded by any L2 chain
 
      // shift the step counters of by +lastL2Step (note that there is no step=0)
      hltChain->shiftStepCounter(lastL2step);
 
 
      // find the lower chain
      const HLTChain * l2Chain = frame.getHLTChainList().chain( hltChain->lower_chain_name() );
 
      // if no seeding l2 chain is found, nothing needs to be done
      if(l2Chain) {
 
         hltChain->mergeCounter.l2 = l2Chain->chain_counter();
 
         // insert l2 steps at the beginning
         // first need to create a deep copy
         vector<HLTSignature*> l2sig_deepcopy;
         for(HLTSignature* sig : l2Chain->signatures())
            l2sig_deepcopy.push_back(new HLTSignature(*sig));
 
         hltChain->signatureList().insert( hltChain->signatureList().begin(),
                                           l2sig_deepcopy.begin(), l2sig_deepcopy.end());
 
         // set L1 input
         hltChain->set_lower_chain_name( l2Chain->lower_chain_name() );
         hltChain->set_lower_chain_counter( l2Chain->lower_chain_counter() );
 
         // set the EB start after old L2 chain
         hltChain->set_EB_after_step( l2Chain->signatureList().size());
         
         // set prescales, pass throughs, rerun prescales, stream prescales
         
         // prescale (product of L2 and EF, disabled if either were disabled)
 
         mergeL2EFPrescales(hltChain, l2Chain->prescales(), hltChain->prescales());
//          bool disabled = l2Chain->prescale()<0 || hltChain->prescale()<0;
//          float prescale = l2Chain->prescale() * hltChain->prescale();
//          prescale = fabs(prescale) * (disabled?-1:1);
//          hltChain->prescales().setPrescale(prescale);
      }
      
      // TODO: rerun prescales, streams, 
      //       int rerun_prescale(0);
      //       if (((*cL2)->rerun_prescale("")).second<0 || ((*cEF)->rerun_prescale("")).second<0) rerun_prescale=-1.;
      //       else rerun_prescale=((*cL2)->rerun_prescale("")).second * ((*cEF)->rerun_prescale("")).second;
      //       (*cEF)->set_rerun_prescale(rerun_prescale);
      //       int pass_through(0);
      //       if ((*cL2)->pass_through()==-1. || (*cEF)->pass_through()==-1.) pass_through=-1.;
      //       else pass_through=(*cL2)->pass_through()*(*cEF)->pass_through();
      //       (*cEF)->set_pass_through(pass_through);
      //       // add the EB_after_step
      //       (*cEF)->set_EB_after_step( (*cL2)->signatureList().size());
      
      // TODO deal with L2-only chains
 
   }
 
   // delete the current chainlist content
   frame.theHLTChainList().clear();
 
   // and add the new chains
   for( HLTChain* chain : newHLTchains )
      frame.theHLTChainList().addHLTChain(chain);
 
   return;
}

mergeL2EFPrescales()

void TrigConf::HLTTEUtils::mergeL2EFPrescales ( TrigConf::HLTChain * hltchain, const TrigConf::HLTPrescale & l2ps, const TrigConf::HLTPrescale & efps )

static

Definition at line 545 of file TrigConfHLTData/Root/HLTUtils.cxx.

                                                                                                            {
   HLTPrescale hltps;
 
   bool disabled = l2ps.disabled() || efps.disabled();
 
   float prescale = fabs( l2ps.prescale() * efps.prescale() ) * (disabled?-1:1);
   hltps.setPrescale(prescale);
   
   hltchain->set_prescales(hltps);
}

splitGroups()

std::vector< std::string > TrigConf::HLTTEUtils::splitGroups ( const std::string & s )

static

Definition at line 409 of file TrigConfHLTData/Root/HLTUtils.cxx.

{
   // turns "(str1),(str2),(str3)" into ["str1", "str2", "str3"]
   std::string::size_type currentOpen = 0;
 
   std::vector< std::string > result;
 
   bool openParenthesis = false;
   for(std::string::size_type pos = 0; pos!=s.size(); ++pos) {
      char cc = s[pos];
      if(cc=='(') {
         if(openParenthesis) {
            std::stringstream str;
            str << "Two many open parenthesis in " << s << std::endl;
            throw std::runtime_error(str.str());
         }
         openParenthesis = true;
         currentOpen = pos;
      }
      if(cc==')') {
         if(!openParenthesis) {
            std::stringstream str;
            str << "Two many closing parenthesis in " << s << std::endl;
            throw std::runtime_error(str.str());
         }
         openParenthesis = false;
         result.push_back(std::string(s, currentOpen+1, pos-currentOpen-1));
      }
   }
   return result;
}

---

The documentation for this class was generated from the following files:

• TrigConfHLTData/TrigConfHLTData/HLTUtils.h
• TrigConfHLTData/Root/HLTUtils.cxx