CaloCondition.cc

Go to the documentation of this file.

// this class header
#include "L1Trigger/L1TGlobal/interface/CaloCondition.h"

// system include files
#include <iostream>
#include <iomanip>

#include <string>
#include <vector>
#include <algorithm>

// user include files
//   base classes
#include "L1Trigger/L1TGlobal/interface/CaloTemplate.h"
#include "L1Trigger/L1TGlobal/interface/ConditionEvaluation.h"

#include "DataFormats/L1Trigger/interface/L1Candidate.h"

#include "L1Trigger/L1TGlobal/interface/GlobalBoard.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"

// constructors
//     default
l1t::CaloCondition::CaloCondition() : ConditionEvaluation() {
  m_ifCaloEtaNumberBits = -1;
  m_corrParDeltaPhiNrBins = 0;
}

//     from base template condition (from event setup usually)
l1t::CaloCondition::CaloCondition(const GlobalCondition* caloTemplate,
                                  const GlobalBoard* ptrGTB,
                                  const int nrL1EG,
                                  const int nrL1Jet,
                                  const int nrL1Tau,
                                  const int ifCaloEtaNumberBits)
    : ConditionEvaluation(),
      m_gtCaloTemplate(static_cast<const CaloTemplate*>(caloTemplate)),
      m_uGtB(ptrGTB),
      m_ifCaloEtaNumberBits(ifCaloEtaNumberBits) {
  m_corrParDeltaPhiNrBins = 0;

  // maximum number of  objects received for the evaluation of the condition
  // retrieved before from event setup
  // for a CondCalo, all objects ar of same type, hence it is enough to get the
  // type for the first object

  switch ((m_gtCaloTemplate->objectType())[0]) {
    case gtEG:
      m_condMaxNumberObjects = nrL1EG;
      break;

    case gtJet:
      m_condMaxNumberObjects = nrL1Jet;
      break;

    case gtTau:
      m_condMaxNumberObjects = nrL1Tau;
      break;
    default:
      m_condMaxNumberObjects = 0;
      break;
  }
}

// copy constructor
void l1t::CaloCondition::copy(const l1t::CaloCondition& cp) {
  m_gtCaloTemplate = cp.gtCaloTemplate();
  m_uGtB = cp.getuGtB();

  m_ifCaloEtaNumberBits = cp.gtIfCaloEtaNumberBits();
  m_corrParDeltaPhiNrBins = cp.m_corrParDeltaPhiNrBins;

  m_condMaxNumberObjects = cp.condMaxNumberObjects();
  m_condLastResult = cp.condLastResult();
  m_combinationsInCond = cp.getCombinationsInCond();

  m_verbosity = cp.m_verbosity;
}

l1t::CaloCondition::CaloCondition(const l1t::CaloCondition& cp) : ConditionEvaluation() { copy(cp); }

// destructor
l1t::CaloCondition::~CaloCondition() {
  // empty
}

// equal operator
l1t::CaloCondition& l1t::CaloCondition::operator=(const l1t::CaloCondition& cp) {
  copy(cp);
  return *this;
}

// methods
void l1t::CaloCondition::setGtCaloTemplate(const CaloTemplate* caloTempl) { m_gtCaloTemplate = caloTempl; }

void l1t::CaloCondition::setuGtB(const GlobalBoard* ptrGTB) { m_uGtB = ptrGTB; }

//   set the number of bits for eta of calorimeter objects
void l1t::CaloCondition::setGtIfCaloEtaNumberBits(const int& ifCaloEtaNumberBitsValue) {
  m_ifCaloEtaNumberBits = ifCaloEtaNumberBitsValue;
}

//   set the maximum number of bins for the delta phi scales
void l1t::CaloCondition::setGtCorrParDeltaPhiNrBins(const int& corrParDeltaPhiNrBins) {
  m_corrParDeltaPhiNrBins = corrParDeltaPhiNrBins;
}

