---

L1GtMuonCondition.cc

Go to the documentation of this file.

// this class header
#include "L1Trigger/GlobalTrigger/interface/L1GtMuonCondition.h"

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

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

// user include files
//   base classes
#include "CondFormats/L1TObjects/interface/L1GtMuonTemplate.h"
#include "L1Trigger/GlobalTrigger/interface/L1GtConditionEvaluation.h"

#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"

#include "DataFormats/L1GlobalMuonTrigger/interface/L1MuGMTCand.h"

#include "L1Trigger/GlobalTrigger/interface/L1GlobalTriggerFunctions.h"
#include "L1Trigger/GlobalTrigger/interface/L1GlobalTriggerGTL.h"

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

// constructors
//     default
L1GtMuonCondition::L1GtMuonCondition() :
    L1GtConditionEvaluation() {

    // empty

}

//     from base template condition (from event setup usually)
L1GtMuonCondition::L1GtMuonCondition(const L1GtCondition* muonTemplate,
        const L1GlobalTriggerGTL* ptrGTL, const int nrL1Mu,
        const int ifMuEtaNumberBits) :
    L1GtConditionEvaluation(),
    m_gtMuonTemplate(static_cast<const L1GtMuonTemplate*>(muonTemplate)),
    m_gtGTL(ptrGTL),
    m_ifMuEtaNumberBits(ifMuEtaNumberBits)
{

    m_condMaxNumberObjects = nrL1Mu;
}

// copy constructor
void L1GtMuonCondition::copy(const L1GtMuonCondition &cp) {

    m_gtMuonTemplate = cp.gtMuonTemplate();
    m_gtGTL = cp.gtGTL();

    m_ifMuEtaNumberBits = cp.gtIfMuEtaNumberBits();

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

}

L1GtMuonCondition::L1GtMuonCondition(const L1GtMuonCondition& cp) :
    L1GtConditionEvaluation() {
    copy(cp);
}

// destructor
L1GtMuonCondition::~L1GtMuonCondition() {

    // empty

}

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

// methods
void L1GtMuonCondition::setGtMuonTemplate(const L1GtMuonTemplate* muonTempl) {

    m_gtMuonTemplate = muonTempl;

}

//   set the number of bits for eta of muon objects
void L1GtMuonCondition::setGtIfMuEtaNumberBits(const int& ifMuEtaNumberBitsValue) {

    m_ifMuEtaNumberBits = ifMuEtaNumberBitsValue;

}

void L1GtMuonCondition::setGtGTL(const L1GlobalTriggerGTL* ptrGTL) {

    m_gtGTL = ptrGTL;

}

