Run2toRun3ConvertersHLT.cxx File Reference

#include <numeric>
#include "TrigConfData/HLTMenu.h"
#include "TrigConfData/DataStructure.h"
#include "TrigCompositeUtils/HLTIdentifier.h"
#include <boost/property_tree/json_parser.hpp>
#include "TrigConfHLTData/HLTFrame.h"
#include "TrigConfHLTData/HLTChain.h"
#include "TrigConfHLTData/HLTStreamTag.h"
#include "TrigConfHLTData/HLTSignature.h"
#include "TrigConfHLTData/HLTTriggerElement.h"
#include "TrigCompositeUtils/ChainNameParser.h"
#include "TrigConfIO/JsonFileWriterHLT.h"
#include "TrigConfData/HLTPrescalesSet.h"

Go to the source code of this file.

Macros
#define	BOOST_BIND_GLOBAL_PLACEHOLDERS

Functions
template<typename COLL>
boost::property_tree::ptree	asArray (const COLL &data)
std::vector< int >	legMult (const TrigConf::HLTChain *cptr)
std::vector< std::string >	l1thresholds (const TrigConf::HLTFrame *frame, const TrigConf::HLTChain *cptr)
void	printJSON (boost::property_tree::ptree &p)
bool	convertHLTMenu (const TrigConf::HLTFrame *frame, TrigConf::HLTMenu &menu)
void	convertRun2HLTMenuToRun3 (const TrigConf::HLTFrame *frame, const std::string &filename)
void	convertRun2HLTPrescalesToRun3 (const TrigConf::HLTFrame *frame, const std::string &filename)

Macro Definition Documentation

BOOST_BIND_GLOBAL_PLACEHOLDERS

#define BOOST_BIND_GLOBAL_PLACEHOLDERS

Definition at line 9 of file Run2toRun3ConvertersHLT.cxx.

Function Documentation

asArray()

template<typename COLL>

boost::property_tree::ptree asArray

(

const COLL &

data

)

Definition at line 22 of file Run2toRun3ConvertersHLT.cxx.

                                                   {
   using ptree = boost::property_tree::ptree;
   ptree array;
   for ( const auto& el: data ) {
      ptree one;
      one.put("", el);
      array.push_back(std::make_pair("", one));
   }
   return array;
}

convertHLTMenu()

bool convertHLTMenu	(	const TrigConf::HLTFrame *	frame,
		TrigConf::HLTMenu &	menu )

Definition at line 59 of file Run2toRun3ConvertersHLT.cxx.

                                                                          {
   using ptree = boost::property_tree::ptree;
   ptree top;
   top.put("filetype", "hltmenu");
   top.put("name", frame->name());
   ptree pChains;
 
   std::map<std::string, const TrigConf::HLTStreamTag*> allStreams;
 
   for ( auto cptr : frame->getHLTChainList() ) {
      ptree pChain;
      pChain.put("counter", cptr->chain_counter());
      pChain.put("nameHash", cptr->chain_hash_id());
      pChain.put("l1item", cptr->lower_chain_name());
      pChain.add_child("l1thresholds", asArray(l1thresholds(frame, cptr)));
      pChain.add_child("legMultiplicities", asArray(legMult(cptr)) );
      pChain.add_child("sequencers", asArray(std::vector<std::string>({"missing"})));
 
      std::vector<std::string> strNames;
      for ( const auto st: cptr->streams()) {
         strNames.push_back(st->stream());
         allStreams[st->stream()] = st;
      }
      pChain.add_child("streams", asArray(strNames));
 
      pChain.add_child("groups", asArray(cptr->groups()));
 
      // Signature data
      // Note: This is run-2 only.
      // It is propagated here to allow legacy trigger feature access.
      std::vector<uint32_t> counters;
      std::vector<int> logics;
      std::vector<std::string> labels;
      ptree outputTEs_outerArray; // outputTEs is a std::vector<std::vector<std::string>>
 
      for(auto& signature : cptr->signatureList() ){
         uint32_t cntr = signature->signature_counter();
         counters.push_back(cntr);
         logics.push_back(signature->logic());
         labels.push_back(signature->label());
         ptree outputTEs_innerArray;
         for(auto& outputTE : signature->outputTEs()){
            outputTEs_innerArray.push_back( ptree::value_type("", outputTE->name()) );
         }
         outputTEs_outerArray.push_back( ptree::value_type("", outputTEs_innerArray) );
      }
 
      ptree pSig; 
      pSig.add_child("counters", asArray(counters));
      pSig.add_child("logics", asArray(logics));
      pSig.add_child("outputTEs", outputTEs_outerArray);
      pSig.add_child("labels", asArray(labels));
 
      pChain.add_child("signature", pSig);
      // End of signature data
 
      pChains.push_back(std::make_pair(cptr->chain_name(), pChain));
   }
   ptree pStreams;
   for ( auto [sname, stream]: allStreams ) {
      ptree pStream;
      pStream.put("name", sname);
      pStream.put("type", stream->type());
      pStream.put("obeyLB", stream->obeyLB());
      pStream.put("forceFullEventBuilding", true);  // TODO understand how to get this information from old menu
      pStreams.push_back(std::make_pair(sname, pStream));
   }
 
   top.add_child("chains", pChains);
 
   top.add_child("streams", pStreams);
   ptree pSequencers;
   pSequencers.add_child("missing", asArray(std::vector<std::string>({""})));
   top.add_child("sequencers", pSequencers);
 
   // Set run2 sequence information:
   const TrigConf::HLTSequenceList& sequenceList = frame->getHLTSequenceList();
   std::vector<std::string> outputTEs;
   ptree inputTEs_outerArray;  // sequenceInputTEs is a std::vector<std::vector<std::string>>
   ptree algorithms_outerArray;  // sequenceAlgorithms is a std::vector<std::vector<std::string>>
   for(auto& seq : sequenceList){
      outputTEs.push_back(seq->outputTE()->name());
 
      ptree inputTEs_innerArray;
      for(auto& input : seq->inputTEs()) {
         inputTEs_innerArray.push_back( ptree::value_type("", input->name()) );
      }
      inputTEs_outerArray.push_back( ptree::value_type("", inputTEs_innerArray) );
 
      ptree algorithms_innerArray;
      for(const std::string& alg : seq->algorithms()) {
         algorithms_innerArray.push_back( ptree::value_type("", alg) );
      }
      algorithms_outerArray.push_back( ptree::value_type("", algorithms_innerArray) );
   }
   ptree pSequence;
   pSequence.add_child("outputTEs", asArray(outputTEs));
   pSequence.add_child("inputTEs", inputTEs_outerArray);
   pSequence.add_child("algorithms", algorithms_outerArray);
   top.add_child("sequence_run2", pSequence);
 
   menu.setData(std::move(top));
   menu.setSMK(frame->smk());
   return true;
}

