L1GtTriggerMenuConfigOnlineProd.h

Go to the documentation of this file.

#ifndef L1GtConfigProducers_L1GtTriggerMenuConfigOnlineProd_h
#define L1GtConfigProducers_L1GtTriggerMenuConfigOnlineProd_h
 
// system include files
#include "boost/lexical_cast.hpp"
 
#include <memory>
#include <string>
#include <vector>
#include <iomanip>
#include <iostream>
 
// user include files
//   base class
#include "CondTools/L1Trigger/interface/L1ConfigOnlineProdBase.h"
 
#include "CondFormats/L1TObjects/interface/L1GtTriggerMenu.h"
#include "CondFormats/DataRecord/interface/L1GtTriggerMenuRcd.h"
 
#include "CondFormats/L1TObjects/interface/L1GtMuonTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtCaloTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtEnergySumTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtJetCountsTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtCastorTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtHfBitCountsTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtHfRingEtSumsTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtCorrelationTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtBptxTemplate.h"
#include "CondFormats/L1TObjects/interface/L1GtExternalTemplate.h"
 
// forward declarations
 
// class declaration
class L1GtTriggerMenuConfigOnlineProd : public L1ConfigOnlineProdBase<L1GtTriggerMenuRcd, L1GtTriggerMenu> {
public:
  L1GtTriggerMenuConfigOnlineProd(const edm::ParameterSet&);
 
  ~L1GtTriggerMenuConfigOnlineProd() override;
 
  std::unique_ptr<L1GtTriggerMenu> newObject(const std::string& objectKey) override;
 
  void init(const int numberConditionChips);
 
private:
 
  struct TableMenuGeneral {
    std::string menuInterface;
    std::string menuImplementation;
    std::string algoImplTag;
    std::string scalesKey;
  };
 
  struct TableMenuAlgo {
    short bitNumberSh;
    std::string algName;
    std::string algAlias;
    std::string logExpression;
  };
 
  struct TableMenuAlgoCond {
    short bitNumberSh;
    float condIndexF;
    std::string condFK;
  };
 
  struct TableMenuCond {
    std::string cond;
    std::string condCategory;
    std::string condType;
    std::string gtObject1;
    std::string gtObject2;
    bool condGEq;
    short countIndex;
    short countThreshold;
 
    // Oracle / Coral pretends that chargeCorrelation is bool in OMDS
    //   can not be - it has three values...
    //   but it reads/writes correctly the numerical value from OMDS (1, 2...)
    bool chargeCorrelation;
    std::string objectParameter1FK;
    std::string objectParameter2FK;
    std::string objectParameter3FK;
    std::string objectParameter4FK;
    std::string deltaEtaRange;
    std::string deltaPhiRange;
  };
 
  struct TableMenuObjectParameters {
    std::string opId;
    short ptHighThreshold;
    short ptLowThreshold;
    bool enableMip;
    bool enableIso;
    bool requestIso;
    bool energyOverflow;
    float etThreshold;
    std::string etaRange;
    std::string phiRange;
    short phiHigh;
    short phiLow;
    std::string qualityRange;
    bool charge;
  };
 
  struct TableMenuTechTrig {
    short bitNumberSh;
    std::string techName;
  };
 
 
  bool tableMenuGeneralFromDB(const std::string& gtSchema, const std::string& objKey);
 
  bool tableMenuAlgoFromDB(const std::string& gtSchema, const std::string& objKey);
 
  bool tableMenuAlgoCondFromDB(const std::string& gtSchema, const std::string& objKey);
 
  bool tableMenuCondFromDB(const std::string& gtSchema, const std::string& objKey);
 
  bool tableMenuObjectParametersFromDB(const std::string& gtSchema, const std::string& objKey);
 
  bool tableMenuTechTrigFromDB(const std::string& gtSchema, const std::string& objKey);
 
private:
  const std::map<int, std::string> condIndexNameMap(const short bitNr) const;
 
  std::string convertLogicalExpression(const std::string&, const std::map<int, std::string>&) const;
 
  int chipNumber(short) const;
 
  void buildAlgorithmMap();
 
  void buildTechnicalTriggerMap();
 