// try all object permutations and check spatial correlations, if required
const bool L1GtMuonCondition::evaluateCondition() const {

    // number of trigger objects in the condition
    int nObjInCond = m_gtMuonTemplate->nrObjects();

    // the candidates
    const std::vector<const L1MuGMTCand*>* candVec = m_gtGTL->getCandL1Mu();
    
    int numberObjects = candVec->size();
    //LogTrace("L1GtCaloCondition") << "  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 jumpIndex = 1;
    int jump = factorial(numberObjects - nObjInCond);

    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 muon objects
    // from the combination evaluated in the condition
    SingleCombInCond objectsInComb;
    objectsInComb.reserve(nObjInCond);

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

    do {

        if (--jumpIndex)
            continue;

        jumpIndex = jump;
        totalLoops++;

        // clear the indices in the combination
        objectsInComb.clear();

        bool tmpResult = true;

        // check if there is a permutation that matches object-parameter requirements
        for (int i = 0; i < nObjInCond; i++) {

            tmpResult &= checkObjectParameter(i, *(*candVec)[index[i]]);
            objectsInComb.push_back(index[i]);

        }

        // if permutation does not match particle conditions
        // skip charge correlation and spatial correlations
        if ( !tmpResult) {

            continue;

        }

        // get the correlation parameters (chargeCorrelation included here also)
        L1GtMuonTemplate::CorrelationParameter corrPar =
            *(m_gtMuonTemplate->correlationParameter());

        // charge_correlation consists of 3 relevant bits (D2, D1, D0)
        unsigned int chargeCorr = corrPar.chargeCorrelation;

        // charge ignore bit (D0) not set?
        if (chargeCorr & 1 == 0) {

            for (int i = 0; i < nObjInCond; i++) {
                // check valid charge - skip if invalid charge
                bool chargeValid = (*candVec)[index[i]]->charge_valid();
                tmpResult &= chargeValid;

                if ( !chargeValid) {
                    continue;
                }
            }

            if ( !tmpResult) {
                continue;
            }

            if (nObjInCond == 1) { // one object condition

                // D2..enable pos, D1..enable neg
                if ( ! ( ( (chargeCorr & 4) != 0 && (*candVec)[index[0]]->charge()> 0 )
                    || ( (chargeCorr & 2) != 0 && (*candVec)[index[0]]->charge() < 0 ) )) {

                    continue;
                }

            }
            else { // more objects condition

                // find out if signs are equal
                bool equalSigns = true;
                for (int i = 0; i < nObjInCond-1; i++) {
                    if ((*candVec)[index[i]]->charge() != (*candVec)[index[i+1]]->charge()) {
                        equalSigns = false;
                        break;
                    }
                }

                // two or three particle condition
                if (nObjInCond == 2 || nObjInCond == 3) {
                    // D2..enable equal, D1..enable not equal
                    if ( ! ( ( (chargeCorr & 4) != 0 && equalSigns ) || ( (chargeCorr & 2) != 0
                        && !equalSigns ) )) {

                        continue;
                    }
                }

                // four particle condition
                if (nObjInCond == 4) {
                    //counter to count positive charges to determine if there are pairs
                    unsigned int posCount = 0;

                    for (int i = 0; i < nObjInCond; i++) {
                        if ((*candVec)[index[i]]->charge()> 0) {
                            posCount++;
                        }
                    }

                    // D2..enable equal, D1..enable pairs
                    if ( ! ( ( (chargeCorr & 4) != 0 && equalSigns ) || ( (chargeCorr & 2) != 0
                        && posCount == 2 ) )) {

                        continue;
                    }
                }
            }
        } // end signchecks


        if (m_gtMuonTemplate->wsc()) {

            // wsc requirements have always nObjInCond = 2
            // one can use directly index[0] and index[1] to compute
            // eta and phi differences
            const int ObjInWscComb = 2;
            if (nObjInCond != ObjInWscComb) {

                edm::LogError("L1GtMuonCondition") << "\n  Error: "
                    << "number of particles in condition with spatial correlation = " << nObjInCond
                    << "\n  it must be = " << ObjInWscComb << std::endl;
                // TODO Perhaps I should throw here an exception,
                // since something is really wrong if nObjInCond != ObjInWscComb (=2)
                continue;
            }

            unsigned int candDeltaEta;
            unsigned int candDeltaPhi;

            // check candDeltaEta

            // get eta index and the sign bit of the eta index (MSB is the sign)
            //   signedEta[i] is the signed eta index of (*candVec)[index[i]]
            int signedEta[ObjInWscComb];
            int signBit[ObjInWscComb] = { 0, 0 };

            int scaleEta = 1 << (m_ifMuEtaNumberBits - 1);

            for (int i = 0; i < ObjInWscComb; ++i) {
                signBit[i] = ((*candVec)[index[i]]->etaIndex() & scaleEta)>>(m_ifMuEtaNumberBits - 1);
                signedEta[i] = ((*candVec)[index[i]]->etaIndex() )%scaleEta;

                if (signBit[i] == 1) {
                    signedEta[i] = (-1)*signedEta[i];
                }

            }

            // compute candDeltaEta - add 1 if signs are different (due to +0/-0 indices)
            candDeltaEta = static_cast<int> (std::abs(signedEta[1] - signedEta[0]))
                + static_cast<int> (signBit[1]^signBit[0]);

            if ( !checkBit(corrPar.deltaEtaRange, candDeltaEta) ) {
                continue;
            }

            // check candDeltaPhi

            // calculate absolute value of candDeltaPhi
            if ((*candVec)[index[0]]->phiIndex()> (*candVec)[index[1]]->phiIndex()) {
                candDeltaPhi = (*candVec)[index[0]]->phiIndex() - (*candVec)[index[1]]->phiIndex();
            }
            else {
                candDeltaPhi = (*candVec)[index[1]]->phiIndex() - (*candVec)[index[0]]->phiIndex();
            }

            // check if candDeltaPhi > 180 (via delta_phi_maxbits)
            // delta_phi contains bits for 0..180 (0 and 180 included)
            while (candDeltaPhi> corrPar.deltaPhiMaxbits) {

                // candDeltaPhi > 180 ==> take 360 - candDeltaPhi
                candDeltaPhi = (corrPar.deltaPhiMaxbits - 1)*2 - candDeltaPhi;
                LogTrace("L1GtMuonCondition") << "  candDeltaPhi rescaled to: " << candDeltaPhi
                    << std::endl;
            }

            // delta_phi bitmask is saved in two boost::uint64_t words
            if (candDeltaPhi < 64) {
                if (!checkBit(corrPar.deltaPhiRange0Word, candDeltaPhi) ) {
                    continue;
                }
            }
            else {
                if (!checkBit(corrPar.deltaPhiRange1Word, (candDeltaPhi - 64))) {
                    continue;
                }
            }

        } // end wsc check

        // if we get here all checks were successfull for this combination
        // set the general result for evaluateCondition to "true"

        condResult = true;
        passLoops++;
        (*m_combinationsInCond).push_back(objectsInComb);

    } while (std::next_permutation(index.begin(), index.end()) );

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

    return condResult;

}