// try all object permutations and check spatial correlations, if required
const bool l1t::CaloCondition::evaluateCondition(const int bxEval) const {
  // number of trigger objects in the condition
  int nObjInCond = m_gtCaloTemplate->nrObjects();
  //LogTrace("L1TGlobal") << "  nObjInCond: " << nObjInCond
  //    << std::endl;

  // the candidates

  // objectType() gives the type for nrObjects() only,
  // but in a CondCalo all objects have the same type
  // take type from the type of the first object

  const BXVector<const l1t::L1Candidate*>* candVec;

  switch ((m_gtCaloTemplate->objectType())[0]) {
    case gtEG:
      candVec = m_uGtB->getCandL1EG();
      break;

    case gtJet:
      candVec = m_uGtB->getCandL1Jet();
      break;

    case gtTau:
      candVec = m_uGtB->getCandL1Tau();
      break;

    default:
      return false;
      break;
  }

  // Look at objects in bx = bx + relativeBx
  int useBx = bxEval + m_gtCaloTemplate->condRelativeBx();

  // Fail condition if attempting to get Bx outside of range
  if ((useBx < candVec->getFirstBX()) || (useBx > candVec->getLastBX())) {
    return false;
  }

  int numberObjects = candVec->size(useBx);
  //LogTrace("L1TGlobal") << "  numberObjects: " << numberObjects
  //    << std::endl;
  if (numberObjects < nObjInCond) {
    return false;
  }

  std::vector<int> index(numberObjects);

  for (int i = 0; i < numberObjects; ++i) {
    index[i] = i;
  }

  int totalLoops = 0;
  int passLoops = 0;

  // condition result condResult set to true if at least one permutation
  //     passes all requirements
  // all possible permutations are checked
  bool condResult = false;

  // store the indices of the calorimeter objects
  // from the combination evaluated in the condition
  SingleCombInCond objectsInComb;
  objectsInComb.reserve(nObjInCond);

  // clear the m_combinationsInCond vector
  combinationsInCond().clear();

  if (nObjInCond == 1) {
    // clear the indices in the combination
    //objectsInComb.clear();

    for (int i = 0; i < numberObjects; i++) {
      // clear the indices in the combination
      objectsInComb.clear();

      totalLoops++;
      bool passCondition = checkObjectParameter(0, *(candVec->at(useBx, i)), index[i]);
      if (passCondition) {
        objectsInComb.push_back(i);
        condResult = true;
        passLoops++;
        combinationsInCond().push_back(objectsInComb);
      }
    }
  } else if (nObjInCond == 2) {
    for (int i = 0; i < numberObjects; i++) {
      bool passCondition0i = checkObjectParameter(0, *(candVec->at(useBx, i)), index[i]);
      bool passCondition1i = checkObjectParameter(1, *(candVec->at(useBx, i)), index[i]);

      if (!(passCondition0i || passCondition1i))
        continue;

      for (int j = 0; j < numberObjects; j++) {
        if (i == j)
          continue;
        totalLoops++;

        bool passCondition0j = checkObjectParameter(0, *(candVec->at(useBx, j)), index[i]);
        bool passCondition1j = checkObjectParameter(1, *(candVec->at(useBx, j)), index[i]);

        bool pass = ((passCondition0i && passCondition1j) || (passCondition0j && passCondition1i));

        if (pass) {
          if (m_gtCaloTemplate->wsc()) {
            // wsc requirements have always nObjInCond = 2
            // one can use directly 0] and 1] to compute
            // eta and phi differences
            const int ObjInWscComb = 2;
            if (nObjInCond != ObjInWscComb) {
              if (m_verbosity) {
                edm::LogError("L1TGlobal")
                    << "\n  Error: "
                    << "number of particles in condition with spatial correlation = " << nObjInCond
                    << "\n  it must be = " << ObjInWscComb << std::endl;
              }

              continue;
            }

            CaloTemplate::CorrelationParameter corrPar = *(m_gtCaloTemplate->correlationParameter());

            // check delta eta
            if (!checkRangeDeltaEta((candVec->at(useBx, i))->hwEta(),
                                    (candVec->at(useBx, j))->hwEta(),
                                    corrPar.deltaEtaRangeLower,
                                    corrPar.deltaEtaRangeUpper,
                                    7)) {
              LogDebug("L1TGlobal") << "\t\t l1t::Candidate failed checkRangeDeltaEta" << std::endl;
              continue;
            }

            // check delta phi
            if (!checkRangeDeltaPhi((candVec->at(useBx, i))->hwPhi(),
                                    (candVec->at(useBx, j))->hwPhi(),
                                    corrPar.deltaPhiRangeLower,
                                    corrPar.deltaPhiRangeUpper)) {
              LogDebug("L1TGlobal") << "\t\t l1t::Candidate failed checkRangeDeltaPhi" << std::endl;
              continue;
            }

          }  // end wsc check

          objectsInComb.clear();
          objectsInComb.push_back(i);
          objectsInComb.push_back(j);
          condResult = true;
          passLoops++;
          combinationsInCond().push_back(objectsInComb);
        }
      }
    }
  } else if (nObjInCond == 3) {
    for (int i = 0; i < numberObjects; i++) {
      bool passCondition0i = checkObjectParameter(0, *(candVec->at(useBx, i)), index[i]);
      bool passCondition1i = checkObjectParameter(1, *(candVec->at(useBx, i)), index[i]);
      bool passCondition2i = checkObjectParameter(2, *(candVec->at(useBx, i)), index[i]);

      if (!(passCondition0i || passCondition1i || passCondition2i))
        continue;

      for (int j = 0; j < numberObjects; j++) {
        if (i == j)
          continue;

        bool passCondition0j = checkObjectParameter(0, *(candVec->at(useBx, j)), index[i]);
        bool passCondition1j = checkObjectParameter(1, *(candVec->at(useBx, j)), index[i]);
        bool passCondition2j = checkObjectParameter(2, *(candVec->at(useBx, j)), index[i]);

        if (!(passCondition0j || passCondition1j || passCondition2j))
          continue;

        for (int k = 0; k < numberObjects; k++) {
          if (k == i || k == j)
            continue;
          totalLoops++;

          bool passCondition0k = checkObjectParameter(0, *(candVec->at(useBx, k)), index[i]);
          bool passCondition1k = checkObjectParameter(1, *(candVec->at(useBx, k)), index[i]);
          bool passCondition2k = checkObjectParameter(2, *(candVec->at(useBx, k)), index[i]);

          bool pass = ((passCondition0i && passCondition1j && passCondition2k) ||
                       (passCondition0i && passCondition1k && passCondition2j) ||
                       (passCondition0j && passCondition1k && passCondition2i) ||
                       (passCondition0j && passCondition1i && passCondition2k) ||
                       (passCondition0k && passCondition1i && passCondition2j) ||
                       (passCondition0k && passCondition1j && passCondition2i));
          if (pass) {
            condResult = true;
            passLoops++;
            objectsInComb.clear();
            objectsInComb.push_back(i);
            objectsInComb.push_back(j);
            objectsInComb.push_back(k);
            combinationsInCond().push_back(objectsInComb);
          }
        }  // end loop on k
      }    // end loop on j
    }      // end loop on i
  }        // end if condition has 3 objects
  else if (nObjInCond == 4) {
    for (int i = 0; i < numberObjects; i++) {
      bool passCondition0i = checkObjectParameter(0, *(candVec->at(useBx, i)), index[i]);
      bool passCondition1i = checkObjectParameter(1, *(candVec->at(useBx, i)), index[i]);
      bool passCondition2i = checkObjectParameter(2, *(candVec->at(useBx, i)), index[i]);
      bool passCondition3i = checkObjectParameter(3, *(candVec->at(useBx, i)), index[i]);

      if (!(passCondition0i || passCondition1i || passCondition2i || passCondition3i))
        continue;

      for (int j = 0; j < numberObjects; j++) {
        if (j == i)
          continue;

        bool passCondition0j = checkObjectParameter(0, *(candVec->at(useBx, j)), index[i]);
        bool passCondition1j = checkObjectParameter(1, *(candVec->at(useBx, j)), index[i]);
        bool passCondition2j = checkObjectParameter(2, *(candVec->at(useBx, j)), index[i]);
        bool passCondition3j = checkObjectParameter(3, *(candVec->at(useBx, j)), index[i]);

        if (!(passCondition0j || passCondition1j || passCondition2j || passCondition3j))
          continue;

        for (int k = 0; k < numberObjects; k++) {
          if (k == i || k == j)
            continue;

          bool passCondition0k = checkObjectParameter(0, *(candVec->at(useBx, k)), index[i]);
          bool passCondition1k = checkObjectParameter(1, *(candVec->at(useBx, k)), index[i]);
          bool passCondition2k = checkObjectParameter(2, *(candVec->at(useBx, k)), index[i]);
          bool passCondition3k = checkObjectParameter(3, *(candVec->at(useBx, k)), index[i]);

          if (!(passCondition0k || passCondition1k || passCondition2k || passCondition3k))
            continue;

          for (int m = 0; m < numberObjects; m++) {
            if (m == i || m == j || m == k)
              continue;
            totalLoops++;

            bool passCondition0m = checkObjectParameter(0, *(candVec->at(useBx, m)), index[i]);
            bool passCondition1m = checkObjectParameter(1, *(candVec->at(useBx, m)), index[i]);
            bool passCondition2m = checkObjectParameter(2, *(candVec->at(useBx, m)), index[i]);
            bool passCondition3m = checkObjectParameter(3, *(candVec->at(useBx, m)), index[i]);

            bool pass = ((passCondition0i && passCondition1j && passCondition2k && passCondition3m) ||
                         (passCondition0i && passCondition1j && passCondition2m && passCondition3k) ||
                         (passCondition0i && passCondition1k && passCondition2j && passCondition3m) ||
                         (passCondition0i && passCondition1k && passCondition2m && passCondition3j) ||
                         (passCondition0i && passCondition1m && passCondition2j && passCondition3k) ||
                         (passCondition0i && passCondition1m && passCondition2k && passCondition3j) ||
                         (passCondition0j && passCondition1i && passCondition2k && passCondition3m) ||
                         (passCondition0j && passCondition1i && passCondition2m && passCondition3k) ||
                         (passCondition0j && passCondition1k && passCondition2i && passCondition3m) ||
                         (passCondition0j && passCondition1k && passCondition2m && passCondition3i) ||
                         (passCondition0j && passCondition1m && passCondition2i && passCondition3k) ||
                         (passCondition0j && passCondition1m && passCondition2k && passCondition3i) ||
                         (passCondition0k && passCondition1i && passCondition2j && passCondition3m) ||
                         (passCondition0k && passCondition1i && passCondition2m && passCondition3j) ||
                         (passCondition0k && passCondition1j && passCondition2i && passCondition3m) ||
                         (passCondition0k && passCondition1j && passCondition2m && passCondition3i) ||
                         (passCondition0k && passCondition1m && passCondition2i && passCondition3j) ||
                         (passCondition0k && passCondition1m && passCondition2j && passCondition3i) ||
                         (passCondition0m && passCondition1i && passCondition2j && passCondition3k) ||
                         (passCondition0m && passCondition1i && passCondition2k && passCondition3j) ||
                         (passCondition0m && passCondition1j && passCondition2i && passCondition3k) ||
                         (passCondition0m && passCondition1j && passCondition2k && passCondition3i) ||
                         (passCondition0m && passCondition1k && passCondition2i && passCondition3j) ||
                         (passCondition0m && passCondition1k && passCondition2j && passCondition3i));
            if (pass) {
              objectsInComb.clear();
              objectsInComb.push_back(i);
              objectsInComb.push_back(j);
              objectsInComb.push_back(k);
              objectsInComb.push_back(m);
              condResult = true;
              passLoops++;
              combinationsInCond().push_back(objectsInComb);
            }
          }  // end loop on m
        }    // end loop on k
      }      // end loop on j
    }        // end loop on i
  }          // end if condition has 4 objects

  LogTrace("L1TGlobal") << "\n  CaloCondition: total number of permutations found:          " << totalLoops
                        << "\n  CaloCondition: number of permutations passing requirements: " << passLoops << "\n"
                        << std::endl;

  return condResult;
}

