TrigConfCoolWriter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TrigConf_TrigConfCoolWriter
#define TrigConf_TrigConfCoolWriter
 
#include "CoolApplication/Application.h"
#include "CoolKernel/DatabaseId.h"
#include "CoolKernel/Exception.h"
#include "CoolKernel/IDatabaseSvc.h"
#include "CoolKernel/IDatabase.h"
 
#include <string>
#include <iostream>
#include <vector>
#include <map>
 
namespace TrigConf {
 
   class ThresholdConfig;
   class CTPConfig;
   class Menu;
   class PIT;
   class TIP;
   class CaloInfo;
   class HLTFrame;
   class PrescaleSet;
   class HLTPrescaleSet;
   class BunchGroupSet;
   class TriggerItem;
   class TriggerThreshold;
   class ThresholdMonitor;
 
 
   typedef std::pair<unsigned int,unsigned int> RunRange;
   typedef std::vector<RunRange> RunRangeVec;
 
   class ValidityRange {
   public:
      ValidityRange(unsigned int run) {
         // highest bit==1 indicates infinite run range to be set (would not give valid iov anyway)
         bool infiniteRange = (run & 0x80000000) != 0; 
         if(infiniteRange) {
            m_range.first  = cool::ValidityKeyMin;
            m_range.second = cool::ValidityKeyMax;
         } else {
            m_range.first  = run; m_range.first <<= 32;
            m_range.second = run+1; m_range.second <<= 32;
         }
      }
 
      // from run/lb to end of run
      ValidityRange(unsigned int run, unsigned int lb) {
         m_range.first  = run; m_range.first <<= 32; m_range.first += lb;
         m_range.second = run+1; m_range.second <<= 32;
      }
 
      ValidityRange(cool::ValidityKey since, cool::ValidityKey until) {
         m_range.first  = since;
         m_range.second = until;
      }
 
      ValidityRange(const RunRange& rr) {
         int firstRN = rr.first;
         int lastRN = rr.second;
         // highest bit==1 indicates infinite run range to be set (would not give valid iov anyway)
         bool infiniteRange = (firstRN & 0x80000000) != 0; 
         if(infiniteRange) {
            m_range.first  = cool::ValidityKeyMin;
            m_range.second = cool::ValidityKeyMax;
         } else {
            m_range.first  = firstRN; m_range.first <<= 32;
            m_range.second = lastRN+1; m_range.second <<= 32;
         }
      }
      cool::ValidityKey& since() { return m_range.first; }
      cool::ValidityKey& until() { return m_range.second; }
   private:
      std::pair<cool::ValidityKey,cool::ValidityKey> m_range;
   };
   
   class TrigConfCoolWriter;
   class AutoDBOpen {
   public:
      AutoDBOpen(TrigConfCoolWriter *writer, bool readOnly);
      ~AutoDBOpen();
      TrigConfCoolWriter * m_writer;
      bool m_neededToOpen;
      bool m_ro;
   };
 
   
   class TrigConfCoolWriter {
   public:
 
      TrigConfCoolWriter(const std::string& dbId, std::ostream & o = std::cout) : 
         m_dbId(cool::DatabaseId(dbId)),
         m_writeFolderList(),
         m_ostream(o)
      {}
    
      ~TrigConfCoolWriter(){};  
 
      void createSchema(int schemaVersion=0);
 
      void recreateSchema(int schemaVersion=0);
 
      void printSchema(std::ostream &o);
 
      void printSchemaVersion(std::ostream &o);
 
 
      void writeL1Payload( ValidityRange vr, const CTPConfig& ctpConfig);
 
      void writeHLTPayload( ValidityRange vr,
                            const HLTFrame& hltFrame,
                            const std::string& configSource);
       
      void writeMCKPayload(ValidityRange vr,
                             unsigned int mck,
                            std::string& release,
                            std::string& info);
 
 
      void writeRunPayload( unsigned int runNumber,
                            unsigned int masterConfigKey,
                            unsigned int hltPrescaleKey,
                            const TrigConf::ThresholdConfig & lvl1Thr,
                            const TrigConf::CTPConfig & ctpConfig,
                            const TrigConf::CaloInfo & caloInfo,
                            const TrigConf::HLTFrame & hltFrame,
                            const std::string & configSource);
      void writeRunPayload( const RunRangeVec& runRanges,
                            unsigned int masterConfigKey,
                            unsigned int hltPrescaleKey,
                            const TrigConf::ThresholdConfig & lvl1Thr,
                            const TrigConf::CTPConfig & ctpConfig,
                            const TrigConf::CaloInfo & caloInfo,
                            const TrigConf::HLTFrame & hltFrame,
                            const std::string & configSource);
 
      void writeL1MenuPayload( ValidityRange vr, const TrigConf::Menu& lvl1Menu);
      void writeL1MenuPayload( const RunRangeVec& runRanges, const TrigConf::Menu& lvl1Menu);
 
      void writeL1CTPCoreInputMapping( ValidityRange vr, const Menu& lvl1Menu);
 
 
      void writeL1MonPayload( unsigned int runNumber, const TrigConf::Menu * lvl1Menu);
      void writeL1MonPayload( const RunRangeVec& runRanges, const TrigConf::Menu * lvl1Menu);
 