// load muon candidates
const L1MuGMTCand* L1GtMuonCondition::getCandidate(const int indexCand) const {

    return (*(m_gtGTL->getCandL1Mu()))[indexCand];
}

const bool L1GtMuonCondition::checkObjectParameter(const int iCondition, const L1MuGMTCand& cand) const {

    // number of objects in condition
    int nObjInCond = m_gtMuonTemplate->nrObjects();

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

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

    const L1GtMuonTemplate::ObjectParameter objPar = 
        ( *(m_gtMuonTemplate->objectParameter()) )[iCondition];

    // using the logic table from GTL-9U-module.pdf
    // "Truth table for Isolation bit"

    // check thresholds:

    //   value < low pt threshold
    //       fail trigger

    //   low pt threshold <= value < high pt threshold & non-isolated muon:
    //       requestIso true:                    fail trigger
    //       requestIso false, enableIso true:   fail trigger
    //       requestIso false, enableIso false:  OK,  trigger

    //   low pt threshold <= value < high pt threshold & isolated muon:
    //       requestIso true:                    OK,  trigger
    //       requestIso false, enableIso true:   OK,  trigger
    //       requestIso false, enableIso false:  OK,  trigger

    //   value >= high pt threshold & non-isolated muon:
    //       requestIso true:  fail trigger
    //       requestIso false: OK,  trigger

    //   value >= high pt threshold & isolated muon:
    //       OK, trigger


    if ( !checkThreshold(objPar.ptHighThreshold, cand.ptIndex(), m_gtMuonTemplate->condGEq()) ) {

        if ( !checkThreshold(objPar.ptLowThreshold, cand.ptIndex(), m_gtMuonTemplate->condGEq()) ) {

            return false;
        }
        else {

            // check isolation
            if ( !cand.isol() ) {
                if (objPar.requestIso || objPar.enableIso) {

                    return false;
                }
            }

        }

    }
    else {

        if ( !cand.isol() ) {
            if (objPar.requestIso) {

                return false;
            }
        }

    }

    // check eta

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

    // check phi  - in the requested range (no LUT used - LUT too big for hw chip)
    // for phiLow <= phiHigh takes [phiLow, phiHigh]
    // for phiLow >= phiHigh takes [phiLow, phiHigh] over zero angle!

    if (objPar.phiHigh >= objPar.phiLow) {

        if (! ( (objPar.phiLow <= cand.phiIndex()) && (cand.phiIndex() <= objPar.phiHigh ) )) {

            return false;
        }

    }
    else { // go over zero angle!!
        if (! ( (objPar.phiLow <= cand.phiIndex()) || (cand.phiIndex() <= objPar.phiHigh ) )) {

            return false;
        }
    }

    // check quality ( bit check )

    // A number of values is required to trigger (at least one).
    // "Don’t care" means that all values are allowed.
    // Qual = 000 means then NO MUON (GTL module)

    if (cand.quality() == 0) {
        return false;
    }

    if (objPar.qualityRange == 0) {
        return false;
    }
    else {
        if (!checkBit(objPar.qualityRange, cand.quality())) {
            return false;
        }
    }

    // check mip
    if (objPar.enableMip) {
        if (!cand.mip()) {

            return false;
        }
    }

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

    return true;
}

void L1GtMuonCondition::print(std::ostream& myCout) const {

    m_gtMuonTemplate->print(myCout);
    L1GtConditionEvaluation::print(myCout);

}

---