  L1GtConditionCategory strToEnumCondCategory(const std::string& strCategory);
 
  L1GtConditionType strToEnumCondType(const std::string& strType);
 
  L1GtObject strToEnumL1GtObject(const std::string& strObject);
 
  void splitHexStringInTwo64bitWords(const std::string& hexStr, std::string& hex0WordStr, std::string& hex1WordStr);
 
  std::list<int> listChipNumber(const std::string&);
 
  void fillMuonObjectParameter(const std::string& opFK, L1GtMuonTemplate::ObjectParameter&);
  void addMuonCondition(const TableMenuCond&);
 
  void fillCaloObjectParameter(const std::string& opFK, L1GtCaloTemplate::ObjectParameter&);
  void addCaloCondition(const TableMenuCond&);
 
  void fillEnergySumObjectParameter(const std::string& opFK,
                                    L1GtEnergySumTemplate::ObjectParameter&,
                                    const L1GtObject&);
  void addEnergySumCondition(const TableMenuCond&);
 
  void addJetCountsCondition(const TableMenuCond&);
  void addHfBitCountsCondition(const TableMenuCond&);
  void addHfRingEtSumsCondition(const TableMenuCond&);
  void addCastorCondition(const TableMenuCond&);
  void addBptxCondition(const TableMenuCond&);
  void addExternalCondition(const TableMenuCond&);
  void addCorrelationCondition(const TableMenuCond&);
 
  void addConditions();
 
private:
  template <typename Result, typename Source>
  Result lexical_cast_from_hex(Source& value) const;
 
private:
 
  TableMenuGeneral m_tableMenuGeneral;
  std::vector<TableMenuAlgo> m_tableMenuAlgo;
  std::vector<TableMenuAlgoCond> m_tableMenuAlgoCond;
  std::vector<TableMenuCond> m_tableMenuCond;
  std::vector<TableMenuObjectParameters> m_tableMenuObjectParameters;
  std::vector<TableMenuTechTrig> m_tableMenuTechTrig;
 
private:
 
  std::string m_triggerMenuInterface;
  std::string m_triggerMenuName;
  std::string m_triggerMenuImplementation;
 
  std::string m_scaleDbKey;
 
  std::vector<std::vector<L1GtMuonTemplate> > m_vecMuonTemplate;
  std::vector<std::vector<L1GtCaloTemplate> > m_vecCaloTemplate;
  std::vector<std::vector<L1GtEnergySumTemplate> > m_vecEnergySumTemplate;
  std::vector<std::vector<L1GtJetCountsTemplate> > m_vecJetCountsTemplate;
  std::vector<std::vector<L1GtCastorTemplate> > m_vecCastorTemplate;
  std::vector<std::vector<L1GtHfBitCountsTemplate> > m_vecHfBitCountsTemplate;
  std::vector<std::vector<L1GtHfRingEtSumsTemplate> > m_vecHfRingEtSumsTemplate;
  std::vector<std::vector<L1GtBptxTemplate> > m_vecBptxTemplate;
  std::vector<std::vector<L1GtExternalTemplate> > m_vecExternalTemplate;
 
  std::vector<std::vector<L1GtCorrelationTemplate> > m_vecCorrelationTemplate;
  std::vector<std::vector<L1GtMuonTemplate> > m_corMuonTemplate;
  std::vector<std::vector<L1GtCaloTemplate> > m_corCaloTemplate;
  std::vector<std::vector<L1GtEnergySumTemplate> > m_corEnergySumTemplate;
 
  AlgorithmMap m_algorithmMap;
 
  AlgorithmMap m_algorithmAliasMap;
 
  AlgorithmMap m_technicalTriggerMap;
 
private:
  bool m_isDebugEnabled;
};
 
template <typename Result, typename Source>
Result L1GtTriggerMenuConfigOnlineProd::lexical_cast_from_hex(Source& value) const {
  std::stringstream convertor;
  convertor << value;
 
  Result result;
  if (!(convertor >> std::hex >> result) || !convertor.eof()) {
    throw boost::bad_lexical_cast();
  }
 
  return result;
}
 
#endif