// load calo candidates
const l1t::L1Candidate* l1t::CaloCondition::getCandidate(const int bx, const int indexCand) const {
  // objectType() gives the type for nrObjects() only,
  // but in a CondCalo all objects have the same type
  // take type from the type of the first object
  switch ((m_gtCaloTemplate->objectType())[0]) {
    case gtEG:
      return (m_uGtB->getCandL1EG())->at(bx, indexCand);
      break;

    case gtJet:
      return (m_uGtB->getCandL1Jet())->at(bx, indexCand);
      break;

    case gtTau:
      return (m_uGtB->getCandL1Tau())->at(bx, indexCand);
      break;
    default:
      return nullptr;
      break;
  }

  return nullptr;
}

const bool l1t::CaloCondition::checkObjectParameter(const int iCondition,
                                                    const l1t::L1Candidate& cand,
                                                    unsigned int index) const {
  // number of objects in condition
  int nObjInCond = m_gtCaloTemplate->nrObjects();

  if (iCondition >= nObjInCond || iCondition < 0) {
    return false;
  }

  // empty candidates can not be compared
  //     if (cand.empty()) {
  //         return false;
  //     }

  const CaloTemplate::ObjectParameter objPar = (*(m_gtCaloTemplate->objectParameter()))[iCondition];

  LogDebug("L1TGlobal") << "\n CaloTemplate: "
                        << "\n\t condRelativeBx = " << m_gtCaloTemplate->condRelativeBx() << "\n ObjectParameter : "
                        << "\n\t etThreshold = " << objPar.etLowThreshold << " - " << objPar.etHighThreshold
                        << "\n\t indexRange  = " << objPar.indexLow << " - " << objPar.indexHigh
                        << "\n\t etaRange    = " << objPar.etaRange << "\n\t phiRange    = " << objPar.phiRange
                        << "\n\t isolationLUT= " << objPar.isolationLUT << std::endl;

  LogDebug("L1TGlobal") << "\n l1t::Candidate : "
                        << "\n\t hwPt   = " << cand.hwPt() << "\n\t hwEta  = " << cand.hwEta()
                        << "\n\t hwPhi  = " << cand.hwPhi() << std::endl;

  // check energy threshold
  if (!checkThreshold(objPar.etLowThreshold, objPar.etHighThreshold, cand.hwPt(), m_gtCaloTemplate->condGEq())) {
    LogDebug("L1TGlobal") << "\t\t l1t::Candidate failed checkThreshold" << std::endl;
    return false;
  }

  // check index
  if (!checkIndex(objPar.indexLow, objPar.indexHigh, index)) {
    LogDebug("L1TGlobal") << "\t\t ilt::Candidate Failed checkIndex " << std::endl;
    return false;
  }

  // check eta
  if (!checkRangeEta(cand.hwEta(),
                     objPar.etaWindow1Lower,
                     objPar.etaWindow1Upper,
                     objPar.etaWindow2Lower,
                     objPar.etaWindow2Upper,
                     7)) {
    LogDebug("L1TGlobal") << "\t\t l1t::Candidate failed checkRange(eta)" << std::endl;
    return false;
  }

  //     if (!checkBit(objPar.etaRange, cand.hwEta())) {
  //         return false;
  //     }

  // check phi
  if (!checkRangePhi(cand.hwPhi(),
                     objPar.phiWindow1Lower,
                     objPar.phiWindow1Upper,
                     objPar.phiWindow2Lower,
                     objPar.phiWindow2Upper)) {
    LogDebug("L1TGlobal") << "\t\t l1t::Candidate failed checkRange(phi)" << std::endl;
    return false;
  }

  // check isolation ( bit check ) with isolation LUT
  // sanity check on candidate isolation
  if (cand.hwIso() > 4) {
    LogDebug("L1TGlobal") << "\t\t l1t::Candidate has out of range hwIso = " << cand.hwIso() << std::endl;
    return false;
  }
  bool passIsoLUT = ((objPar.isolationLUT >> cand.hwIso()) & 1);
  if (!passIsoLUT) {
    LogDebug("L1TGlobal") << "\t\t l1t::Candidate failed isolation requirement" << std::endl;
    return false;
  }
  //     if (!checkBit(objPar.phiRange, cand.hwPhi())) {
  //         return false;
  //     }

  // particle matches if we get here
  //LogTrace("L1TGlobal")
  //    << "  checkObjectParameter: calorimeter object OK, passes all requirements\n"
  //    << std::endl;

  return true;
}

void l1t::CaloCondition::print(std::ostream& myCout) const {
  m_gtCaloTemplate->print(myCout);

  myCout << "    Number of bits for eta of calorimeter objects = " << m_ifCaloEtaNumberBits << std::endl;
  myCout << "    Maximum number of bins for the delta phi scales = " << m_corrParDeltaPhiNrBins << "\n " << std::endl;

  ConditionEvaluation::print(myCout);
}