L1GlobalTriggerObjectMaps.h

Go to the documentation of this file.

#ifndef DataFormats_L1GlobalTrigger_L1GlobalTriggerObjectMaps_h
#define DataFormats_L1GlobalTrigger_L1GlobalTriggerObjectMaps_h
 
#include <vector>
 
#include "DataFormats/L1GlobalTrigger/interface/L1GtLogicParser.h"
#include "DataFormats/Provenance/interface/ParameterSetID.h"
 
class L1GlobalTriggerObjectMaps {
public:
  L1GlobalTriggerObjectMaps() {}
 
  ~L1GlobalTriggerObjectMaps() {}
 
  void swap(L1GlobalTriggerObjectMaps& rh);
 
  bool algorithmExists(int algorithmBitNumber) const;
 
  bool algorithmResult(int algorithmBitNumber) const;
 
  void updateOperandTokenVector(int algorithmBitNumber,
                                std::vector<L1GtLogicParser::OperandToken>& operandTokenVector) const;
 
  void getAlgorithmBitNumbers(std::vector<int>& algorithmBitNumbers) const;
 
  unsigned getNumberOfConditions(int algorithmBitNumber) const;
 
  class ConditionsInAlgorithm;
  class CombinationsInCondition;
 
  ConditionsInAlgorithm getConditionsInAlgorithm(int algorithmBitNumber) const;
 
  CombinationsInCondition getCombinationsInCondition(int algorithmBitNumber, unsigned conditionNumber) const;
 
  edm::ParameterSetID const& namesParameterSetID() const { return m_namesParameterSetID; }
 
  // the rest are methods used to fill the data
  // and should only be used by the producer that
  // creates these and puts them into the event.
  // There are requirements on ordering and the
  // stored indexes that the code that calls these
  // functions is expected to carefully take care of.
 
  void reserveForAlgorithms(unsigned n);
  void pushBackAlgorithm(unsigned startIndexOfConditions, int algorithmBitNumber, bool algorithmResult);
 
  // This function should be called after filling the data in this object
  // using the pushBack* methods.
  void consistencyCheck() const;
 
  void reserveForConditions(unsigned n);
  void pushBackCondition(unsigned startIndexOfCombinations,
                         unsigned short nObjectsPerCombination,
                         bool conditionResult);
 
  void reserveForObjectIndexes(unsigned n);
  void pushBackObjectIndex(unsigned char objectIndex);
 
  void setNamesParameterSetID(edm::ParameterSetID const& psetID);
 
  class AlgorithmResult {
  public:
    AlgorithmResult();
    AlgorithmResult(unsigned startIndexOfConditions, int algorithmBitNumber, bool algorithmResult);
    unsigned startIndexOfConditions() const { return m_startIndexOfConditions; }
    short algorithmBitNumber() const { return m_algorithmBitNumber; }
    bool algorithmResult() const { return m_algorithmResult; }
    // The operator is used for searching in the std::vector<AlgorithmResult>
    bool operator<(AlgorithmResult const& right) const { return m_algorithmBitNumber < right.algorithmBitNumber(); }
 
  private:
    unsigned m_startIndexOfConditions;
    short m_algorithmBitNumber;
    bool m_algorithmResult;
  };
 
  class ConditionResult {
  public:
    ConditionResult();
    ConditionResult(unsigned startIndexOfCombinations, unsigned short nObjectsPerCombination, bool conditionResult);
    unsigned startIndexOfCombinations() const { return m_startIndexOfCombinations; }
    unsigned short nObjectsPerCombination() const { return m_nObjectsPerCombination; }
    bool conditionResult() const { return m_conditionResult; }
 
  private:
    unsigned m_startIndexOfCombinations;
    unsigned short m_nObjectsPerCombination;
    bool m_conditionResult;
  };
 
  class ConditionsInAlgorithm {
  public:
    ConditionsInAlgorithm(ConditionResult const* conditionResults, unsigned nConditions);
    unsigned nConditions() const { return m_nConditions; }
    bool getConditionResult(unsigned condition) const;
 
  private:
    ConditionResult const* m_conditionResults;
    unsigned m_nConditions;
  };
 
  class CombinationsInCondition {
  public:
    CombinationsInCondition(unsigned char const* startOfObjectIndexes,
                            unsigned nCombinations,
                            unsigned short nObjectsPerCombination);
 
    unsigned nCombinations() const { return m_nCombinations; }
    unsigned short nObjectsPerCombination() const { return m_nObjectsPerCombination; }
    unsigned char getObjectIndex(unsigned combination, unsigned object) const;
 
  private:
    unsigned char const* m_startOfObjectIndexes;
    unsigned m_nCombinations;
    unsigned short m_nObjectsPerCombination;
  };
 
private:
  void getStartEndIndex(int algorithmBitNumber, unsigned& startIndex, unsigned& endIndex) const;
 
  // data members
  // The vectors are sorted. All three vectors are in algorithmBitNumber
  // order. The second two vectors are sorted such that within an algorithm
  // the conditions appear in the same order as in the algorithm logical
  // expression. And the third is additionally sorted so each combination
  // is contiguous and within a combination the order is the same as the
  // type specification in the L1 Trigger Menu.
  std::vector<AlgorithmResult> m_algorithmResults;
  std::vector<ConditionResult> m_conditionResults;
  std::vector<unsigned char> m_combinations;
  edm::ParameterSetID m_namesParameterSetID;
};
 
inline void swap(L1GlobalTriggerObjectMaps& lh, L1GlobalTriggerObjectMaps& rh) { lh.swap(rh); }
 
#endif