      void writeL1BunchGroupLBPayload( const RunRangeVec& runRanges,
                                       unsigned int bgKey,
                                       const BunchGroupSet& bgs);
      void writeL1BunchGroupLBPayload( ValidityRange vr,
                                       unsigned int bgKey,
                                       const BunchGroupSet& bgs);
    
 
      void writeL1BunchGroupRunPayload( ValidityRange vr,
                                        const Menu& lvl1Menu,
                                        const BunchGroupSet& bgs);
      void writeL1BunchGroupRunPayload( const RunRangeVec& runRanges,
                                        const TrigConf::Menu& lvl1Menu,
                                        const TrigConf::BunchGroupSet& bgs);
    
      void writeHltPrescalePayload( unsigned int runNumber,
                                    unsigned int lumiblockNumber,
                                    const TrigConf::HLTPrescaleSet & pss);
      void writeHltPrescalePayload( const RunRangeVec& runRanges,
                                    const TrigConf::HLTPrescaleSet & pss);
      void writeHltPrescalePayload( cool::ValidityKey since,
                                    cool::ValidityKey until,
                                    const TrigConf::HLTPrescaleSet & pss);
    
    
      void writeL1PrescalePayload( unsigned int runNumber,
                                   unsigned int lumiblockNumber,
                                   unsigned int lvl1PrescaleKey,
                                   const TrigConf::PrescaleSet & prescale);
      void writeL1PrescalePayload( const RunRangeVec& runRanges,
                                   unsigned int lvl1PrescaleKey,
                                   const TrigConf::PrescaleSet & prescale);
      void writeL1PrescalePayload( cool::ValidityKey since,
                                   cool::ValidityKey until,
                                   unsigned int lvl1PrescaleKey,
                                   const TrigConf::PrescaleSet & prescaleSet);
 
 
 
      void readRunPayload( unsigned int runNumber,
                           TrigConf::HLTFrame & hltFrame,
                           unsigned int & masterConfigKey,
                           unsigned int & hltPrescaleKey,
                           std::string & configSource );
 
      void readHLTPayload( unsigned int run,
                           HLTFrame & hltFrame);
 
      void readL1Payload( unsigned int run,
                          CTPConfig & ctpc);
 
 
      void readHltPrescalePayload( unsigned int runNumber,
                                   unsigned int lumiblockNumber,
                                   TrigConf::HLTPrescaleSet & pss);
 
 
      void readL1BunchGroupLBPayload( unsigned int runNumber,
                                      unsigned int lumiblockNumber,
                                      int& bgKey,
                                      TrigConf::BunchGroupSet& bgs);
 
      std::pair<std::vector<std::string>, std::map<unsigned int,unsigned char> >
      readL1BunchGroupRunPayload( unsigned int runNumber);
 
 
      void readL1PrescalePayload( unsigned int runNumber,
                                  unsigned int lumiblockNumber,
                                  unsigned int& lvl1PrescaleKey,
                                  TrigConf::PrescaleSet & prescale);
 
      void readL1InputMapPayload( unsigned int runNumber,
                                  std::vector<TrigConf::PIT*>& pits,
                                  std::vector<TrigConf::TIP*>& tips);
    
      void readL1MonMapPayload(unsigned int runNumber,
                               std::vector<TrigConf::ThresholdMonitor*>& mons);
 
      void readL1Items(unsigned int runNumber,
                       std::vector<TrigConf::TriggerItem*>& items);
 
      void readL1Thresholds(unsigned int runNumber,
                            std::vector<TrigConf::TriggerThreshold*>& thrs);
 
      void readL1ItemDef(unsigned int runNumber,
                         const std::vector<TrigConf::TriggerItem*>& items,
                         const std::vector<TrigConf::TriggerThreshold*>& thrs);
 
      void readL1Menu(unsigned int runNumber, CTPConfig & ctpc);
 
      std::vector<std::string> checkPayloadSize(unsigned int run, unsigned int lb, int displayMode, bool openend, unsigned int lbend);
 
      void addWriteFolder(const std::string& fname) { m_writeFolderList.push_back( fname ); }
 
      void setVerbosityLevel(unsigned int level) { m_verbosityLevel = level; }
      unsigned int verbosityLevel() const { return m_verbosityLevel; }
 
      bool checkDbConnection(bool readonly);
 
      bool HLTPrescaleFolderExists();
 
      void clearWriteFolder() { m_writeFolderList.clear(); }
  
   private:
      friend class AutoDBOpen;
 
      TrigConfCoolWriter():
         m_ostream(std::cout)
      {};
 
      TrigConfCoolWriter(const TrigConfCoolWriter & orig) :
         m_ostream(orig.m_ostream)
      {};
 
 
      cool::IDatabaseSvc& databaseService();
 
      cool::IDatabasePtr openDb( bool readOnly = true );
 
      bool dbIsOpen();
 
      void dropDb();
 
      void closeDb(cool::IDatabasePtr& db);
      void closeDb();  // to be used
 
      cool::IDatabasePtr createDb();
 
      cool::IDatabasePtr recreateDb();
 
      void rangeInfo(const std::string& content, cool::ValidityKey since, cool::ValidityKey until);
 
      bool shouldFolderBeUpdated(const std::string & foldername) {
         if( m_writeFolderList.size()==0 ) return true; // nothing specified --> write everything (default)
         return std::count(m_writeFolderList.begin(),m_writeFolderList.end(),foldername)>0;
      }
                         
      // data members
      // DB connection string: oracle://<server>;schema=<acc_name>;dbname=<db_name>;user=<acc_name>;password=<pwd>
      cool::DatabaseId         m_dbId;  
      cool::IDatabasePtr       m_dbPtr; 
      cool::Application        m_coolApp; 
 
      std::vector<std::string> m_writeFolderList; 
      std::ostream & m_ostream; 
 
      int m_verbosityLevel{0};
   };
 
}
 
#endif