convertRun2HLTMenuToRun3()

void convertRun2HLTMenuToRun3	(	const TrigConf::HLTFrame *	frame,
		const std::string &	filename )

Definition at line 165 of file Run2toRun3ConvertersHLT.cxx.

                                                                                        {
  TrigConf::HLTMenu menu;
  convertHLTMenu(frame, menu);
 
  TrigConf::JsonFileWriterHLT writer;
  writer.writeJsonFile(filename, menu);
 
}

convertRun2HLTPrescalesToRun3()

void convertRun2HLTPrescalesToRun3	(	const TrigConf::HLTFrame *	frame,
		const std::string &	filename )

Definition at line 174 of file Run2toRun3ConvertersHLT.cxx.

                                                                                             {
   using ptree = boost::property_tree::ptree;
   ptree top;
   top.put("filetype", "hltprescale");
   top.put("name", frame->name());
   ptree pChains;
   for ( auto cptr : frame->getHLTChainList() ) {
      ptree pChain;
      pChain.put("name", cptr->chain_name());
      pChain.put("counter", cptr->chain_counter());
      pChain.put("hash", cptr->chain_hash_id());
      pChain.put("prescale", cptr->prescale());
      pChain.put("enabled", (cptr->prescale()>0 ? true: false));
 
      pChains.push_back(std::make_pair(cptr->chain_name(), pChain));
   }
   top.add_child("prescales", pChains);
   TrigConf::HLTPrescalesSet psk(std::move(top));
 
   TrigConf::HLTMenu menu;
   convertHLTMenu(frame, menu);
 
   TrigConf::JsonFileWriterHLT writer;
   writer.writeJsonFile(filename, menu, psk);
}

l1thresholds()

std::vector< std::string > l1thresholds	(	const TrigConf::HLTFrame *	frame,
		const TrigConf::HLTChain *	cptr )

Definition at line 37 of file Run2toRun3ConvertersHLT.cxx.

                                                                                               {
   std::set<std::string> names;
   for ( const auto sig: cptr->signatures() ) {
      for ( const auto te: sig->outputTEs() ) {
         auto sequence = frame->getHLTSequenceList().getSequence(te->name());
         for ( const auto inTE: sequence->inputTEs() ) {
            if ( not ( inTE->name().find("L2_") == 0 or inTE->name().find("EF_") == 0 or inTE->name().find("HLT_") == 0 ) ) {
               names.insert(inTE->name());
            }
         }
      }
   }
   return std::vector<std::string>( names.begin(), names.end() );
}

legMult()

std::vector< int > legMult

(

const TrigConf::HLTChain *

cptr

)

Definition at line 33 of file Run2toRun3ConvertersHLT.cxx.

                                                     {
   return ChainNameParser::multiplicities(cptr->chain_name());
}

printJSON()

void printJSON

(

boost::property_tree::ptree &

p

)

Definition at line 52 of file Run2toRun3ConvertersHLT.cxx.

                                           {
   // this code is useful to debug JSON before it is pushed to menu objects expecting certain structure in place
   std::stringstream ss;
   boost::property_tree::json_parser::write_json(ss, p);
   std::cout << ss.str() << std::endl;
}