TriggerMenuRW.cxx File Reference

#include "TrigConfIO/JsonFileLoader.h"
#include "TrigConfIO/JsonFileWriterL1.h"
#include "TrigConfIO/JsonFileWriterHLT.h"
#include "TrigConfIO/TrigDBMenuLoader.h"
#include "TrigConfIO/TrigDBJobOptionsLoader.h"
#include "TrigConfIO/TrigDBL1PrescalesSetLoader.h"
#include "TrigConfIO/TrigDBHLTPrescalesSetLoader.h"
#include "TrigConfIO/TrigDBL1BunchGroupSetLoader.h"
#include "TrigConfIO/TrigDBMonitoringLoader.h"
#include "TrigConfIO/TrigDBCTPFilesLoader.h"
#include "TrigConfData/HLTMenu.h"
#include "TrigConfData/L1Menu.h"
#include "TrigConfData/L1PrescalesSet.h"
#include "TrigConfData/HLTPrescalesSet.h"
#include "TrigConfData/L1BunchGroupSet.h"
#include <cstdlib>
#include <vector>
#include <format>

Go to the source code of this file.

Classes
struct	Config

Functions
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 237 of file TriggerMenuRW.cxx.

                                {
 
   Config cfg;
   cfg.parseProgramOptions(argc, argv);
   if(cfg.help) {
      cfg.usage();
      return 0;
   }
 
   if(cfg.error.size()!=0) {
      for(const string & e: cfg.error)
         cerr << e << endl;
      cfg.usage();
      return 1;
   }
 
   if( cfg.inputFiles.size()>0 ) {
      // load config from files
      TrigConf::JsonFileLoader fileLoader;
      for (const std::string & fn : cfg.inputFiles) {
         // check if the file is L1 or HLT
         std::string filetype = fileLoader.getFileType( fn );
         if(filetype == "l1menu") {
            TrigConf::L1Menu l1menu;
            fileLoader.loadFile( fn, l1menu);
            cout << "Loaded L1 menu " << l1menu.name() << " with " << l1menu.size() << " items from " << fn << endl;
            l1menu.printMenu(cfg.detail);
            writeJsonFile(l1menu, "L1Menu", cfg);
         } else if(filetype == "hltmenu" ) {
            TrigConf::HLTMenu hltmenu;
            fileLoader.loadFile( fn, hltmenu);
            cout << "Loaded HLT menu " << hltmenu.name() << " with " << hltmenu.size() << " chains from " << fn << endl;
            hltmenu.printMenu(cfg.detail);
            writeJsonFile(hltmenu, "HLTMenu", cfg);
         } else if(filetype == "l1prescale" ) {
            TrigConf::L1PrescalesSet l1pss;
            fileLoader.loadFile( fn, l1pss);
            cout << "Loaded L1 prescales set file " << fn << " with " << l1pss.size() << " prescales from " << fn << endl;
            writeJsonFile(l1pss, "L1PrescalesSet", cfg);
         } else if(filetype == "hltprescale" ) {
            TrigConf::HLTPrescalesSet hltpss;
            fileLoader.loadFile( fn, hltpss);
            cout << "Loaded HLT prescales set file " << fn << " with " << hltpss.size() << " prescales from " << fn << endl;
            hltpss.printPrescaleSet(cfg.detail);
            writeJsonFile(hltpss, "HLTPrescalesSet", cfg);
         } else if(filetype == "bunchgroupset" ) {
            TrigConf::L1BunchGroupSet bgs;
            fileLoader.loadFile( fn, bgs);
            cout << "Loaded L1 BunchGroup set file " << fn << " with " << bgs.sizeNonEmpty() << " non-empty bunchgroups from " << fn << endl;
            bgs.printSummary(cfg.detail);
            writeJsonFile(bgs, "BunchGroupSet", cfg);
         } else if(filetype == "joboptions" ) {
            TrigConf::DataStructure jo;
            fileLoader.loadFile( fn, jo);
            cout << "Loaded job options with " << jo.getObject("properties").getKeys().size() << " properties from " << fn << endl;
            if( cfg.detail ) {
               TrigConf::DataStructure ds = jo.getObject("properties");
               //cppcheck-suppress throwInEntryPoint
               for( const auto& alg : ds.data()) {
                  std::cout << alg.first << std::endl;
                  for( const auto& prop : alg.second ) {
                     std::cout << "      " << prop.first << " -> " << prop.second.data() << std::endl;
                  }
               }
            }
            writeJsonFile(jo, "HLTJobOptions", cfg);
         } else if(filetype == "hltmonitoringsummary" ) {
            TrigConf::HLTMonitoring mon;
            fileLoader.loadFile( fn, mon);
            cout << "Loaded HLT monnitoring with " << mon.size() << " signatures from " << fn << endl;
            mon.printMonConfig(cfg.detail);
            writeJsonFile(mon, "HLTMonitoring", cfg);
         } else {
            cerr << "File " << fn << " not recognized as being an L1 or HLT menu or prescale set or bunchgroup set" << endl;
         }
      }
   }
 
   if( cfg.smk != 0 && !cfg.doCtp ) {
      // load config from DB
      {
         // db menu loader
         TrigConf::TrigDBMenuLoader dbloader(cfg.dbalias);
         if(!cfg.crestDb.empty()) {
            dbloader.setCrestTrigDB(cfg.crestDb);
            dbloader.setCrestConnection(cfg.crestServer, cfg.crestApi);
         }
         
         // L1 menu
         {
            TrigConf::L1Menu l1menu;
            try {
               dbloader.loadL1Menu( cfg.smk, l1menu, outputFileName("L1Menu", cfg) );
            }
            catch(TrigConf::IOException & ex) {
               cout << "Could not load L1 menu. An exception occurred: " << ex.what() << endl;
            }
            if(l1menu) {
               cout << "Loaded L1 menu " << l1menu.name() << " with " << l1menu.size() << " items from " << cfg.dbalias << " with SMK " << cfg.smk << endl;
               if( cfg.detail ) {
                  l1menu.printMenu(true);
               }
            }
            cout << endl;
         }
 
         // HLT menu
         {
            TrigConf::HLTMenu hltmenu;
            try {
               dbloader.loadHLTMenu( cfg.smk, hltmenu, outputFileName("HLTMenu", cfg));
            }
            catch(TrigConf::IOException & ex) {
               cout << "Could not load HLT menu. An exception occurred: " << ex.what() << endl;
            }
            if (hltmenu) {
               cout << "Loaded HLT menu " << hltmenu.name() << " with " << hltmenu.size() << " chains from " << cfg.dbalias << " with SMK " << cfg.smk << endl;
               if( cfg.detail ) {
                  hltmenu.printMenu(true);
               }
            }
            cout << endl;
         }
      }
 
      // Job options
      {
         TrigConf::TrigDBJobOptionsLoader dbloader(cfg.dbalias);
         if(!cfg.crestDb.empty()) {
            dbloader.setCrestTrigDB(cfg.crestDb);
            dbloader.setCrestConnection(cfg.crestServer, cfg.crestApi);
         }
         TrigConf::DataStructure jo;
         try {
            dbloader.loadJobOptions( cfg.smk, jo, outputFileName("HLTJobOptions", cfg) );
         }
         catch(TrigConf::IOException & ex) {
            cout << "Could not load HLT job options. An exception occurred: " << ex.what() << endl;
         }
         if (jo) {
            cout << "Loaded job options with " << jo.getObject("properties").getKeys().size() << " entries from " << cfg.dbalias << " with SMK " << cfg.smk << endl;
            if( cfg.detail ) {
               TrigConf::DataStructure ds = jo.getObject("properties");
               for( const auto& alg : ds.data()) {
                  std::cout << alg.first << std::endl;
                  for( const auto& prop : alg.second ) {
                     std::cout << "      " << prop.first << " -> " << prop.second.data() << std::endl;
                  }
               }
            }
         }
         cout << endl;
      }
 
      // HLT monitoring groups
      {
         TrigConf::TrigDBMonitoringLoader dbloader(cfg.dbalias);
         if(!cfg.crestDb.empty()) {
            dbloader.setCrestTrigDB(cfg.crestDb);
            dbloader.setCrestConnection(cfg.crestServer, cfg.crestApi);
         }
         TrigConf::HLTMonitoring hltmon;
         try {
            dbloader.loadHLTMonitoring( cfg.smk, hltmon, outputFileName("HLTMonitoring", cfg));
         }
         catch(TrigConf::IOException & ex) {
            cout << "Could not load HLT monitoring. An exception occurred: " << ex.what() << endl;
         }
         if (hltmon) {
            cout << "Loaded HLT monitoring with " << hltmon.size() << " signatures rom " << cfg.dbalias << " with SMK " << cfg.smk << endl;
            if( cfg.detail ) {
               hltmon.printMonConfig(true);
            }
         }
         cout << endl;
      }
 
   }
 
   if( cfg.smk != 0 && cfg.doCtp ) {
      TrigConf::TrigDBCTPFilesLoader dbloader(cfg.dbalias);
      TrigConf::L1CTPFiles ctpfiles;
      try{
        dbloader.loadHardwareFiles(cfg.smk, ctpfiles, 0x0F, outputFileName("CTPFiles", cfg));
      } catch (std::format_error & e){
        cout << " format_error "<<e.what()<<" thrown in TriggerMenuRW.\n";
        return 1;
      }
      ctpfiles.print();
   }
 
   if( cfg.l1psk != 0 ) {
      // load L1 prescales set from DB
      TrigConf::TrigDBL1PrescalesSetLoader dbloader(cfg.dbalias);
      if(!cfg.crestDb.empty()) {
         dbloader.setCrestTrigDB(cfg.crestDb);
         dbloader.setCrestConnection(cfg.crestServer, cfg.crestApi);
      }
      TrigConf::L1PrescalesSet l1pss;
      try {
         dbloader.loadL1Prescales( cfg.l1psk, l1pss, outputFileName("L1PrescalesSet", cfg) );
      }
      catch(TrigConf::IOException & ex) {
         cout << "Could not load L1 prescales. An exception occurred: " << ex.what() << endl;
      }      
      if (l1pss) {
         cout << "Loaded L1 prescales set " << l1pss.name() << " with " << l1pss.size() << " prescales from " << cfg.dbalias << " with L1 PSK " << cfg.l1psk << endl;
      }
   }
 
   if( cfg.hltpsk != 0 ) {
      // load L1 prescales set from DB
      TrigConf::TrigDBHLTPrescalesSetLoader dbloader(cfg.dbalias);
      if(!cfg.crestDb.empty()) {
         dbloader.setCrestTrigDB(cfg.crestDb);
         dbloader.setCrestConnection(cfg.crestServer, cfg.crestApi);
      }
      TrigConf::HLTPrescalesSet hltpss;    
      try {
         dbloader.loadHLTPrescales( cfg.hltpsk, hltpss, outputFileName("HLTPrescalesSet", cfg) );
      }
      catch(TrigConf::IOException & ex) {
         cout << "Could not load HLT prescales. An exception occurred: " << ex.what() << endl;
      }      
      if (hltpss) {
         cout << "Loaded HLT prescales set " << hltpss.name() << " with " << hltpss.size() << " prescales from " << cfg.dbalias << " with HLT PSK " << cfg.hltpsk << endl;
      }
   }
 
   if( cfg.bgsk != 0 ) {
      // load L1 prescales set from DB
      TrigConf::TrigDBL1BunchGroupSetLoader dbloader(cfg.dbalias);
      if(!cfg.crestDb.empty()) {
         dbloader.setCrestTrigDB(cfg.crestDb);
         dbloader.setCrestConnection(cfg.crestServer, cfg.crestApi);
      }
      TrigConf::L1BunchGroupSet bgs;
      try {
         dbloader.loadBunchGroupSet( cfg.bgsk, bgs, outputFileName("BunchGroupSet", cfg) );
      }
      catch(TrigConf::IOException & ex) {
         cout << "Could not load bunchgroup set. An exception occurred: " << ex.what() << endl;
      }      
      if (bgs) {
         cout << "Loaded L1 bunchgroup set " << bgs.name() << " with " << bgs.size() << " bunchgroups from " << cfg.dbalias << " with BGSK " << cfg.bgsk << endl;
         if( cfg.detail ) {
            bgs.printSummary(true);
         }
      }
   }
 
   return 0;
}