L1GtTriggerMenuConfigOnlineProd.h

Go to the documentation of this file.

#ifndef L1GtConfigProducers_L1GtTriggerMenuConfigOnlineProd_h
#define L1GtConfigProducers_L1GtTriggerMenuConfigOnlineProd_h

// system include files

#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 std::exception();
  }

  return result;
}

#endif