l1t::CorrWithOverlapRemovalCondition Class Reference

#include <CorrWithOverlapRemovalCondition.h>

Inheritance diagram for l1t::CorrWithOverlapRemovalCondition:

Public Member Functions
	CorrWithOverlapRemovalCondition ()
	CorrWithOverlapRemovalCondition (const GlobalCondition *, const GlobalCondition *, const GlobalCondition *, const GlobalCondition *, const GlobalBoard *)
	from base template condition (from event setup usually) More...
	CorrWithOverlapRemovalCondition (const CorrWithOverlapRemovalCondition &)
const bool	evaluateCondition (const int bxEval) const override
	the core function to check if the condition matches More...
const GlobalBoard *	getuGtB () const
	get / set the pointer to uGt GlobalBoard More...
const CorrelationWithOverlapRemovalTemplate *	gtCorrelationWithOverlapRemovalTemplate () const
	get / set the pointer to a Condition More...
CorrWithOverlapRemovalCondition &	operator= (const CorrWithOverlapRemovalCondition &)
void	print (std::ostream &myCout) const override
	print condition More...
void	setGtCorrelationWithOverlapRemovalTemplate (const CorrelationWithOverlapRemovalTemplate *)
void	setScales (const GlobalScales *)
void	setuGtB (const GlobalBoard *)
	set the pointer to uGT GlobalBoard More...
	~CorrWithOverlapRemovalCondition () override
Public Member Functions inherited from l1t::ConditionEvaluation
	ConditionEvaluation ()
	constructor More...
bool	condLastResult () const
	get the latest result for the condition More...
int	condMaxNumberObjects () const
void	evaluateConditionStoreResult (const int bxEval)
	call evaluateCondition and save last result More...
CombinationsInCond const &	getCombinationsInCond () const
	get all the object combinations evaluated to true in the condition More...
virtual std::string	getNumericExpression () const
	get numeric expression More...
void	setCondMaxNumberObjects (int condMaxNumberObjectsValue)
void	setVerbosity (const int verbosity)
virtual	~ConditionEvaluation ()
	destructor More...

Private Member Functions
const bool	checkObjectParameter (const int iCondition, const l1t::L1Candidate &cand) const
	function to check a single object if it matches a condition More...
void	copy (const CorrWithOverlapRemovalCondition &cp)
	copy function for copy constructor and operator= More...
const l1t::L1Candidate *	getCandidate (const int bx, const int indexCand) const
	load candidates More...

Private Attributes
const GlobalCondition *	m_gtCond0
const GlobalCondition *	m_gtCond1
const GlobalCondition *	m_gtCond2
const CorrelationWithOverlapRemovalTemplate *	m_gtCorrelationWithOverlapRemovalTemplate
	pointer to a CorrelationWithOverlapRemovalTemplate More...
const GlobalScales *	m_gtScales
const GlobalBoard *	m_uGtB
	pointer to uGt GlobalBoard, to be able to get the trigger objects More...

Additional Inherited Members
Protected Member Functions inherited from l1t::ConditionEvaluation
template<class Type1 >
const bool	checkBit (const Type1 &mask, const unsigned int bitNumber) const
	check if a bit with a given number is set in a mask More...
template<class Type1 >
const bool	checkIndex (const Type1 &indexLo, const Type1 &indexHi, const unsigned int index) const
	check if a index is in a given range More...
template<class Type1 >
const bool	checkRangeDeltaEta (const unsigned int obj1Eta, const unsigned int obj2Eta, const Type1 &lowerR, const Type1 &upperR, const unsigned int nEtaBits) const
	check if a value is in a given range More...
template<class Type1 >
const bool	checkRangeDeltaPhi (const unsigned int obj1Phi, const unsigned int obj2Phi, const Type1 &lowerR, const Type1 &upperR) const
	check if a value is in a given range More...
template<class Type1 >
const bool	checkRangeEta (const unsigned int bitNumber, const Type1 &W1beginR, const Type1 &W1endR, const Type1 &W2beginR, const Type1 &W2endR, const unsigned int nEtaBits) const
	check if a value is in a given range and outside of a veto range More...
template<class Type1 >
const bool	checkRangePhi (const unsigned int bitNumber, const Type1 &W1beginR, const Type1 &W1endR, const Type1 &W2beginR, const Type1 &W2endR) const
	check if a value is in a given range and outside of a veto range More...
template<class Type1 , class Type2 >
const bool	checkThreshold (const Type1 &thresholdL, const Type1 &thresholdH, const Type2 &value, bool condGEqValue) const
CombinationsInCond &	combinationsInCond () const
	get all the object combinations (to fill it...) More...
Protected Attributes inherited from l1t::ConditionEvaluation
CombinationsInCond	m_combinationsInCond
	store all the object combinations evaluated to true in the condition More...
bool	m_condLastResult
	the last result of evaluateCondition() More...
int	m_condMaxNumberObjects
int	m_verbosity
	verbosity level More...

Detailed Description

Definition at line 39 of file CorrWithOverlapRemovalCondition.h.

Constructor & Destructor Documentation

CorrWithOverlapRemovalCondition::CorrWithOverlapRemovalCondition

(

)

constructors default

Definition at line 77 of file CorrWithOverlapRemovalCondition.cc.

                                                                    :
    ConditionEvaluation() {

}

CorrWithOverlapRemovalCondition::CorrWithOverlapRemovalCondition	(	const GlobalCondition *	corrTemplate,
		const GlobalCondition *	cond0Condition,
		const GlobalCondition *	cond1Condition,
		const GlobalCondition *	cond2Condition,
		const GlobalBoard *	ptrGTB
	)

from base template condition (from event setup usually)

Definition at line 83 of file CorrWithOverlapRemovalCondition.cc.

          :
    ConditionEvaluation(),
    m_gtCorrelationWithOverlapRemovalTemplate(static_cast<const CorrelationWithOverlapRemovalTemplate*>(corrTemplate)),
    m_gtCond0(cond0Condition), m_gtCond1(cond1Condition), m_gtCond2(cond2Condition),
    m_uGtB(ptrGTB)
{



}

CorrWithOverlapRemovalCondition::CorrWithOverlapRemovalCondition

(

const CorrWithOverlapRemovalCondition &

cp

)

Definition at line 113 of file CorrWithOverlapRemovalCondition.cc.

References copy().

                                                                                                                :
    ConditionEvaluation() {

    copy(cp);

}

CorrWithOverlapRemovalCondition::~CorrWithOverlapRemovalCondition ( )

override

Definition at line 121 of file CorrWithOverlapRemovalCondition.cc.

                                                                     {

    // empty

}

Member Function Documentation

const bool CorrWithOverlapRemovalCondition::checkObjectParameter ( const int  iCondition, const l1t::L1Candidate &  cand  ) const

private

function to check a single object if it matches a condition

checkObjectParameter - Compare a single particle with a numbered condition.

Parameters

iCondition	The number of the condition.
cand	The candidate to compare.

Returns

The result of the comparison (false if a condition does not exist).

Definition at line 2247 of file CorrWithOverlapRemovalCondition.cc.

Referenced by getuGtB().

                                                                                                                          {


    return true;
}

void CorrWithOverlapRemovalCondition::copy ( const CorrWithOverlapRemovalCondition &  cp )

private

copy function for copy constructor and operator=

Definition at line 100 of file CorrWithOverlapRemovalCondition.cc.

References l1t::ConditionEvaluation::condLastResult(), l1t::ConditionEvaluation::condMaxNumberObjects(), l1t::ConditionEvaluation::getCombinationsInCond(), getuGtB(), gtCorrelationWithOverlapRemovalTemplate(), l1t::ConditionEvaluation::m_combinationsInCond, l1t::ConditionEvaluation::m_condLastResult, l1t::ConditionEvaluation::m_condMaxNumberObjects, m_gtCorrelationWithOverlapRemovalTemplate, m_uGtB, and l1t::ConditionEvaluation::m_verbosity.

Referenced by CorrWithOverlapRemovalCondition(), getuGtB(), and operator=().

                                                                                          {

    m_gtCorrelationWithOverlapRemovalTemplate = cp.gtCorrelationWithOverlapRemovalTemplate();
    m_uGtB = cp.getuGtB();

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

    m_verbosity = cp.m_verbosity;

}

const bool CorrWithOverlapRemovalCondition::evaluateCondition ( const int  bxEval ) const

overridevirtual

the core function to check if the condition matches

Implements l1t::ConditionEvaluation.

Definition at line 156 of file CorrWithOverlapRemovalCondition.cc.

References funct::abs(), BXVector< T >::at(), CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::chargeCorrelation, hitfit::clear(), l1t::ConditionEvaluation::combinationsInCond(), CorrelationWithOverlapRemovalTemplate::cond0Category(), CorrelationWithOverlapRemovalTemplate::cond1Category(), CorrelationWithOverlapRemovalTemplate::cond2Category(), l1t::CondCalo, l1t::CondEnergySum, l1t::ConditionEvaluation::condLastResult(), l1t::CondMuon, GlobalCondition::condRelativeBx(), CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::corrCutType, CorrelationWithOverlapRemovalTemplate::correlationParameter(), funct::cos(), conversionPostprocessing_cfi::etaBin2, l1t::GlobalScales::ScaleParameters::etaBins, l1t::GlobalScales::ScaleParameters::etBins, l1t::ConditionEvaluation::evaluateConditionStoreResult(), l1t::GlobalBoard::getCandL1EG(), l1t::GlobalBoard::getCandL1EtSum(), l1t::GlobalBoard::getCandL1Jet(), l1t::GlobalBoard::getCandL1Mu(), l1t::GlobalBoard::getCandL1Tau(), l1t::ConditionEvaluation::getCombinationsInCond(), l1t::GlobalScales::getEGScales(), l1t::GlobalScales::getETMHFScales(), l1t::GlobalScales::getETMScales(), l1t::GlobalScales::getHTMScales(), l1t::GlobalScales::getJETScales(), l1t::GlobalScales::getLUT_CalMuEta(), l1t::GlobalScales::getLUT_CalMuPhi(), l1t::GlobalScales::getLUT_Cos(), l1t::GlobalScales::getLUT_DeltaEta(), l1t::GlobalScales::getLUT_DeltaEta_Cosh(), l1t::GlobalScales::getLUT_DeltaPhi(), l1t::GlobalScales::getLUT_DeltaPhi_Cos(), l1t::GlobalScales::getLUT_Pt(), l1t::GlobalScales::getLUT_Sin(), l1t::GlobalScales::getMUScales(), l1t::GlobalScales::getPrec_Cos(), l1t::GlobalScales::getPrec_DeltaEta(), l1t::GlobalScales::getPrec_DeltaEta_Cosh(), l1t::GlobalScales::getPrec_DeltaPhi(), l1t::GlobalScales::getPrec_DeltaPhi_Cos(), l1t::GlobalScales::getPrec_Pt(), l1t::GlobalScales::getPrec_Sin(), l1t::GlobalScales::getTAUScales(), l1t::gtEG, l1t::gtETM, l1t::gtETMHF, l1t::gtETT, l1t::gtETTem, l1t::gtHTM, l1t::gtHTT, l1t::gtJet, l1t::gtMinBiasHFM0, l1t::gtMinBiasHFM1, l1t::gtMinBiasHFP0, l1t::gtMinBiasHFP1, l1t::gtTau, createfilelist::int, L1Analysis::kMinBiasHFP0, L1Analysis::kMissingEt, L1Analysis::kMissingEtHF, L1Analysis::kMissingHt, L1Analysis::kTotalEt, L1Analysis::kTotalEtEm, L1Analysis::kTotalHt, l1t::l1TGtObjectEnumToString(), LogDebug, LogTrace, m_gtCond0, m_gtCond1, m_gtCond2, m_gtCorrelationWithOverlapRemovalTemplate, m_gtScales, M_PI, m_uGtB, l1t::ConditionEvaluation::m_verbosity, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::maxDRCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::maxEtaCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::maxMassCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::maxOverlapRemovalDRCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::maxOverlapRemovalEtaCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::maxOverlapRemovalPhiCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::maxPhiCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::maxTBPTCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::minDRCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::minEtaCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::minMassCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::minOverlapRemovalDRCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::minOverlapRemovalEtaCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::minOverlapRemovalPhiCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::minPhiCutValue, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::minTBPTCutValue, GlobalCondition::objectType(), l1t::GlobalScales::ScaleParameters::phiBins, l1t::GlobalScales::ScaleParameters::phiMax, l1t::GlobalScales::ScaleParameters::phiMin, l1t::GlobalScales::ScaleParameters::phiStep, funct::pow(), CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::precDRCut, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::precEtaCut, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::precMassCut, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::precOverlapRemovalDRCut, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::precOverlapRemovalEtaCut, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::precOverlapRemovalPhiCut, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::precPhiCut, CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter::precTBPTCut, l1t::EnergySumCondition::print(), l1t::MuCondition::print(), l1t::CaloCondition::print(), funct::sin(), BXVector< T >::size(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, globals_cff::x1, and globals_cff::x2.

                                                                                       {

    // std::cout << "m_isDebugEnabled = " << m_isDebugEnabled << std::endl;
    // std::cout << "m_verbosity = " << m_verbosity << std::endl;


    //std::ostringstream myCout;
    //m_gtCorrelationWithOverlapRemovalTemplate->print(myCout);
    //LogDebug("L1TGlobal")
    //   << "CorrelationWithOverlapRemoval Condition Evaluation \n" << myCout.str() << std::endl;

    bool condResult = false;
    bool reqObjResult = false;

    // number of objects in condition (it is 3, no need to retrieve from
    // condition template) and their type
    int nObjInCond = 3;
    std::vector<GlobalObject> cndObjTypeVec(nObjInCond);

    // evaluate first the two sub-conditions (Type1s)

    const GtConditionCategory cond0Categ = m_gtCorrelationWithOverlapRemovalTemplate->cond0Category();
    const GtConditionCategory cond1Categ = m_gtCorrelationWithOverlapRemovalTemplate->cond1Category();
    const GtConditionCategory cond2Categ = m_gtCorrelationWithOverlapRemovalTemplate->cond2Category();

    //Decide if we have a mixed (muon + cal) condition
    bool convertCaloScales = false;
    if( (cond0Categ == CondMuon && (cond1Categ == CondCalo || cond1Categ == CondEnergySum) )  ||
        (cond1Categ == CondMuon && (cond0Categ == CondCalo || cond0Categ == CondEnergySum) ) )
    convertCaloScales = true;

    bool convertCaloScalesForOverlapRemovalFromLeg0 = false;
    if( (cond0Categ == CondMuon && (cond2Categ == CondCalo || cond2Categ == CondEnergySum) )  ||
        (cond2Categ == CondMuon && (cond0Categ == CondCalo || cond0Categ == CondEnergySum) ) )
    convertCaloScalesForOverlapRemovalFromLeg0 = true;

    bool convertCaloScalesForOverlapRemovalFromLeg1 = false;
    if( (cond1Categ == CondMuon && (cond2Categ == CondCalo || cond2Categ == CondEnergySum) )  ||
        (cond2Categ == CondMuon && (cond1Categ == CondCalo || cond1Categ == CondEnergySum) ) )
    convertCaloScalesForOverlapRemovalFromLeg1 = true;

    const MuonTemplate* corrMuon = nullptr;
    const CaloTemplate* corrCalo = nullptr;
    const EnergySumTemplate* corrEnergySum = nullptr;

    // FIXME copying is slow...
    CombinationsInCond cond0Comb;
    CombinationsInCond cond1Comb;
    CombinationsInCond cond2Comb;

    int cond0bx(0);
    int cond1bx(0);
    int cond2bx(0);

    switch (cond0Categ) {
        case CondMuon: {
            corrMuon = static_cast<const MuonTemplate*>(m_gtCond0);
            MuCondition muCondition(corrMuon, m_uGtB,
                    0,0); //BLW these are counts that don't seem to be used...perhaps remove

            muCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = muCondition.condLastResult();

            cond0Comb = (muCondition.getCombinationsInCond());
            cond0bx = bxEval + (corrMuon->condRelativeBx());

            cndObjTypeVec[0] = (corrMuon->objectType())[0];

            if (m_verbosity ) {
                std::ostringstream myCout;
                muCondition.print(myCout);

                LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }
        }
            break;
        case CondCalo: {
            corrCalo = static_cast<const CaloTemplate*>(m_gtCond0);

            CaloCondition caloCondition(corrCalo, m_uGtB,
                    0, 0, 0, 0); //BLW these are counters that don't seem to be used...perhaps remove.

            caloCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = caloCondition.condLastResult();

            cond0Comb = (caloCondition.getCombinationsInCond());
            cond0bx = bxEval + (corrCalo->condRelativeBx());

            cndObjTypeVec[0] = (corrCalo->objectType())[0];

            if (m_verbosity) {
                std::ostringstream myCout;
                caloCondition.print(myCout);

                LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }
        }
            break;
        case CondEnergySum: {

            corrEnergySum = static_cast<const EnergySumTemplate*>(m_gtCond0);
            EnergySumCondition eSumCondition(corrEnergySum, m_uGtB);

            eSumCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = eSumCondition.condLastResult();

            cond0Comb = (eSumCondition.getCombinationsInCond());
            cond0bx = bxEval + (corrEnergySum->condRelativeBx());

            cndObjTypeVec[0] = (corrEnergySum->objectType())[0];

            if (m_verbosity ) {
                std::ostringstream myCout;
                eSumCondition.print(myCout);

                LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }
        }
            break;
        default: {
            // should not arrive here, there are no correlation conditions defined for this object
            return false;
        }
            break;
    }

    // return if first subcondition is false
    if (!reqObjResult) {
            LogDebug("L1TGlobal")
                    << "\n  First sub-condition false, second sub-condition not evaluated and not printed."
                    << std::endl;
        return false;
    }

    // second object
    reqObjResult = false;

    switch (cond1Categ) {
        case CondMuon: {
            corrMuon = static_cast<const MuonTemplate*>(m_gtCond1);
            MuCondition muCondition(corrMuon, m_uGtB,
                    0,0); //BLW these are counts that don't seem to be used...perhaps remove

            muCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = muCondition.condLastResult();

            cond1Comb = (muCondition.getCombinationsInCond());
            cond1bx = bxEval + (corrMuon->condRelativeBx());
            cndObjTypeVec[1] = (corrMuon->objectType())[0];

            if (m_verbosity) {
                std::ostringstream myCout;
                muCondition.print(myCout);

               LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }
        }
            break;
        case CondCalo: {
            corrCalo = static_cast<const CaloTemplate*>(m_gtCond1);
            CaloCondition caloCondition(corrCalo, m_uGtB,
                    0, 0, 0, 0); //BLW these are counters that don't seem to be used...perhaps remove.

            caloCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = caloCondition.condLastResult();

            cond1Comb = (caloCondition.getCombinationsInCond());
            cond1bx = bxEval + (corrCalo->condRelativeBx());

            cndObjTypeVec[1] = (corrCalo->objectType())[0];

            if (m_verbosity ) {
                std::ostringstream myCout;
                caloCondition.print(myCout);

                LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }

        }
            break;
        case CondEnergySum: {
            corrEnergySum = static_cast<const EnergySumTemplate*>(m_gtCond1);

            EnergySumCondition eSumCondition(corrEnergySum, m_uGtB);

            eSumCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = eSumCondition.condLastResult();

            cond1Comb = (eSumCondition.getCombinationsInCond());
            cond1bx = bxEval + (corrEnergySum->condRelativeBx());
            cndObjTypeVec[1] = (corrEnergySum->objectType())[0];

            if (m_verbosity) {
                std::ostringstream myCout;
                eSumCondition.print(myCout);

                LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }
        }
            break;
        default: {
            // should not arrive here, there are no correlation conditions defined for this object
            return false;
        }
            break;
    }

    // return if second sub-condition is false
    if (!reqObjResult) {
        return false;
    } else {
        LogDebug("L1TGlobal") << "\n"
                << "    Both sub-conditions true for object requirements."
                << "    Evaluate correlation requirements.\n" << std::endl;

    }

    // third object (used for overlap removal)
    reqObjResult = false;

    switch (cond2Categ) {
        case CondMuon: {
            corrMuon = static_cast<const MuonTemplate*>(m_gtCond2);
            MuCondition muCondition(corrMuon, m_uGtB,
                    0,0); //BLW these are counts that don't seem to be used...perhaps remove

            muCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = muCondition.condLastResult();

            cond2Comb = (muCondition.getCombinationsInCond());
            cond2bx = bxEval + (corrMuon->condRelativeBx());
            cndObjTypeVec[2] = (corrMuon->objectType())[0];

            if (m_verbosity) {
                std::ostringstream myCout;
                muCondition.print(myCout);

               LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }
        }
            break;
        case CondCalo: {
            corrCalo = static_cast<const CaloTemplate*>(m_gtCond2);
            CaloCondition caloCondition(corrCalo, m_uGtB,
                    0, 0, 0, 0); //BLW these are counters that don't seem to be used...perhaps remove.

            caloCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = caloCondition.condLastResult();

            cond2Comb = (caloCondition.getCombinationsInCond());
            cond2bx = bxEval + (corrCalo->condRelativeBx());
            cndObjTypeVec[2] = (corrCalo->objectType())[0];

            if (m_verbosity ) {
                std::ostringstream myCout;
                caloCondition.print(myCout);

                LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }

        }
            break;
        case CondEnergySum: {
            corrEnergySum = static_cast<const EnergySumTemplate*>(m_gtCond2);

            EnergySumCondition eSumCondition(corrEnergySum, m_uGtB);

            eSumCondition.evaluateConditionStoreResult(bxEval);
            reqObjResult = eSumCondition.condLastResult();

            cond2Comb = (eSumCondition.getCombinationsInCond());
            cond2bx = bxEval + (corrEnergySum->condRelativeBx());
            cndObjTypeVec[2] = (corrEnergySum->objectType())[0];

            if (m_verbosity) {
                std::ostringstream myCout;
                eSumCondition.print(myCout);

                LogDebug("L1TGlobal") << myCout.str() << std::endl;
            }
        }
            break;
        default: {
            // should not arrive here, there are no correlation conditions defined for this object
            return false;
        }
            break;
    }

    // if third sub-condition is false, effectively there will no overlap removal
    if (!reqObjResult) {
        LogDebug("L1TGlobal") << "\n"
                << "    Third sub-condtion false for object requirements."
                << "    Algorithm returning false.\n" << std::endl;
    return false;
    } else {
        LogDebug("L1TGlobal") << "\n"
                << "    All three sub-conditions true for object requirements."
                << "    Evaluate correlation requirements and overlap removal.\n" << std::endl;

    }

    // since we have two good legs and overlap-removal let, get the correlation parameters
    CorrelationWithOverlapRemovalTemplate::CorrelationWithOverlapRemovalParameter corrPar = *(m_gtCorrelationWithOverlapRemovalTemplate->correlationParameter());

    // vector to 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();

    // pointers to objects
    const BXVector<const l1t::Muon*>*        candMuVec    = nullptr;
    const BXVector<const l1t::L1Candidate*>* candCaloVec  = nullptr;
    const BXVector<const l1t::EtSum*>*       candEtSumVec = nullptr;

    bool etSumCond = false;

    // make the conversions of the indices, depending on the combination of objects involved
    // (via pair index)

    int phiIndex0  = 0;
    int phiIndex1  = 0;
    int phiORIndex0  = 0; // hold phi index transformed in case of need with overlap-removal
    int phiORIndex1  = 0; // hold phi index transformed in case of need with overlap-removal
    double phi0Phy = 0.;
    double phi1Phy = 0.;

    int etaIndex0  = 0;
    int etaIndex1  = 0;
    int etaORIndex0  = 0;
    int etaORIndex1  = 0;
    double eta0Phy = 0.;
    double eta1Phy = 0.;
    int etaBin0    = 0;
    int etaBin1    = 0;

    int etIndex0  = 0;
    int etIndex1  = 0;
    int etBin0    = 0;
    int etBin1    = 0;
    double et0Phy = 0.;
    double et1Phy = 0.;

    int chrg0 = -1;
    int chrg1 = -1;

    // make the conversions of the indices, depending on the combination of objects involved in overlap-removal
    int phiIndex2  = 0;
    int etaIndex2  = 0;
    double phi2Phy = 0.;
    double eta2Phy = 0.;
    int etaBin2    = 0;
    //int etIndex2  = 0;
    //int etBin2    = 0;

// Determine the number of phi bins to get cutoff at pi
    int phiBound = 0;
    if(cond0Categ == CondMuon || cond1Categ == CondMuon || cond2Categ == CondMuon) {
      GlobalScales::ScaleParameters par = m_gtScales->getMUScales();
      //phiBound = par.phiBins.size()/2;
      phiBound = (int)((par.phiMax - par.phiMin)/par.phiStep)/2;
    } else {
      //Assumes all calorimeter objects are on same phi scale
      GlobalScales::ScaleParameters par = m_gtScales->getEGScales();
      //phiBound = par.phiBins.size()/2;
      phiBound = (int)((par.phiMax - par.phiMin)/par.phiStep)/2;
    }
    LogDebug("L1TGlobal") << "Phi Bound = " << phiBound << std::endl;


// Keep track of objects for LUTS
    std::string lutObj0 = "NULL";
    std::string lutObj1 = "NULL";
    std::string lutObj2 = "NULL";


    LogTrace("L1TGlobal")
      << "  Sub-condition 0: std::vector<SingleCombInCond> size: "
      << (cond0Comb.size()) << std::endl;
    LogTrace("L1TGlobal")
      << "  Sub-condition 1: std::vector<SingleCombInCond> size: "
      << (cond1Comb.size()) << std::endl;
    LogTrace("L1TGlobal")
      << "  Sub-condition 2: std::vector<SingleCombInCond> size: "
      << (cond2Comb.size()) << std::endl;


    // ///////////////////////////////////////////////////////////////////////////////////////////
    // loop over all combinations which produced individually "true" as Type1s
    // ///////////////////////////////////////////////////////////////////////////////////////////
    // BLW: Optimization issue: potentially making the same comparison twice
    //                          if both legs are the same object type.
    // ///////////////////////////////////////////////////////////////////////////////////////////
    for (std::vector<SingleCombInCond>::const_iterator it0Comb = cond0Comb.begin(); it0Comb != cond0Comb.end(); it0Comb++) {

      // Type1s: there is 1 object only, no need for a loop, index 0 should be OK in (*it0Comb)[0]
      // ... but add protection to not crash
      int obj0Index = -1;

      if (!(*it0Comb).empty()) {
        obj0Index = (*it0Comb)[0];
      } else {
        LogTrace("L1TGlobal")
        << "\n  SingleCombInCond (*it0Comb).size() "
        << ((*it0Comb).size()) << std::endl;
        return false;
      }

      // Collect the information on the first leg of the correlation
      switch (cond0Categ) {
        case CondMuon: {
          lutObj0 = "MU";
          candMuVec = m_uGtB->getCandL1Mu();
          phiIndex0 =  (candMuVec->at(cond0bx,obj0Index))->hwPhi(); //(*candMuVec)[obj0Index]->phiIndex();
          etaIndex0 =  (candMuVec->at(cond0bx,obj0Index))->hwEta();
          etIndex0  =  (candMuVec->at(cond0bx,obj0Index))->hwPt();
          chrg0     =  (candMuVec->at(cond0bx,obj0Index))->hwCharge();
          int etaBin0 = etaIndex0;
          if(etaBin0<0) etaBin0 = m_gtScales->getMUScales().etaBins.size() + etaBin0; //twos complement
          //        LogDebug("L1TGlobal") << "Muon phi" << phiIndex0 << " eta " << etaIndex0 << " etaBin0 = " << etaBin0  << " et " << etIndex0 << std::endl;
          //

          etBin0 = etIndex0;
          int ssize = m_gtScales->getMUScales().etBins.size();
          if (etBin0 >= ssize){
            etBin0 = ssize-1;
            LogTrace("L1TGlobal")
            << "muon0 hw et" << etBin0 << " out of scale range.  Setting to maximum.";
          }

          // Determine Floating Pt numbers for floating point caluclation
          std::pair<double, double> binEdges = m_gtScales->getMUScales().phiBins.at(phiIndex0);
          phi0Phy = 0.5*(binEdges.second + binEdges.first);
          binEdges = m_gtScales->getMUScales().etaBins.at(etaBin0);
          eta0Phy = 0.5*(binEdges.second + binEdges.first);
          binEdges = m_gtScales->getMUScales().etBins.at(etBin0);
          et0Phy = 0.5*(binEdges.second + binEdges.first);

          LogDebug("L1TGlobal") << "Found all quantities for the muon 0" << std::endl;
        }
          break;

        // Calorimeter Objects (EG, Jet, Tau)
          case CondCalo: {
            switch(cndObjTypeVec[0]) {
              case gtEG: {
                lutObj0 = "EG";
                candCaloVec = m_uGtB->getCandL1EG();
                phiIndex0 =  (candCaloVec->at(cond0bx,obj0Index))->hwPhi();
                etaIndex0 =  (candCaloVec->at(cond0bx,obj0Index))->hwEta();
                etIndex0  =  (candCaloVec->at(cond0bx,obj0Index))->hwPt();
                etaBin0   = etaIndex0;
                if(etaBin0<0) etaBin0 = m_gtScales->getEGScales().etaBins.size() + etaBin0;
                //          LogDebug("L1TGlobal") << "EG0 phi" << phiIndex0 << " eta " << etaIndex0 << " etaBin0 = " << etaBin0 << " et " << etIndex0 << std::endl;

                etBin0 = etIndex0;
                int ssize = m_gtScales->getEGScales().etBins.size();
                if (etBin0 >= ssize){
                  etBin0 = ssize-1;
                  LogTrace("L1TGlobal")
                  << "EG0 hw et" << etBin0 << " out of scale range.  Setting to maximum.";
                }

                // Determine Floating Pt numbers for floating point caluclation
                std::pair<double, double> binEdges = m_gtScales->getEGScales().phiBins.at(phiIndex0);
                phi0Phy = 0.5*(binEdges.second + binEdges.first);
                binEdges = m_gtScales->getEGScales().etaBins.at(etaBin0);
                eta0Phy = 0.5*(binEdges.second + binEdges.first);
                binEdges = m_gtScales->getEGScales().etBins[etBin0];
                et0Phy = 0.5*(binEdges.second + binEdges.first);

              }
                break;
              case gtJet: {
                lutObj0 = "JET";
                candCaloVec = m_uGtB->getCandL1Jet();
                phiIndex0 =  (candCaloVec->at(cond0bx,obj0Index))->hwPhi();
                etaIndex0 =  (candCaloVec->at(cond0bx,obj0Index))->hwEta();
                etIndex0  =  (candCaloVec->at(cond0bx,obj0Index))->hwPt();
                etaBin0 = etaIndex0;
                if(etaBin0<0) etaBin0 = m_gtScales->getJETScales().etaBins.size() + etaBin0;

                etBin0 = etIndex0;
                int ssize = m_gtScales->getJETScales().etBins.size();
                if (etBin0 >= ssize){
                  //edm::LogWarning("L1TGlobal")
                  //<< "jet0 hw et" << etBin0 << " out of scale range.  Setting to maximum.";
                  etBin0 = ssize-1;
                }

                // Determine Floating Pt numbers for floating point caluclation
                std::pair<double, double> binEdges = m_gtScales->getJETScales().phiBins.at(phiIndex0);
                phi0Phy = 0.5*(binEdges.second + binEdges.first);
                binEdges = m_gtScales->getJETScales().etaBins.at(etaBin0);
                eta0Phy = 0.5*(binEdges.second + binEdges.first);
                binEdges = m_gtScales->getJETScales().etBins.at(etBin0);
                et0Phy = 0.5*(binEdges.second + binEdges.first);

              }
                break;
              case gtTau: {
                candCaloVec = m_uGtB->getCandL1Tau();
                phiIndex0 =  (candCaloVec->at(cond0bx,obj0Index))->hwPhi();
                etaIndex0 =  (candCaloVec->at(cond0bx,obj0Index))->hwEta();
                etIndex0  =  (candCaloVec->at(cond0bx,obj0Index))->hwPt();
                etaBin0 = etaIndex0;
                if(etaBin0<0) etaBin0 = m_gtScales->getTAUScales().etaBins.size() + etaBin0;

                etBin0 = etIndex0;
                int ssize = m_gtScales->getTAUScales().etBins.size();
                if (etBin0 >= ssize){
                  etBin0 = ssize-1;
                  LogTrace("L1TGlobal")
                  << "tau0 hw et" << etBin0 << " out of scale range.  Setting to maximum.";
                }

                // Determine Floating Pt numbers for floating point caluclation
                std::pair<double, double> binEdges = m_gtScales->getTAUScales().phiBins.at(phiIndex0);
                phi0Phy = 0.5*(binEdges.second + binEdges.first);
                binEdges = m_gtScales->getTAUScales().etaBins.at(etaBin0);
                eta0Phy = 0.5*(binEdges.second + binEdges.first);
                binEdges = m_gtScales->getTAUScales().etBins.at(etBin0);
                et0Phy = 0.5*(binEdges.second + binEdges.first);
                lutObj0 = "TAU";
              }
                  break;
              default: {
              }
                break;
            } //end switch on calo type.

            phiORIndex0 = phiIndex0;
            etaORIndex0 = etaIndex0;

            //If needed convert calo scales to muon scales for comparison
            if(convertCaloScales) {
              std::string lutName = lutObj0;
              lutName += "-MU";
              long long tst = m_gtScales->getLUT_CalMuEta(lutName,etaBin0);
              LogDebug("L1TGlobal") << lutName <<"  EtaCal = " << etaIndex0 << " etaBin0 = " << etaBin0 << " EtaMu = " << tst << std::endl;
              etaIndex0 = tst;
              tst = m_gtScales->getLUT_CalMuPhi(lutName,phiIndex0);
              LogDebug("L1TGlobal") << lutName <<"  PhiCal = " << phiIndex0 << " PhiMu = " << tst << std::endl;
              phiIndex0 = tst;
            }

            //If needed convert calo scales to muon scales for comparison
            if(convertCaloScalesForOverlapRemovalFromLeg0) {
              phiORIndex0 = phiIndex0;
             etaORIndex0 = etaIndex0;

            }

          }
                break;

          // Energy Sums
          case CondEnergySum: {

            etSumCond = true;
            //Stupid mapping between enum types for energy sums.
            l1t::EtSum::EtSumType type;

            switch( cndObjTypeVec[0] ){
            case gtETM:
              type = l1t::EtSum::EtSumType::kMissingEt;
              lutObj0 = "ETM";
              break;
            case gtETT:
              type = l1t::EtSum::EtSumType::kTotalEt;
              lutObj0 = "ETT";
              break;
            case gtETTem:
              type = l1t::EtSum::EtSumType::kTotalEtEm;
              lutObj0 = "ETTem"; //should this be just ETT (share LUTs?) Can't be used for CorrCond anyway since now directional information
              break;
            case gtHTM:
              type = l1t::EtSum::EtSumType::kMissingHt;
              lutObj0 = "HTM";
              break;
            case gtHTT:
              type = l1t::EtSum::EtSumType::kTotalHt;
              lutObj0 = "HTT";
              break;
            case gtETMHF:
              type = l1t::EtSum::EtSumType::kMissingEtHF;
              lutObj0 = "ETMHF";
              break;
            case gtMinBiasHFP0:
            case gtMinBiasHFM0:
            case gtMinBiasHFP1:
            case gtMinBiasHFM1:
              type = l1t::EtSum::EtSumType::kMinBiasHFP0;
              lutObj0 = "MinBias"; //??Fix?? Not a valid LUT type Can't be used for CorrCond anyway since now directional information
              break;
            default:
              edm::LogError("L1TGlobal")
                << "\n  Error: "
                << "Unmatched object type from template to EtSumType, cndObjTypeVec[0] = "
                << cndObjTypeVec[0]
                << std::endl;
              type = l1t::EtSum::EtSumType::kTotalEt;
              break;
            }

            candEtSumVec = m_uGtB->getCandL1EtSum();

            for( int iEtSum=0; iEtSum < (int)candEtSumVec->size(cond0bx); iEtSum++) {
              if( (candEtSumVec->at(cond0bx,iEtSum))->getType() == type ) {
                phiIndex0 =  (candEtSumVec->at(cond0bx,iEtSum))->hwPhi();
                etaIndex0 =  (candEtSumVec->at(cond0bx,iEtSum))->hwEta();
                etIndex0  =  (candEtSumVec->at(cond0bx,iEtSum))->hwPt();

                //  Get the floating point numbers
                if(cndObjTypeVec[0] == gtETM ) {
                  std::pair<double, double> binEdges = m_gtScales->getETMScales().phiBins.at(phiIndex0);
                  phi0Phy = 0.5*(binEdges.second + binEdges.first);
                  eta0Phy = 0.; //No Eta for Energy Sums

                  etBin0 = etIndex0;
                  int ssize = m_gtScales->getETMScales().etBins.size();
                  assert(ssize > 0);
                  if (etBin0 >= ssize){ etBin0 = ssize-1; }

                  binEdges = m_gtScales->getETMScales().etBins.at(etBin0);
                  et0Phy = 0.5*(binEdges.second + binEdges.first);
                } else if (cndObjTypeVec[0] == gtHTM) {
                  std::pair<double, double> binEdges = m_gtScales->getHTMScales().phiBins.at(phiIndex0);
                  phi0Phy = 0.5*(binEdges.second + binEdges.first);
                  eta0Phy = 0.; //No Eta for Energy Sums

                  etBin0 = etIndex0;
                  int ssize = m_gtScales->getHTMScales().etBins.size();
                  assert(ssize > 0);
                  if (etBin0 >= ssize){ etBin0 = ssize-1; }

                  binEdges = m_gtScales->getHTMScales().etBins.at(etBin0);
                  et0Phy = 0.5*(binEdges.second + binEdges.first);
                } else if (cndObjTypeVec[0] == gtETMHF) {
                  std::pair<double, double> binEdges = m_gtScales->getETMHFScales().phiBins.at(phiIndex0);
                  phi0Phy = 0.5*(binEdges.second + binEdges.first);
                  eta0Phy = 0.; //No Eta for Energy Sums

                  etBin0 = etIndex0;
                  int ssize = m_gtScales->getETMHFScales().etBins.size();
                  assert(ssize > 0);
                  if (etBin0 >= ssize){ etBin0 = ssize-1; }

                  binEdges = m_gtScales->getETMHFScales().etBins.at(etBin0);
                  et0Phy = 0.5*(binEdges.second + binEdges.first);
                }

                phiORIndex0 = phiIndex0;
                etaORIndex0 = etaIndex0;

                //If needed convert calo scales to muon scales for comparison (only phi for energy sums)
                if(convertCaloScales) {
                  std::string lutName = lutObj0;
                  lutName += "-MU";
                  long long tst = m_gtScales->getLUT_CalMuPhi(lutName,phiIndex0);
                  LogDebug("L1TGlobal") << lutName <<"  PhiCal = " << phiIndex0 << " PhiMu = " << tst << std::endl;
                  phiIndex0 = tst;
                }

                //If needed convert calo scales to muon scales for comparison (only phi for energy sums)
                if(convertCaloScalesForOverlapRemovalFromLeg0) {
                  phiORIndex0 = phiIndex0;

                }

              } //check it is the EtSum we want
            } // loop over Etsums

          } // end case CondEnergySum
            break;


          default: {
            // should not arrive here, there are no correlation conditions defined for this object
            LogDebug("L1TGlobal") << "Error could not find the Cond Category for Leg 0" << std::endl;
            return false;
          }
            break;
        } //end switch on first leg type

        LogDebug("L1TGlobal") << "lutObj0 = " << lutObj0 << std::endl;

        unsigned int overlapRemovalMatchLeg1 = 0x0;

        // ///////////////////////////////////////////////////////////////////////////////////////////
        // loop over overlap-removal leg combination which produced individually "true" as Type1s
        // ///////////////////////////////////////////////////////////////////////////////////////////
        for (std::vector<SingleCombInCond>::const_iterator it2Comb = cond2Comb.begin(); it2Comb != cond2Comb.end() && overlapRemovalMatchLeg1 != 0x1; it2Comb++) {

          // Type1s: there is 1 object only, no need for a loop, index 0 should be OK in (*it2Comb)[0]
          // ... but add protection to not crash
          int obj2Index = -1;

          if (!(*it2Comb).empty()) {
            obj2Index = (*it2Comb)[0];
          } else {
            LogTrace("L1TGlobal")
            << "\n  SingleCombInCond (*it2Comb).size() "
            << ((*it2Comb).size()) << std::endl;
            return false;
          }

          // Collect the information on the overlap-removal leg
          switch (cond2Categ) {

            case CondMuon: {

              lutObj2 = "MU";
              candMuVec = m_uGtB->getCandL1Mu();
              phiIndex2 =  (candMuVec->at(cond2bx,obj2Index))->hwPhi(); //(*candMuVec)[obj2Index]->phiIndex();
              etaIndex2 =  (candMuVec->at(cond2bx,obj2Index))->hwEta();
              int etaBin2 = etaIndex2;
              if(etaBin2<0) etaBin2 = m_gtScales->getMUScales().etaBins.size() + etaBin2; //twos complement
              //LogDebug("L1TGlobal") << "Muon phi" << phiIndex2 << " eta " << etaIndex2 << " etaBin2 = " << etaBin2  << " et " << etIndex2 << std::endl;

              // Determine Floating Pt numbers for floating point caluclation
              std::pair<double, double> binEdges = m_gtScales->getMUScales().phiBins.at(phiIndex2);
              phi2Phy = 0.5*(binEdges.second + binEdges.first);
              binEdges = m_gtScales->getMUScales().etaBins.at(etaBin2);
              eta2Phy = 0.5*(binEdges.second + binEdges.first);

              LogDebug("L1TGlobal") << "Found all quantities for the muon 0" << std::endl;
            }
              break;

            // Calorimeter Objects (EG, Jet, Tau)
            case CondCalo: {

              switch(cndObjTypeVec[2]) {

                case gtEG: {
                  lutObj2 = "EG";
                  candCaloVec = m_uGtB->getCandL1EG();
                  phiIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwPhi();
                  etaIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwEta();
                  if(etaBin2<0) etaBin2 = m_gtScales->getEGScales().etaBins.size() + etaBin2;
                  //LogDebug("L1TGlobal") << "EG0 phi" << phiIndex2 << " eta " << etaIndex2 << " etaBin2 = " << etaBin2 << " et " << etIndex2 << std::endl;

                  // Determine Floating Pt numbers for floating point caluclation
                  std::pair<double, double> binEdges = m_gtScales->getEGScales().phiBins.at(phiIndex2);
                  phi2Phy = 0.5*(binEdges.second + binEdges.first);
                  binEdges = m_gtScales->getEGScales().etaBins.at(etaBin2);
                  eta2Phy = 0.5*(binEdges.second + binEdges.first);

                }
                  break;
                case gtJet: {
                  lutObj2 = "JET";
                  candCaloVec = m_uGtB->getCandL1Jet();
                  phiIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwPhi();
                  etaIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwEta();
                  etaBin2 = etaIndex2;
                  if(etaBin2<0) etaBin2 = m_gtScales->getJETScales().etaBins.size() + etaBin2;

                  // Determine Floating Pt numbers for floating point caluclation
                  std::pair<double, double> binEdges = m_gtScales->getJETScales().phiBins.at(phiIndex2);
                  phi2Phy = 0.5*(binEdges.second + binEdges.first);
                  binEdges = m_gtScales->getJETScales().etaBins.at(etaBin2);
                  eta2Phy = 0.5*(binEdges.second + binEdges.first);

                }
                  break;
                case gtTau: {

                  candCaloVec = m_uGtB->getCandL1Tau();
                  phiIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwPhi();
                  etaIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwEta();
                  if(etaBin2<0) etaBin2 = m_gtScales->getTAUScales().etaBins.size() + etaBin2;

                  // Determine Floating Pt numbers for floating point caluclation
                  std::pair<double, double> binEdges = m_gtScales->getTAUScales().phiBins.at(phiIndex2);
                  phi2Phy = 0.5*(binEdges.second + binEdges.first);
                  binEdges = m_gtScales->getTAUScales().etaBins.at(etaBin2);
                  eta2Phy = 0.5*(binEdges.second + binEdges.first);
                  lutObj2 = "TAU";
                }
                    break;
                default: {
                }
                  break;

              } //end switch on calo type.

              //If needed convert calo scales to muon scales for comparison
              if(convertCaloScales) {

                  std::string lutName = lutObj2;
                  lutName += "-MU";
                  long long tst = m_gtScales->getLUT_CalMuEta(lutName,etaBin2);
                  LogDebug("L1TGlobal") << lutName <<"  EtaCal = " << etaIndex2 << " etaBin2 = " << etaBin2 << " EtaMu = " << tst << std::endl;
                  etaIndex2 = tst;

                  tst = m_gtScales->getLUT_CalMuPhi(lutName,phiIndex2);
                  LogDebug("L1TGlobal") << lutName <<"  PhiCal = " << phiIndex2 << " PhiMu = " << tst << std::endl;
                  phiIndex2 = tst;

              }

            } // end case CondCalo
              break;

            // Energy Sums
            case CondEnergySum: {

              etSumCond = true;
              //Stupid mapping between enum types for energy sums.
              l1t::EtSum::EtSumType type;
              switch( cndObjTypeVec[2] ){
              case gtETM:
                type = l1t::EtSum::EtSumType::kMissingEt;
                lutObj2 = "ETM";
                break;
              case gtETT:
                type = l1t::EtSum::EtSumType::kTotalEt;
                lutObj2 = "ETT";
                break;
              case gtETTem:
                type = l1t::EtSum::EtSumType::kTotalEtEm;
                lutObj2 = "ETTem"; //should this be just ETT (share LUTs?) Can't be used for CorrCond anyway since now directional information
                break;
              case gtHTM:
                type = l1t::EtSum::EtSumType::kMissingHt;
                lutObj2 = "HTM";
                break;
              case gtHTT:
                type = l1t::EtSum::EtSumType::kTotalHt;
                lutObj2 = "HTT";
                break;
              case gtETMHF:
                type = l1t::EtSum::EtSumType::kMissingEtHF;
                lutObj2 = "ETMHF";
                break;
              case gtMinBiasHFP0:
              case gtMinBiasHFM0:
              case gtMinBiasHFP1:
              case gtMinBiasHFM1:
                type = l1t::EtSum::EtSumType::kMinBiasHFP0;
                lutObj2 = "MinBias"; //??Fix?? Not a valid LUT type Can't be used for CorrCond anyway since now directional information
                break;
              default:
                edm::LogError("L1TGlobal")
                << "\n  Error: "
                << "Unmatched object type from template to EtSumType, cndObjTypeVec[2] = "
                << cndObjTypeVec[2]
                << std::endl;
                type = l1t::EtSum::EtSumType::kTotalEt;
                break;
              }

              candEtSumVec = m_uGtB->getCandL1EtSum();

              for( int iEtSum=0; iEtSum < (int)candEtSumVec->size(cond2bx); iEtSum++) {
                if( (candEtSumVec->at(cond2bx,iEtSum))->getType() == type ) {
                  phiIndex2 =  (candEtSumVec->at(cond2bx,iEtSum))->hwPhi();
                  etaIndex2 =  (candEtSumVec->at(cond2bx,iEtSum))->hwEta();

                  //  Get the floating point numbers
                  if(cndObjTypeVec[2] == gtETM ) {
                    std::pair<double, double> binEdges = m_gtScales->getETMScales().phiBins.at(phiIndex2);
                    phi2Phy = 0.5*(binEdges.second + binEdges.first);
                    eta2Phy = 0.; //No Eta for Energy Sums

                  } else if (cndObjTypeVec[2] == gtHTM) {
                    std::pair<double, double> binEdges = m_gtScales->getHTMScales().phiBins.at(phiIndex2);
                    phi2Phy = 0.5*(binEdges.second + binEdges.first);
                    eta2Phy = 0.; //No Eta for Energy Sums

                  } else if (cndObjTypeVec[2] == gtETMHF) {
                    std::pair<double, double> binEdges = m_gtScales->getETMHFScales().phiBins.at(phiIndex2);
                    phi2Phy = 0.5*(binEdges.second + binEdges.first);
                    eta2Phy = 0.; //No Eta for Energy Sums

                  }

                  //If needed convert calo scales to muon scales for comparison (only phi for energy sums)
                  if(convertCaloScales) {

                    std::string lutName = lutObj2;
                    lutName += "-MU";
                    long long tst = m_gtScales->getLUT_CalMuPhi(lutName,phiIndex2);
                    LogDebug("L1TGlobal") << lutName <<"  PhiCal = " << phiIndex2 << " PhiMu = " << tst << std::endl;
                    phiIndex2 = tst;

                  }

                } //check it is the EtSum we want
              } // loop over Etsums

            }
              break;

            default: {
              // should not arrive here, there are no correlation conditions defined for this object
              LogDebug("L1TGlobal") << "Error could not find the Cond Category for Leg 3" << std::endl;
              return false;
            }
              break;
          } //end switch on overlap-removal leg type

          LogDebug("L1TGlobal") << "lutObj2 = " << lutObj2 << std::endl;

          // /////////////////////////////////////////////////////////////////////////////////////////
          //
          // here check if there is a match of 1st leg with overlap removal object, and store result
          //
          // /////////////////////////////////////////////////////////////////////////////////////////
          // These all require some delta eta and phi calculations.  Do them first...for now real calculation but need to
          // revise this to line up with firmware calculations.
          double deltaPhiPhy  = fabs(phi2Phy - phi0Phy);
          if(deltaPhiPhy> M_PI) deltaPhiPhy = 2.*M_PI - deltaPhiPhy;
          double deltaEtaPhy  = fabs(eta2Phy - eta0Phy);

          // Deter the integer based delta eta and delta phi
          int deltaPhiFW = abs(phiORIndex0 - phiIndex2);
          if(deltaPhiFW>=phiBound) deltaPhiFW = 2*phiBound - deltaPhiFW;
          std::string lutName = lutObj0;
          lutName += "-";
          lutName += lutObj2;
          long long deltaPhiLUT = m_gtScales->getLUT_DeltaPhi(lutName,deltaPhiFW);
          unsigned int precDeltaPhiLUT = m_gtScales->getPrec_DeltaPhi(lutName);

          int deltaEtaFW = abs(etaORIndex0 - etaIndex2);
          long long deltaEtaLUT = 0;
          unsigned int precDeltaEtaLUT = 0;
          if(!etSumCond) {
            deltaEtaLUT = m_gtScales->getLUT_DeltaEta(lutName,deltaEtaFW);
            precDeltaEtaLUT = m_gtScales->getPrec_DeltaEta(lutName);
          }

          LogDebug("L1TGlobal") << "Obj0 phiFW = " << phiORIndex0 << " Obj2 phiFW = " << phiIndex2 << "\n"
          << "    DeltaPhiFW = " << deltaPhiFW << "\n"
          << "    LUT Name = " << lutName << " Prec = " << precDeltaPhiLUT << "  DeltaPhiLUT = " << deltaPhiLUT << "\n"
          << "Obj0 etaFW = " << etaIndex0 << " Obj2 etaFW = " << etaIndex2 << "\n"
          << "    DeltaEtaFW = " << deltaEtaFW << "\n"
          << "    LUT Name = " << lutName << " Prec = " << precDeltaEtaLUT << "  DeltaEtaLUT = " << deltaEtaLUT << std::endl;

          // If there is a OverlapRemovalDeltaEta cut, check it.
          if(corrPar.corrCutType & 0x10) {

                unsigned int preShift = precDeltaEtaLUT - corrPar.precOverlapRemovalEtaCut;
                LogDebug("L1TGlobal")    << "    Testing Leg1 Overlap Removal Delta Eta Cut (" << lutObj0 << "," << lutObj2 << ") [" << (long long)(corrPar.minOverlapRemovalEtaCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxOverlapRemovalEtaCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precOverlapRemovalEtaCut <<"\n"
                << "    deltaEtaLUT = " << deltaEtaLUT << "\n"
                << "    Precision Shift = " << preShift << "\n"
                << "    deltaEta (shift)= " << (deltaEtaLUT/pow(10,preShift+corrPar.precOverlapRemovalEtaCut)) << "\n"
                << "    deltaEtaPhy = " <<  deltaEtaPhy << std::endl;

                //if(preShift>0) deltaEtaLUT /= pow(10,preShift);
                if( deltaEtaLUT >= (long long)(corrPar.minOverlapRemovalEtaCutValue*pow(10,preShift)) &&
                    deltaEtaLUT <= (long long)(corrPar.maxOverlapRemovalEtaCutValue*pow(10,preShift)) ) {

                  overlapRemovalMatchLeg1 |= 0x1;
                  LogDebug("L1TGlobal") << "    Satified Leg1 Overlap Removal Delta Eta Cut [" << (long long)(corrPar.minOverlapRemovalEtaCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalEtaCutValue*pow(10,preShift)) << "]" << std::endl;
                  // next leg3 object
                  continue;

                } else {

                  LogDebug("L1TGlobal")  << "    Failed Leg1 Overlap Removal Delta Eta Cut [" << (long long)(corrPar.minOverlapRemovalEtaCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalEtaCutValue*pow(10,preShift)) << "]" << std::endl;
                }

              }

              //if there is a OverlapRemovalDeltaPhi cut, check it.
              if(corrPar.corrCutType & 0x20) {

                unsigned int preShift = precDeltaPhiLUT - corrPar.precOverlapRemovalPhiCut;
                LogDebug("L1TGlobal")  << "    Testing Leg1 Overlap Removal Delta Phi Cut (" << lutObj0 << "," << lutObj2 << ") [" << (long long)(corrPar.minOverlapRemovalPhiCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxOverlapRemovalPhiCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precOverlapRemovalPhiCut <<"\n"
                << "    deltaPhiLUT = " << deltaPhiLUT  << "\n"
                << "    Precision Shift = " << preShift << "\n"
                << "    deltaPhi (shift)= " << (deltaPhiLUT/pow(10,preShift+corrPar.precOverlapRemovalPhiCut)) << "\n"
                << "    deltaPhiPhy = " <<  deltaPhiPhy << std::endl;

                //if(preShift>0) deltaPhiLUT /= pow(10,preShift);
                if( deltaPhiLUT >= (long long)(corrPar.minOverlapRemovalPhiCutValue*pow(10,preShift)) &&
                  deltaPhiLUT <= (long long)(corrPar.maxOverlapRemovalPhiCutValue*pow(10,preShift)) ) {

                  overlapRemovalMatchLeg1 |= 0x1;
                  LogDebug("L1TGlobal")  << "    Satisfied Leg1 Overlap Removal Delta Phi Cut [" << (long long)(corrPar.minOverlapRemovalPhiCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalPhiCutValue*pow(10,preShift)) << "]" << std::endl;
                  // next leg3 object
                  continue;

                } else {

                  LogDebug("L1TGlobal") << "    Failed Leg1 Overlap Removal Delta Phi Cut [" << (long long)(corrPar.minOverlapRemovalPhiCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalPhiCutValue*pow(10,preShift)) << "]" << std::endl;
                }
              }

              //if there is a OverlapRemovalDeltaR cut, check it.
              if(corrPar.corrCutType & 0x40) {

                //Assumes Delta Eta and Delta Phi LUTs have the same precision
                unsigned int preShift = 2*precDeltaPhiLUT  - corrPar.precOverlapRemovalDRCut;
                double deltaRSqPhy = deltaPhiPhy*deltaPhiPhy + deltaEtaPhy*deltaEtaPhy;
                long long deltaRSq = deltaEtaLUT*deltaEtaLUT + deltaPhiLUT*deltaPhiLUT;

                LogDebug("L1TGlobal") << "    Testing Leg1 Overlap Removal Delta R Cut (" << lutObj0 << "," << lutObj2 << ") [" << (long long)(corrPar.minOverlapRemovalDRCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxOverlapRemovalDRCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precOverlapRemovalDRCut <<"\n"
                << "    deltaPhiLUT = " << deltaPhiLUT << "\n"
                << "    deltaEtaLUT = " << deltaEtaLUT << "\n"
                << "    deltaRSqLUT = " << deltaRSq <<  "\n"
                << "    Precision Shift = " << preShift << "\n"
                << "    deltaRSqLUT (shift)= " << (deltaRSq/pow(10,preShift+corrPar.precDRCut)) << "\n"
                << "    deltaRSqPhy = " << deltaRSqPhy << std::endl;

                //if(preShift>0) deltaRSq /= pow(10,preShift);
                if( deltaRSq >= (long long)(corrPar.minOverlapRemovalDRCutValue*pow(10,preShift)) &&
                  deltaRSq <= (long long)(corrPar.maxOverlapRemovalDRCutValue*pow(10,preShift)) ) {

                  overlapRemovalMatchLeg1 |= 0x1;
                  LogDebug("L1TGlobal") << "    Satified Leg1 Overlap Removal Delta R Cut [" << (long long)(corrPar.minOverlapRemovalDRCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalDRCutValue*pow(10,preShift)) << "]" << std::endl;
                  // next leg3 object
                  continue;

                } else {

                  LogDebug("L1TGlobal") << "    Failed Leg1 Overlap Removal Delta R Cut [" << (int)(corrPar.minOverlapRemovalDRCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalDRCutValue*pow(10,preShift)) << "]" << std::endl;

                }

              }

            } // end loop over combinations in overlap-removal leg.

            // skip object leg1 if matched with overlap removal object
            // ///////////////////////////////////////////////////////
            if (overlapRemovalMatchLeg1 == 0x1) {
              LogDebug("L1TGlobal") << "   Remove Object of Leg1: Satisfied Overlap Removal Cuts " << std::endl;
              continue;
            }
            else {
              LogDebug("L1TGlobal") << "   Keep Object of Leg1: Failed Overlap Removal Cuts " << std::endl;
            }


            // ///////////////////////////////////////////////////////////////////////////////////////////
            // Now loop over the second leg to get its information
            // ///////////////////////////////////////////////////////////////////////////////////////////
            for (std::vector<SingleCombInCond>::const_iterator it1Comb = cond1Comb.begin(); it1Comb != cond1Comb.end(); it1Comb++) {

              LogDebug("L1TGlobal") << "Looking at second Condition" << std::endl;
              // Type1s: there is 1 object only, no need for a loop (*it1Comb)[0]
              // ... but add protection to not crash
              int obj1Index = -1;

              if (!(*it1Comb).empty()) {
                obj1Index = (*it1Comb)[0];
              } else {
                LogTrace("L1TGlobal")
                << "\n  SingleCombInCond (*it1Comb).size() "
                << ((*it1Comb).size()) << std::endl;
                return false;
              }

              //If we are dealing with the same object type avoid the two legs
              // either being the same object
              if( cndObjTypeVec[0] == cndObjTypeVec[1] &&
          obj0Index == obj1Index &&
          cond0bx == cond1bx) {

                LogDebug("L1TGlobal") << "Corr Condition looking at same leg...skip" << std::endl;
                continue;
              }

            switch (cond1Categ) {
              case CondMuon: {
                lutObj1 = "MU";
                candMuVec = m_uGtB->getCandL1Mu();
                phiIndex1 =  (candMuVec->at(cond1bx,obj1Index))->hwPhi(); //(*candMuVec)[obj0Index]->phiIndex();
                etaIndex1 =  (candMuVec->at(cond1bx,obj1Index))->hwEta();
                etIndex1  =  (candMuVec->at(cond1bx,obj1Index))->hwPt();
                chrg1     =  (candMuVec->at(cond1bx,obj1Index))->hwCharge();
                etaBin1 = etaIndex1;
                if(etaBin1<0) etaBin1 = m_gtScales->getMUScales().etaBins.size() + etaBin1;
                //         LogDebug("L1TGlobal") << "Muon phi" << phiIndex1 << " eta " << etaIndex1 << " etaBin1 = " << etaBin1  << " et " << etIndex1 << std::endl;
                etBin1 = etIndex1;
                int ssize = m_gtScales->getMUScales().etBins.size();

                if (etBin1 >= ssize){
                  LogTrace("L1TGlobal")
                  << "muon2 hw et" << etBin1 << " out of scale range.  Setting to maximum.";
                  etBin1 = ssize-1;
                }

                // Determine Floating Pt numbers for floating point caluclation
                std::pair<double, double> binEdges = m_gtScales->getMUScales().phiBins.at(phiIndex1);
                phi1Phy = 0.5*(binEdges.second + binEdges.first);
                binEdges = m_gtScales->getMUScales().etaBins.at(etaBin1);
                eta1Phy = 0.5*(binEdges.second + binEdges.first);
                binEdges = m_gtScales->getMUScales().etBins.at(etBin1);
                et1Phy = 0.5*(binEdges.second + binEdges.first);

              }
                break;

              case CondCalo: {

                switch(cndObjTypeVec[1]) {

                  case gtEG: {

                    candCaloVec = m_uGtB->getCandL1EG();
                    phiIndex1 =  (candCaloVec->at(cond1bx,obj1Index))->hwPhi();
                    etaIndex1 =  (candCaloVec->at(cond1bx,obj1Index))->hwEta();
                    etIndex1  =  (candCaloVec->at(cond1bx,obj1Index))->hwPt();
                    etaBin1   =   etaIndex1;
                    if(etaBin1<0) etaBin1 = m_gtScales->getEGScales().etaBins.size() + etaBin1;

                    etBin1 = etIndex1;
                    int ssize = m_gtScales->getEGScales().etBins.size();
                    if (etBin1 >= ssize){
                      LogTrace("L1TGlobal")
                      << "EG1 hw et" << etBin1 << " out of scale range.  Setting to maximum.";
                      etBin1 = ssize-1;
                    }

                    // Determine Floating Pt numbers for floating point caluclation
                    std::pair<double, double> binEdges = m_gtScales->getEGScales().phiBins.at(phiIndex1);
                    phi1Phy = 0.5*(binEdges.second + binEdges.first);
                    binEdges = m_gtScales->getEGScales().etaBins.at(etaBin1);
                    eta1Phy = 0.5*(binEdges.second + binEdges.first);
                    binEdges = m_gtScales->getEGScales().etBins.at(etBin1);
                    et1Phy = 0.5*(binEdges.second + binEdges.first);
                    lutObj1 = "EG";
                  }
                    break;

                  case gtJet: {
                    candCaloVec = m_uGtB->getCandL1Jet();
                    phiIndex1 =  (candCaloVec->at(cond1bx,obj1Index))->hwPhi();
                    etaIndex1 =  (candCaloVec->at(cond1bx,obj1Index))->hwEta();
                    etIndex1  =  (candCaloVec->at(cond1bx,obj1Index))->hwPt();
                    etaBin1 = etaIndex1;
                    if(etaBin1<0) etaBin1 = m_gtScales->getJETScales().etaBins.size() + etaBin1;
                    etBin1 = etIndex1;
                    int ssize = m_gtScales->getJETScales().etBins.size();
                    assert(ssize);
                    if (etBin1 >= ssize){
                      //edm::LogWarning("L1TGlobal")
                      //<< "jet2 hw et" << etBin1 << " out of scale range.  Setting to maximum.";
                      etBin1 = ssize-1;
                    }

                    // Determine Floating Pt numbers for floating point caluclation
                    std::pair<double, double> binEdges = m_gtScales->getJETScales().phiBins.at(phiIndex1);
                    phi1Phy = 0.5*(binEdges.second + binEdges.first);
                    binEdges = m_gtScales->getJETScales().etaBins.at(etaBin1);
                    eta1Phy = 0.5*(binEdges.second + binEdges.first);

                    binEdges = m_gtScales->getJETScales().etBins.at(etBin1);
                    et1Phy = 0.5*(binEdges.second + binEdges.first);
                    lutObj1 = "JET";
                  }
                    break;

                  case gtTau: {
                    candCaloVec = m_uGtB->getCandL1Tau();
                    phiIndex1 =  (candCaloVec->at(cond1bx,obj1Index))->hwPhi();
                    etaIndex1 =  (candCaloVec->at(cond1bx,obj1Index))->hwEta();
                    etIndex1  =  (candCaloVec->at(cond1bx,obj1Index))->hwPt();
                    etaBin1 = etaIndex1;
                    if(etaBin1<0) etaBin1 = m_gtScales->getTAUScales().etaBins.size() + etaBin1;
                    etBin1 = etIndex1;
                    int ssize = m_gtScales->getTAUScales().etBins.size();
                    if (etBin1 >= ssize){
                      LogTrace("L1TGlobal")
                      << "tau2 hw et" << etBin1 << " out of scale range.  Setting to maximum.";
                      etBin1 = ssize-1;
                    }

                    // Determine Floating Pt numbers for floating point caluclation
                    std::pair<double, double> binEdges = m_gtScales->getTAUScales().phiBins.at(phiIndex1);
                    phi1Phy = 0.5*(binEdges.second + binEdges.first);
                    binEdges = m_gtScales->getTAUScales().etaBins.at(etaBin1);
                    eta1Phy = 0.5*(binEdges.second + binEdges.first);
                    binEdges = m_gtScales->getTAUScales().etBins.at(etBin1);
                    et1Phy = 0.5*(binEdges.second + binEdges.first);
                    lutObj1 = "TAU";
                  }
                    break;
                  default: {
                  }
                    break;

                } //end switch on calo type.


                phiORIndex1 = phiIndex1;
                etaORIndex1 = etaIndex1;

                //If needed convert calo scales to muon scales for comparison
                if(convertCaloScales) {

                  std::string lutName = lutObj1;
                  lutName += "-MU";
                  long long tst = m_gtScales->getLUT_CalMuEta(lutName,etaBin1);
                  LogDebug("L1TGlobal") << lutName <<"  EtaCal = " << etaIndex1 << " EtaMu = " << tst << std::endl;
                  etaIndex1 = tst;
                  tst = m_gtScales->getLUT_CalMuPhi(lutName,phiIndex1);
                  LogDebug("L1TGlobal") << lutName <<"  PhiCal = " << phiIndex1 << " PhiMu = " << tst << std::endl;
                  phiIndex1 = tst;

                }

                //If needed convert calo scales to muon scales for comparison
                if(convertCaloScalesForOverlapRemovalFromLeg1) {
                  phiORIndex1 = phiIndex1;
                  etaORIndex1 = etaIndex1;

                }


              }  // end case CondCalo
                break;
              case CondEnergySum: {

                LogDebug("L1TGlobal") << "Looking at second Condition as Energy Sum: " << cndObjTypeVec[1] << std::endl;
                etSumCond = true;

                //Stupid mapping between enum types for energy sums.
                l1t::EtSum::EtSumType type;

                switch( cndObjTypeVec[1] ){
                case gtETM:
                  type = l1t::EtSum::EtSumType::kMissingEt;
                  lutObj1 = "ETM";
                  break;
                case gtETT:
                  type = l1t::EtSum::EtSumType::kTotalEt;
                  lutObj1 = "ETT";
                  break;
                case gtETTem:
                  type = l1t::EtSum::EtSumType::kTotalEtEm;
                  lutObj1 = "ETTem";
                  break;
                case gtHTM:
                  type = l1t::EtSum::EtSumType::kMissingHt;
                  lutObj1 = "HTM";
                  break;
                case gtHTT:
                  type = l1t::EtSum::EtSumType::kTotalHt;
                  lutObj1 = "HTT";
                  break;
                case gtETMHF:
                  type = l1t::EtSum::EtSumType::kMissingEtHF;
                  lutObj1 = "ETMHF";
                  break;
                case gtMinBiasHFP0:
                case gtMinBiasHFM0:
                case gtMinBiasHFP1:
                case gtMinBiasHFM1:
                  type = l1t::EtSum::EtSumType::kMinBiasHFP0;
                  lutObj1 = "MinBias";
                  break;
                default:
                  edm::LogError("L1TGlobal")
                    << "\n  Error: "
                    << "Unmatched object type from template to EtSumType, cndObjTypeVec[1] = "
                    << cndObjTypeVec[1]
                    << std::endl;
                  type = l1t::EtSum::EtSumType::kTotalEt;
                  break;
                }

                candEtSumVec = m_uGtB->getCandL1EtSum();

                LogDebug("L1TGlobal") << "obj " << lutObj1 << " Vector Size " << candEtSumVec->size(cond1bx) << std::endl;
                for( int iEtSum=0; iEtSum < (int)candEtSumVec->size(cond1bx); iEtSum++) {
                  if( (candEtSumVec->at(cond1bx,iEtSum))->getType() == type ) {
                    phiIndex1 =  (candEtSumVec->at(cond1bx,iEtSum))->hwPhi();
                    etaIndex1 =  (candEtSumVec->at(cond1bx,iEtSum))->hwEta();
                    etIndex1  =  (candEtSumVec->at(cond1bx,iEtSum))->hwPt();

                    // Determine Floating Pt numbers for floating point caluclation

                    if(cndObjTypeVec[1] == gtETM) {
                      std::pair<double, double> binEdges = m_gtScales->getETMScales().phiBins.at(phiIndex1);
                      phi1Phy = 0.5*(binEdges.second + binEdges.first);
                      eta1Phy = 0.; //No Eta for Energy Sums

                      etBin1 = etIndex1;
                      int ssize = m_gtScales->getETMScales().etBins.size();
                      assert(ssize > 0);
                      if (etBin1 >= ssize){ etBin1 = ssize-1; }

                      binEdges = m_gtScales->getETMScales().etBins.at(etBin1);
                      et1Phy = 0.5*(binEdges.second + binEdges.first);
                    } else if(cndObjTypeVec[1] == gtHTM) {
                      std::pair<double, double> binEdges = m_gtScales->getHTMScales().phiBins.at(phiIndex1);
                      phi1Phy = 0.5*(binEdges.second + binEdges.first);
                      eta1Phy = 0.; //No Eta for Energy Sums

                      etBin1 = etIndex1;
                      int ssize = m_gtScales->getHTMScales().etBins.size();
                      assert(ssize > 0);
                    if (etBin1 >= ssize){ etBin1 = ssize-1; }

                      binEdges = m_gtScales->getHTMScales().etBins.at(etBin1);
                      et1Phy = 0.5*(binEdges.second + binEdges.first);
                    } else if(cndObjTypeVec[1] == gtETMHF) {
                      std::pair<double, double> binEdges = m_gtScales->getETMHFScales().phiBins.at(phiIndex1);
                      phi1Phy = 0.5*(binEdges.second + binEdges.first);
                      eta1Phy = 0.; //No Eta for Energy Sums
                      etBin1 = etIndex1;
                      int ssize = m_gtScales->getETMHFScales().etBins.size();
                      assert(ssize > 0);
                      if (etBin1 >= ssize){ etBin1 = ssize-1; }
                      binEdges = m_gtScales->getETMHFScales().etBins.at(etBin1);
                      et1Phy = 0.5*(binEdges.second + binEdges.first);
                    }

                    phiORIndex1 = phiIndex1;
                    etaORIndex1 = etaIndex1;

                    //If needed convert calo scales to muon scales for comparison (only phi for energy sums)
                    if(convertCaloScales) {

                      std::string lutName = lutObj1;
                      lutName += "-MU";
                      long long tst = m_gtScales->getLUT_CalMuPhi(lutName,phiIndex1);
                      LogDebug("L1TGlobal") << lutName <<"  PhiCal = " << phiIndex1 << " PhiMu = " << tst << std::endl;
                      phiIndex1 = tst;

                    }

                    //If needed convert calo scales to muon scales for comparison (only phi for energy sums)
                    if(convertCaloScalesForOverlapRemovalFromLeg1) {
                      phiORIndex1 = phiIndex1;
                    }

                  } //check it is the EtSum we want
                } // loop over Etsums

              } // end case EnergySum
                break;
              default: {
                // should not arrive here, there are no correlation conditions defined for this object
                LogDebug("L1TGlobal") << "Error could not find the Cond Category for Leg 0" << std::endl;
                return false;
              }
                break;
            } //end switch on second leg

            unsigned int overlapRemovalMatchLeg2 = 0x0;

            // ///////////////////////////////////////////////////////////////////////////////////////////
            // loop over overlap-removal leg combination which produced individually "true" as Type1s
            // ///////////////////////////////////////////////////////////////////////////////////////////
            for (std::vector<SingleCombInCond>::const_iterator it2Comb = cond2Comb.begin(); it2Comb != cond2Comb.end() && overlapRemovalMatchLeg2 != 0x1; it2Comb++) {

              // Type1s: there is 1 object only, no need for a loop, index 0 should be OK in (*it2Comb)[0]
              // ... but add protection to not crash
              int obj2Index = -1;

              if (!(*it2Comb).empty()) {
                  obj2Index = (*it2Comb)[0];
              } else {
                LogTrace("L1TGlobal")
                << "\n  SingleCombInCond (*it2Comb).size() "
                << ((*it2Comb).size()) << std::endl;
                return false;
              }

              // Collect the information on the overlap-removal leg
              switch (cond2Categ) {
                case CondMuon: {
                  lutObj2 = "MU";
                  candMuVec = m_uGtB->getCandL1Mu();
                  phiIndex2 =  (candMuVec->at(cond2bx,obj2Index))->hwPhi(); //(*candMuVec)[obj2Index]->phiIndex();
                  etaIndex2 =  (candMuVec->at(cond2bx,obj2Index))->hwEta();
                    int etaBin2 = etaIndex2;
                    if(etaBin2<0) etaBin2 = m_gtScales->getMUScales().etaBins.size() + etaBin2; //twos complement
                  //LogDebug("L1TGlobal") << "Muon phi" << phiIndex2 << " eta " << etaIndex2 << " etaBin2 = " << etaBin2  << " et " << etIndex2 << std::endl;

                    // Determine Floating Pt numbers for floating point caluclation
                    std::pair<double, double> binEdges = m_gtScales->getMUScales().phiBins.at(phiIndex2);
                    phi2Phy = 0.5*(binEdges.second + binEdges.first);
                    binEdges = m_gtScales->getMUScales().etaBins.at(etaBin2);
                    eta2Phy = 0.5*(binEdges.second + binEdges.first);

                    LogDebug("L1TGlobal") << "Found all quantities for the muon 0" << std::endl;
                }
                  break;

                // Calorimeter Objects (EG, Jet, Tau)
                case CondCalo: {

                  switch(cndObjTypeVec[2]) {

                    case gtEG: {
                      lutObj2 = "EG";
                      candCaloVec = m_uGtB->getCandL1EG();
                      phiIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwPhi();
                      etaIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwEta();
                      if(etaBin2<0) etaBin2 = m_gtScales->getEGScales().etaBins.size() + etaBin2;
                      //LogDebug("L1TGlobal") << "EG0 phi" << phiIndex2 << " eta " << etaIndex2 << " etaBin2 = " << etaBin2 << " et " << etIndex2 << std::endl;

                      // Determine Floating Pt numbers for floating point caluclation
                      std::pair<double, double> binEdges = m_gtScales->getEGScales().phiBins.at(phiIndex2);
                      phi2Phy = 0.5*(binEdges.second + binEdges.first);
                      binEdges = m_gtScales->getEGScales().etaBins.at(etaBin2);
                      eta2Phy = 0.5*(binEdges.second + binEdges.first);
                    }
                      break;

                    case gtJet: {
                      lutObj2 = "JET";
                      candCaloVec = m_uGtB->getCandL1Jet();
                      phiIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwPhi();
                      etaIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwEta();
                      etaBin2 = etaIndex2;
                      if(etaBin2<0) etaBin2 = m_gtScales->getJETScales().etaBins.size() + etaBin2;
                      // Determine Floating Pt numbers for floating point caluclation
                      std::pair<double, double> binEdges = m_gtScales->getJETScales().phiBins.at(phiIndex2);
                      phi2Phy = 0.5*(binEdges.second + binEdges.first);
                      binEdges = m_gtScales->getJETScales().etaBins.at(etaBin2);
                      eta2Phy = 0.5*(binEdges.second + binEdges.first);
                    }
                      break;
                    case gtTau: {
                      candCaloVec = m_uGtB->getCandL1Tau();
                      phiIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwPhi();
                      etaIndex2 =  (candCaloVec->at(cond2bx,obj2Index))->hwEta();
                      if(etaBin2<0) etaBin2 = m_gtScales->getTAUScales().etaBins.size() + etaBin2;

                      // Determine Floating Pt numbers for floating point caluclation
                      std::pair<double, double> binEdges = m_gtScales->getTAUScales().phiBins.at(phiIndex2);
                      phi2Phy = 0.5*(binEdges.second + binEdges.first);
                      binEdges = m_gtScales->getTAUScales().etaBins.at(etaBin2);
                      eta2Phy = 0.5*(binEdges.second + binEdges.first);
                      lutObj2 = "TAU";
                    }
                     break;
                    default: {
                    }
                      break;

                  } //end switch on calo type.

                  //If needed convert calo scales to muon scales for comparison
                  if(convertCaloScales) {
                    std::string lutName = lutObj2;
                    lutName += "-MU";
                    long long tst = m_gtScales->getLUT_CalMuEta(lutName,etaBin2);
                    LogDebug("L1TGlobal") << lutName <<"  EtaCal = " << etaIndex2 << " etaBin2 = " << etaBin2 << " EtaMu = " << tst << std::endl;
                    etaIndex2 = tst;

                    tst = m_gtScales->getLUT_CalMuPhi(lutName,phiIndex2);
                    LogDebug("L1TGlobal") << lutName <<"  PhiCal = " << phiIndex2 << " PhiMu = " << tst << std::endl;
                    phiIndex2 = tst;

                }

              }
                break;

              // Energy Sums
              case CondEnergySum: {

                  etSumCond = true;
                    //Stupid mapping between enum types for energy sums.
                    l1t::EtSum::EtSumType type;
                    switch( cndObjTypeVec[2] ){
                    case gtETM:
                      type = l1t::EtSum::EtSumType::kMissingEt;
                      lutObj2 = "ETM";
                      break;
                    case gtETT:
                      type = l1t::EtSum::EtSumType::kTotalEt;
                      lutObj2 = "ETT";
                      break;
                    case gtETTem:
                      type = l1t::EtSum::EtSumType::kTotalEtEm;
                      lutObj2 = "ETTem"; //should this be just ETT (share LUTs?) Can't be used for CorrCond anyway since now directional information
                      break;
                    case gtHTM:
                      type = l1t::EtSum::EtSumType::kMissingHt;
                      lutObj2 = "HTM";
                      break;
                    case gtHTT:
                      type = l1t::EtSum::EtSumType::kTotalHt;
                      lutObj2 = "HTT";
                      break;
                    case gtETMHF:
                      type = l1t::EtSum::EtSumType::kMissingEtHF;
                      lutObj2 = "ETMHF";
                      break;
                    case gtMinBiasHFP0:
                    case gtMinBiasHFM0:
                    case gtMinBiasHFP1:
                    case gtMinBiasHFM1:
                      type = l1t::EtSum::EtSumType::kMinBiasHFP0;
                      lutObj2 = "MinBias"; //??Fix?? Not a valid LUT type Can't be used for CorrCond anyway since now directional information
                      break;
                    default:
                      edm::LogError("L1TGlobal")
                        << "\n  Error: "
                        << "Unmatched object type from template to EtSumType, cndObjTypeVec[2] = "
                        << cndObjTypeVec[2]
                        << std::endl;
                      type = l1t::EtSum::EtSumType::kTotalEt;
                      break;
                    }

                  candEtSumVec = m_uGtB->getCandL1EtSum();

                  for( int iEtSum=0; iEtSum < (int)candEtSumVec->size(cond2bx); iEtSum++) {
                    if( (candEtSumVec->at(cond2bx,iEtSum))->getType() == type ) {
                      phiIndex2 =  (candEtSumVec->at(cond2bx,iEtSum))->hwPhi();
                      etaIndex2 =  (candEtSumVec->at(cond2bx,iEtSum))->hwEta();

                      //  Get the floating point numbers
                      if(cndObjTypeVec[2] == gtETM ) {
                        std::pair<double, double> binEdges = m_gtScales->getETMScales().phiBins.at(phiIndex2);
                        phi2Phy = 0.5*(binEdges.second + binEdges.first);
                        eta2Phy = 0.; //No Eta for Energy Sums

                      } else if (cndObjTypeVec[2] == gtHTM) {
                        std::pair<double, double> binEdges = m_gtScales->getHTMScales().phiBins.at(phiIndex2);
                        phi2Phy = 0.5*(binEdges.second + binEdges.first);
                        eta2Phy = 0.; //No Eta for Energy Sums

                      } else if (cndObjTypeVec[2] == gtETMHF) {
                        std::pair<double, double> binEdges = m_gtScales->getETMHFScales().phiBins.at(phiIndex2);
                        phi2Phy = 0.5*(binEdges.second + binEdges.first);
                        eta2Phy = 0.; //No Eta for Energy Sums

                      }

                      //If needed convert calo scales to muon scales for comparison (only phi for energy sums)
                      if(convertCaloScales) {
                        std::string lutName = lutObj2;
                        lutName += "-MU";
                        long long tst = m_gtScales->getLUT_CalMuPhi(lutName,phiIndex2);
                        LogDebug("L1TGlobal") << lutName <<"  PhiCal = " << phiIndex2 << " PhiMu = " << tst << std::endl;
                        phiIndex2 = tst;
                      }

                    } //check it is the EtSum we want
                  } // loop over Etsums

                } // end case CondEnerySum
                  break;
                default: {
                  // should not arrive here, there are no correlation conditions defined for this object
                    LogDebug("L1TGlobal") << "Error could not find the Cond Category for Leg 3" << std::endl;
                  return false;
                }
                    break;
              } //end switch on overlap-removal leg type

              // /////////////////////////////////////////////////////////////////////////////////////////
              //
              // here check if there is a match of 2st leg with overlap removal object ...if yes, continue
              //
              // /////////////////////////////////////////////////////////////////////////////////////////
              // These all require some delta eta and phi calculations.  Do them first...for now real calculation but need to
              // revise this to line up with firmware calculations.
              double deltaPhiPhy  = fabs(phi2Phy - phi1Phy);
              if(deltaPhiPhy> M_PI) deltaPhiPhy = 2.*M_PI - deltaPhiPhy;
              double deltaEtaPhy  = fabs(eta2Phy - eta1Phy);

              // Deter the integer based delta eta and delta phi
              int deltaPhiFW = abs(phiORIndex1 - phiIndex2);
              if(deltaPhiFW>=phiBound) deltaPhiFW = 2*phiBound - deltaPhiFW;
              std::string lutName = lutObj1;
              lutName += "-";
              lutName += lutObj2;
              long long deltaPhiLUT = m_gtScales->getLUT_DeltaPhi(lutName,deltaPhiFW);
              unsigned int precDeltaPhiLUT = m_gtScales->getPrec_DeltaPhi(lutName);

              int deltaEtaFW = abs(etaORIndex1 - etaIndex2);
              long long deltaEtaLUT = 0;
              unsigned int precDeltaEtaLUT = 0;
              if(!etSumCond) {
                deltaEtaLUT = m_gtScales->getLUT_DeltaEta(lutName,deltaEtaFW);
                precDeltaEtaLUT = m_gtScales->getPrec_DeltaEta(lutName);
              }

              LogDebug("L1TGlobal") << "Obj1 phiFW = " << phiORIndex1 << " Obj2 phiFW = " << phiIndex2 << "\n"
              << "    DeltaPhiFW = " << deltaPhiFW << "\n"
              << "    LUT Name = " << lutName << " Prec = " << precDeltaPhiLUT << "  DeltaPhiLUT = " << deltaPhiLUT << "\n"
              << "Obj1 etaFW = " << etaIndex1 << " Obj1 etaFW = " << etaIndex1 << "\n"
              << "    DeltaEtaFW = " << deltaEtaFW << "\n"
              << "    LUT Name = " << lutName << " Prec = " << precDeltaEtaLUT << "  DeltaEtaLUT = " << deltaEtaLUT << std::endl;

              // If there is a OverlapRemovalDeltaEta cut, check it.
              // /////////////////////////////////////////////////
              if(corrPar.corrCutType & 0x10) {

                unsigned int preShift = precDeltaEtaLUT - corrPar.precOverlapRemovalEtaCut;
                LogDebug("L1TGlobal")    << "    Testing Leg2 Overlap Removal Delta Eta Cut (" << lutObj1 << "," << lutObj2 << ") [" << (long long)(corrPar.minOverlapRemovalEtaCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxOverlapRemovalEtaCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precOverlapRemovalEtaCut <<"\n"
                << "    deltaEtaLUT = " << deltaEtaLUT << "\n"
                << "    Precision Shift = " << preShift << "\n"
                << "    deltaEta (shift)= " << (deltaEtaLUT/pow(10,preShift+corrPar.precOverlapRemovalEtaCut)) << "\n"
                << "    deltaEtaPhy = " <<  deltaEtaPhy << std::endl;

                //if(preShift>0) deltaEtaLUT /= pow(10,preShift);
                if( deltaEtaLUT >= (long long)(corrPar.minOverlapRemovalEtaCutValue*pow(10,preShift)) &&
                  deltaEtaLUT <= (long long)(corrPar.maxOverlapRemovalEtaCutValue*pow(10,preShift)) ) {

                  overlapRemovalMatchLeg2 |= 0x1;
                  LogDebug("L1TGlobal") << "    Satisfied Leg2 Overlap Removal Delta Eta Cut [" << (long long)(corrPar.minOverlapRemovalEtaCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalEtaCutValue*pow(10,preShift)) << "]" << std::endl;
                  // next leg3 object
                  continue;

                } else {

                  LogDebug("L1TGlobal")  << "    Failed Leg2 Overlap Removal Delta Eta Cut [" << (long long)(corrPar.minOverlapRemovalEtaCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalEtaCutValue*pow(10,preShift)) << "]" << std::endl;
                }
              }
              // If there is a OverlapRemovalDeltaPhi cut, check it.
              // /////////////////////////////////////////////////
              if(corrPar.corrCutType & 0x20) {

                unsigned int preShift = precDeltaPhiLUT - corrPar.precOverlapRemovalPhiCut;
                LogDebug("L1TGlobal")  << "    Testing Delta Phi Cut (" << lutObj1 << "," << lutObj2 << ") [" << (long long)(corrPar.minOverlapRemovalPhiCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxOverlapRemovalPhiCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precOverlapRemovalPhiCut <<"\n"
                << "    deltaPhiLUT = " << deltaPhiLUT  << "\n"
                << "    Precision Shift = " << preShift << "\n"
                << "    deltaPhi (shift)= " << (deltaPhiLUT/pow(10,preShift+corrPar.precOverlapRemovalPhiCut)) << "\n"
                << "    deltaPhiPhy = " <<  deltaPhiPhy << std::endl;

                //if(preShift>0) deltaPhiLUT /= pow(10,preShift);
                if( deltaPhiLUT >= (long long)(corrPar.minOverlapRemovalPhiCutValue*pow(10,preShift)) &&
                  deltaPhiLUT <= (long long)(corrPar.maxOverlapRemovalPhiCutValue*pow(10,preShift)) ) {

                  overlapRemovalMatchLeg2 |= 0x1;
                  LogDebug("L1TGlobal")  << "    Satisfied Leg2 Overlap Removal Delta Phi Cut [" << (long long)(corrPar.minOverlapRemovalPhiCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalPhiCutValue*pow(10,preShift)) << "]" << std::endl;
                  // next leg3 object
                  continue;

                } else {

                  LogDebug("L1TGlobal") << "    Failed Leg2 Overlap Removal Delta Phi Cut [" << (long long)(corrPar.minOverlapRemovalPhiCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalPhiCutValue*pow(10,preShift)) << "]" << std::endl;
                }
              }

              //if there is a OverlapRemovalDeltaR cut, check it.
              // /////////////////////////////////////////////////
              if(corrPar.corrCutType & 0x40) {

                //Assumes Delta Eta and Delta Phi LUTs have the same precision
                unsigned int preShift = 2*precDeltaPhiLUT  - corrPar.precOverlapRemovalDRCut;
                double deltaRSqPhy = deltaPhiPhy*deltaPhiPhy + deltaEtaPhy*deltaEtaPhy;
                long long deltaRSq = deltaEtaLUT*deltaEtaLUT + deltaPhiLUT*deltaPhiLUT;

                LogDebug("L1TGlobal") << "    Testing Leg2 Overlap Removal Delta R Cut (" << lutObj1 << "," << lutObj2 << ") [" << (long long)(corrPar.minOverlapRemovalDRCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxOverlapRemovalDRCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precOverlapRemovalDRCut <<"\n"
                << "    deltaPhiLUT = " << deltaPhiLUT << "\n"
                << "    deltaEtaLUT = " << deltaEtaLUT << "\n"
                << "    deltaRSqLUT = " << deltaRSq <<  "\n"
                << "    Precision Shift = " << preShift << "\n"
                << "    deltaRSqLUT (shift)= " << (deltaRSq/pow(10,preShift+corrPar.precDRCut)) << "\n"
                << "    deltaRSqPhy = " << deltaRSqPhy << std::endl;

                //if(preShift>0) deltaRSq /= pow(10,preShift);
                if( deltaRSq >= (long long)(corrPar.minOverlapRemovalDRCutValue*pow(10,preShift)) &&
                  deltaRSq <= (long long)(corrPar.maxOverlapRemovalDRCutValue*pow(10,preShift)) ) {

                  overlapRemovalMatchLeg2 |= 0x1;
                  LogDebug("L1TGlobal") << "    Satisfied Leg2 Overlap Removal Delta R Cut [" << (long long)(corrPar.minOverlapRemovalDRCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalDRCutValue*pow(10,preShift)) << "]" << std::endl;
                  // next leg3 object
                  continue;

                } else {

                  LogDebug("L1TGlobal") << "    Failed Leg2 Overlap Removal Delta R Cut [" << (int)(corrPar.minOverlapRemovalDRCutValue*pow(10,preShift))
                  << "," << (long long)(corrPar.maxOverlapRemovalDRCutValue*pow(10,preShift)) << "]" << std::endl;
                }
              }

            } // end loop over combinations in overlap-removal leg.

            // skip object leg2 if matched with overlap removal object
            // ///////////////////////////////////////////////////////
            if (overlapRemovalMatchLeg2 == 0x1) {
              LogDebug("L1TGlobal") << "   Remove Object of Leg2: Satisfied Overlap Removal Cuts" << std::endl;
              continue;
            }
            else {
              LogDebug("L1TGlobal") << "   Keep Object of Leg2: Failed Overlap Removal Cuts " << std::endl;
            }


            // ///////////////////////////////////////////////////////
            // At this point, both correlation legs are cleared of overlaps
            // ///////////////////////////////////////////////////////

            if (m_verbosity) {
                LogDebug("L1TGlobal") << "    Correlation pair ["
                        << l1TGtObjectEnumToString(cndObjTypeVec[0]) << ", "
                        << l1TGtObjectEnumToString(cndObjTypeVec[1])
                        << "] with collection indices [" << obj0Index << ", "
                        << obj1Index << "] " << " has: \n"
                        << "     Et  value   = ["<< etIndex0  << ", " << etIndex1  << "]\n"
                        << "     phi indices = ["<< phiIndex0 << ", " << phiIndex1 << "]\n"
                        << "     eta indices = ["<< etaIndex0 << ", " << etaIndex1 << "]\n"
                        << "     chrg        = ["<< chrg0     << ", " << chrg1     << "]\n"<< std::endl;
            }


            // Now perform the desired correlation on these two objects. Assume true until we find a contradition
            bool reqResult = true;

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

            objectsInComb.push_back(obj0Index);
            objectsInComb.push_back(obj1Index);

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


            // These all require some delta eta and phi calculations.  Do them first...for now real calculation but need to
            // revise this to line up with firmware calculations.
            double deltaPhiPhy  = fabs(phi1Phy - phi0Phy);
            if(deltaPhiPhy> M_PI) deltaPhiPhy = 2.*M_PI - deltaPhiPhy;
            double deltaEtaPhy  = fabs(eta1Phy - eta0Phy);


            // Determine the integer based delta eta and delta phi
            int deltaPhiFW = abs(phiIndex0 - phiIndex1);
            if(deltaPhiFW>=phiBound) deltaPhiFW = 2*phiBound - deltaPhiFW;
            std::string lutName = lutObj0;
            lutName += "-";
            lutName += lutObj1;
            long long deltaPhiLUT = m_gtScales->getLUT_DeltaPhi(lutName,deltaPhiFW);
            unsigned int precDeltaPhiLUT = m_gtScales->getPrec_DeltaPhi(lutName);

            int deltaEtaFW = abs(etaIndex0 - etaIndex1);
            long long  deltaEtaLUT = 0;
            unsigned int precDeltaEtaLUT = 0;
            if(!etSumCond) {
               deltaEtaLUT = m_gtScales->getLUT_DeltaEta(lutName,deltaEtaFW);
              precDeltaEtaLUT = m_gtScales->getPrec_DeltaEta(lutName);
            }

            //
            LogDebug("L1TGlobal") << "Obj0 phiFW = " << phiIndex0 << " Obj1 phiFW = " << phiIndex1 << "\n"
            << "    DeltaPhiFW = " << deltaPhiFW << "\n"
            << "    LUT Name = " << lutName << " Prec = " << precDeltaPhiLUT << "  DeltaPhiLUT = " << deltaPhiLUT << "\n"
            << "Obj0 etaFW = " << etaIndex0 << " Obj1 etaFW = " << etaIndex1 << "\n"
            << "    DeltaEtaFW = " << deltaEtaFW << "\n"
            << "    LUT Name = " << lutName << " Prec = " << precDeltaEtaLUT << "  DeltaEtaLUT = " << deltaEtaLUT << std::endl;


            // If there is a delta eta, check it.
            if(corrPar.corrCutType & 0x1) {

              unsigned int preShift = precDeltaEtaLUT - corrPar.precEtaCut;
              LogDebug("L1TGlobal")    << "    Testing Delta Eta Cut (" << lutObj0 << "," << lutObj1 << ") [" << (long long)(corrPar.minEtaCutValue*pow(10,preShift))
               << "," << (long long)(corrPar.maxEtaCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precEtaCut <<"\n"
                       << "    deltaEtaLUT = " << deltaEtaLUT << "\n"
                       << "    Precision Shift = " << preShift << "\n"
                       << "    deltaEta (shift)= " << (deltaEtaLUT/pow(10,preShift+corrPar.precEtaCut)) << "\n"
                       << "    deltaEtaPhy = " <<  deltaEtaPhy << std::endl;

              //if(preShift>0) deltaEtaLUT /= pow(10,preShift);
              if( deltaEtaLUT >= (long long)(corrPar.minEtaCutValue*pow(10,preShift)) &&
                  deltaEtaLUT <= (long long)(corrPar.maxEtaCutValue*pow(10,preShift)) ) {

                LogDebug("L1TGlobal") << "    Passed Delta Eta Cut [" << (long long)(corrPar.minEtaCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxEtaCutValue*pow(10,preShift)) << "]" << std::endl;

              } else {

                LogDebug("L1TGlobal")  << "    Failed Delta Eta Cut [" << (long long)(corrPar.minEtaCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxEtaCutValue*pow(10,preShift)) << "]" << std::endl;
                reqResult = false;
              }
            }

            //if there is a delta phi check it.
            if(corrPar.corrCutType & 0x2) {

              unsigned int preShift = precDeltaPhiLUT - corrPar.precPhiCut;
              LogDebug("L1TGlobal")  << "    Testing Delta Phi Cut (" << lutObj0 << "," << lutObj1 << ") [" << (long long)(corrPar.minPhiCutValue*pow(10,preShift))
              << "," << (long long)(corrPar.maxPhiCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precPhiCut <<"\n"
              << "    deltaPhiLUT = " << deltaPhiLUT  << "\n"
              << "    Precision Shift = " << preShift << "\n"
              << "    deltaPhi (shift)= " << (deltaPhiLUT/pow(10,preShift+corrPar.precPhiCut)) << "\n"
              << "    deltaPhiPhy = " <<  deltaPhiPhy << std::endl;

              //if(preShift>0) deltaPhiLUT /= pow(10,preShift);
              if( deltaPhiLUT >= (long long)(corrPar.minPhiCutValue*pow(10,preShift)) &&
                  deltaPhiLUT <= (long long)(corrPar.maxPhiCutValue*pow(10,preShift)) ) {

                LogDebug("L1TGlobal")  << "    Passed Delta Phi Cut [" << (long long)(corrPar.minPhiCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxPhiCutValue*pow(10,preShift)) << "]" << std::endl;

              } else {

                LogDebug("L1TGlobal") << "    Failed Delta Phi Cut [" << (long long)(corrPar.minPhiCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxPhiCutValue*pow(10,preShift)) << "]" << std::endl;
                reqResult = false;

              }
            }

            if(corrPar.corrCutType & 0x4) {

              //Assumes Delta Eta and Delta Phi LUTs have the same precision
              unsigned int preShift = 2*precDeltaPhiLUT  - corrPar.precDRCut;
              double deltaRSqPhy = deltaPhiPhy*deltaPhiPhy + deltaEtaPhy*deltaEtaPhy;
              long long deltaRSq = deltaEtaLUT*deltaEtaLUT + deltaPhiLUT*deltaPhiLUT;

              LogDebug("L1TGlobal") << "    Testing Delta R Cut (" << lutObj0 << "," << lutObj1 << ") [" << (long long)(corrPar.minDRCutValue*pow(10,preShift))
              << "," << (long long)(corrPar.maxDRCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precDRCut <<"\n"
              << "    deltaPhiLUT = " << deltaPhiLUT << "\n"
              << "    deltaEtaLUT = " << deltaEtaLUT << "\n"
              << "    deltaRSqLUT = " << deltaRSq <<  "\n"
              << "    Precision Shift = " << preShift << "\n"
              << "    deltaRSqLUT (shift)= " << (deltaRSq/pow(10,preShift+corrPar.precDRCut))   << "\n"
              << "    deltaRSqPhy = " << deltaRSqPhy << std::endl;

              //if(preShift>0) deltaRSq /= pow(10,preShift);
              if( deltaRSq >= (long long)(corrPar.minDRCutValue*pow(10,preShift)) &&
                deltaRSq <= (long long)(corrPar.maxDRCutValue*pow(10,preShift)) ) {

                LogDebug("L1TGlobal") << "    Passed Delta R Cut [" << (long long)(corrPar.minDRCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxDRCutValue*pow(10,preShift)) << "]" << std::endl;

              } else {

                LogDebug("L1TGlobal") << "    Failed Delta R Cut [" << (int)(corrPar.minDRCutValue*pow(10,preShift))
                << "," << (long long)(corrPar.maxDRCutValue*pow(10,preShift)) << "]" << std::endl;
                reqResult = false;
              }

          }

        if(corrPar.corrCutType & 0x20) {
          // Two body pt: pt^2 = pt1^2+pt2^2+2*pt1*pt2*(cos(phi1)*cos(phi2)+sin(phi1)*sin(phi2)).

          LogDebug("L1TGlobal") << " corrPar.corrCutType: " << corrPar.corrCutType<< "\n";

          //calculate math sins and cosines for debugging
          double cosPhi1Phy  = cos(phi0Phy);
          double sinPhi1Phy  = sin(phi0Phy);
          double cosPhi2Phy  = cos(phi1Phy);
          double sinPhi2Phy  = sin(phi1Phy);

          double tbptSqPhy = et0Phy*et0Phy + et1Phy*et1Phy + 2*et0Phy*et1Phy*(cosPhi1Phy*cosPhi2Phy + sinPhi1Phy*sinPhi2Phy);
          // get values from LUT's

          const std::string& lutName0 = lutObj0;
          unsigned int precCosLUT0 = m_gtScales->getPrec_Cos(lutName0);
          unsigned int precSinLUT0 = m_gtScales->getPrec_Sin(lutName0);

          const std::string& lutName1 = lutObj1;
          unsigned int precCosLUT1 = m_gtScales->getPrec_Cos(lutName1);
          unsigned int precSinLUT1 = m_gtScales->getPrec_Sin(lutName1);

          if(precCosLUT0 - precCosLUT1 != 0) LogDebug("L1TGlobal") << "Warning: Cos LUTs for TwoBodyPt on different Precision" << std::endl;
          if(precSinLUT0 - precSinLUT1 != 0) LogDebug("L1TGlobal") << "Warning: Sin LUTs for TwoBodyPt on different Precision" << std::endl;
          if(precSinLUT0 - precCosLUT1 != 0) LogDebug("L1TGlobal") << "Warning: Sin and Cos LUTs for TwoBodyPt on different Precision" << std::endl;
          if(precSinLUT1 - precCosLUT0 != 0) LogDebug("L1TGlobal") << "Warning: Sin and Cos LUTs for TwoBodyPt on different Precision" << std::endl;


          long long cosPhi1LUT = m_gtScales->getLUT_Cos(lutName0,phiIndex0);
          long long sinPhi1LUT = m_gtScales->getLUT_Sin(lutName0,phiIndex0);

          long long cosPhi2LUT = m_gtScales->getLUT_Cos(lutName1,phiIndex1);
          long long sinPhi2LUT = m_gtScales->getLUT_Sin(lutName1,phiIndex1);

          // now get pt LUTs
          std::string lutName = lutObj0;
          lutName += "-ET";
          long long ptObj0 = m_gtScales->getLUT_Pt("TwoBody_" + lutName,etIndex0);
          unsigned int precPtLUTObj0 = m_gtScales->getPrec_Pt("TwoBody_" + lutName);

          lutName = lutObj1;
          lutName += "-ET";
          long long ptObj1 = m_gtScales->getLUT_Pt("TwoBody_" + lutName,etIndex1);
          unsigned int precPtLUTObj1 = m_gtScales->getPrec_Pt("TwoBody_" + lutName);

          LogTrace("L1TGlobal") << " TBPT Trig precisions:\t " << precCosLUT0 << "\t" << precCosLUT1 << "\t" << precSinLUT0 << "\t" << precSinLUT1;
          LogTrace("L1TGlobal") << " TBPT Pt precisions:\t " << precPtLUTObj0 << "\t" << precPtLUTObj1;
          LogTrace("L1TGlobal") << " TBPT Pt cut:\t " <<  corrPar.minTBPTCutValue << "\tPrecTBPTCut\t" <<  corrPar.precTBPTCut ;
          LogTrace("L1TGlobal") << " TBPT Pt1*Pt1 -- Phys:\t " <<  et0Phy*et0Phy << "\tHW:\t" << ptObj0*ptObj0*(pow(10,6));
          LogTrace("L1TGlobal") << " TBPT Pt2*Pt2 -- Phys:\t " <<  et1Phy*et1Phy << "\tHW:\t" << ptObj1*ptObj1*(pow(10,6));
          LogTrace("L1TGlobal") << " TBPT 2Pt1*Pt2 -- Phys:\t " << 2*et0Phy*et1Phy  << "\tHW:\t" << 2*(ptObj0*pow(10,0))*(ptObj1*pow(10,0));
          LogTrace("L1TGlobal") << " TBPT Trig -- Phys:\t " <<  cosPhi1Phy*cosPhi2Phy + sinPhi1Phy*sinPhi2Phy << "\tHW:\t" << cosPhi1LUT*cosPhi2LUT + sinPhi1LUT*sinPhi2LUT;

          //double tbptSqPhy =   et0Phy*et0Phy             + et1Phy*et1Phy + 2*et0Phy*et1Phy*(cosPhi1Phy*cosPhi2Phy + sinPhi1Phy*sinPhi2Phy);
          long long tbptSqHW =
        ptObj0*ptObj0*(pow(10,2*precCosLUT0)) +
        ptObj1*ptObj1*(pow(10,2*precCosLUT0)) +
        2*ptObj0*ptObj1*(cosPhi1LUT*cosPhi2LUT + sinPhi1LUT*sinPhi2LUT);

          unsigned int preShift = precPtLUTObj0  + precPtLUTObj1 + 2*precCosLUT0;

          LogTrace("L1TGlobal") << "TBPT Result -- Phys: " << tbptSqPhy << "\tHW: " << tbptSqHW << "\tShifted\t" << tbptSqHW/pow(10,preShift) << std::endl;

          preShift=preShift - corrPar.precTBPTCut;


          LogDebug("L1TGlobal") << "    Testing Two Body Pt Cut (" << lutObj0 << "," << lutObj1
                    << ") [" << (long long)(corrPar.minTBPTCutValue*pow(10,preShift))
                    << ","   << (long long)(corrPar.maxTBPTCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precTBPTCut <<"\n"
                    << "    etIndex0     = " << etIndex0 << "    pt0LUT      = " << ptObj0 << " PhyEt0 = " << et0Phy  << "\n"
                    << "    etIndex1     = " << etIndex1 << "    pt1LUT      = " << ptObj1 << " PhyEt1 = " << et1Phy  <<"\n"
                    << "    Precision Shift = " << preShift << "\n"
                    << "    Sin(phi1): LUT/Phys\t " << sinPhi1LUT << " / " << sinPhi1Phy << "\n"
                    << "    Sin(phi2): LUT/Phys\t " << sinPhi2LUT << " / " << sinPhi2Phy << "\n"
                    << "    Cos(phi1): LUT/Phys\t " << cosPhi1LUT << " / " << cosPhi1Phy << "\n"
                    << "    Cos(phi2): LUT/Phys\t " << cosPhi2LUT << " / " << cosPhi2Phy << "\n"

        //    << "    deltaPhiLUT = " << deltaPhiLUT << "\n"
        //    << "    deltaEtaLUT = " << deltaEtaLUT << "\n"
        //    << "    deltaRSqLUT = " << deltaRSq <<  "\n"
        //    << "    Precision Shift = " << preShift << "\n"
        //    << "    deltaRSqLUT (shift)= " << (deltaRSq/pow(10,preShift+corrPar.precDRCut))   << "\n"
        //    << "    deltaRSqPhy = " << deltaRSqPhy
                    << std::endl;

          if(  tbptSqHW > 0. &&
           tbptSqHW >= (long long)(corrPar.minTBPTCutValue*pow(10,preShift)) ) {
        LogDebug("L1TGlobal") << "    Passed Two Body pT Cut [" << (long long)(corrPar.minTBPTCutValue*pow(10,preShift))
                      << "]" << "\twith value: " << tbptSqHW << "\n"
                      << "\tPhysics Cut[" << corrPar.minTBPTCutValue/pow(10,corrPar.precTBPTCut) << "]\tPhysics Value: " << tbptSqPhy
                      << std::endl;

          } else {

        LogDebug("L1TGlobal") << "    Failed Two Body pT Cut [" << (long long)(corrPar.minTBPTCutValue*pow(10,preShift))
                      << "]" << "\t with value: " << tbptSqHW << "\n"
                      << "\tPhysics Cut[" << corrPar.minTBPTCutValue/pow(10,corrPar.precTBPTCut) << "]\tPhysics Value: " << tbptSqPhy
                      << std::endl;
        reqResult = false;
          }
        }

          if(corrPar.corrCutType & 0x8 || corrPar.corrCutType & 0x10) {

            //invariant mass calculation based on
            // M = sqrt(2*p1*p2(cosh(eta1-eta2) - cos(phi1 - phi2)))
            // but we calculate (1/2)M^2
            //
            double cosDeltaPhiPhy  = cos(deltaPhiPhy);
            double coshDeltaEtaPhy = cosh(deltaEtaPhy);
        if (corrPar.corrCutType & 0x10) coshDeltaEtaPhy=1.;
            double massSqPhy = et0Phy*et1Phy*(coshDeltaEtaPhy - cosDeltaPhiPhy);

            long long cosDeltaPhiLUT = m_gtScales->getLUT_DeltaPhi_Cos(lutName,deltaPhiFW);
            unsigned int precCosLUT = m_gtScales->getPrec_DeltaPhi_Cos(lutName);

        long long coshDeltaEtaLUT;
        if (corrPar.corrCutType & 0x10) {
          coshDeltaEtaLUT=1*pow(10,precCosLUT);
        }else{
          coshDeltaEtaLUT = m_gtScales->getLUT_DeltaEta_Cosh(lutName,deltaEtaFW);
          unsigned int precCoshLUT = m_gtScales->getPrec_DeltaEta_Cosh(lutName);
          if(precCoshLUT - precCosLUT != 0) LogDebug("L1TGlobal") << "Warning: Cos and Cosh LUTs on different Precision" << std::endl;
        }

            std::string lutName = lutObj0;
            lutName += "-ET";
            long long ptObj0 = m_gtScales->getLUT_Pt("Mass_" + lutName,etIndex0);
            unsigned int precPtLUTObj0 = m_gtScales->getPrec_Pt("Mass_" + lutName);

            lutName = lutObj1;
            lutName += "-ET";
            long long ptObj1 = m_gtScales->getLUT_Pt("Mass_" + lutName,etIndex1);
            unsigned int precPtLUTObj1 = m_gtScales->getPrec_Pt("Mass_" + lutName);

            // Pt and Angles are at different precission.
            long long massSq = ptObj0*ptObj1*(coshDeltaEtaLUT - cosDeltaPhiLUT);

            //Note: There is an assumption here that Cos and Cosh have the same precission
            unsigned int preShift = precPtLUTObj0  + precPtLUTObj1 + precCosLUT - corrPar.precMassCut;

            LogDebug("L1TGlobal") << "    Testing Invariant Mass (" << lutObj0 << "," << lutObj1 << ") [" << (long long)(corrPar.minMassCutValue*pow(10,preShift))
            << "," << (long long)(corrPar.maxMassCutValue*pow(10,preShift)) << "] with precision = " << corrPar.precMassCut <<"\n"
            << "    deltaPhiLUT  = " << deltaPhiLUT << "  cosLUT  = " << cosDeltaPhiLUT << "\n"
            << "    deltaEtaLUT  = " << deltaEtaLUT << "  coshLUT = " << coshDeltaEtaLUT << "\n"
            << "    etIndex0     = " << etIndex0 << "    pt0LUT      = " << ptObj0 << " PhyEt0 = " << et0Phy  << "\n"
            << "    etIndex1     = " << etIndex1 << "    pt1LUT      = " << ptObj1 << " PhyEt1 = " << et1Phy  <<"\n"
            << "    massSq/2     = " << massSq <<  "\n"
            << "    Precision Shift = " << preShift << "\n"
            << "    massSq   (shift)= " << (massSq/pow(10,preShift+corrPar.precMassCut)) << "\n"
            << "    deltaPhiPhy  = " << deltaPhiPhy << "  cos() = " << cosDeltaPhiPhy << "\n"
            << "    deltaEtaPhy  = " << deltaEtaPhy << "  cosh()= " << coshDeltaEtaPhy << "\n"
            << "    massSqPhy/2  = " << massSqPhy << "  sqrt(|massSq|) = "<< sqrt(fabs(2.*massSqPhy)) << std::endl;

            //if(preShift>0) massSq /= pow(10,preShift);
            if(  massSq >= 0 &&
              massSq >= (long long)(corrPar.minMassCutValue*pow(10,preShift)) &&
              massSq <= (long long)(corrPar.maxMassCutValue*pow(10,preShift))  ) {

              LogDebug("L1TGlobal") << "    Passed Invariant Mass Cut [" << (long long)(corrPar.minMassCutValue*pow(10,preShift))
              << "," << (long long)(corrPar.maxMassCutValue*pow(10,preShift)) << "]" << std::endl;

            } else {

            LogDebug("L1TGlobal") << "    Failed Invariant Mass Cut [" << (long long)(corrPar.minMassCutValue*pow(10,preShift))
              << "," << (long long)(corrPar.maxMassCutValue*pow(10,preShift)) << "]" << std::endl;
              reqResult = false;
            }

        }

        // For Muon-Muon Correlation Check the Charge Correlation if requested
              bool chrgCorrel = true;
        if(cond0Categ==CondMuon && cond1Categ==CondMuon) {
          // Check for like-sign
          if(corrPar.chargeCorrelation==2 && chrg0 != chrg1 ) chrgCorrel = false;
          // Check for opp-sign
          if(corrPar.chargeCorrelation==4 && chrg0 == chrg1 ) chrgCorrel = false;
        }


        if (reqResult & chrgCorrel) {

                condResult = true;
                (combinationsInCond()).push_back(objectsInComb);

         }

        } //end loop over second leg

    } //end loop over first leg



    if (m_verbosity  && condResult) {
        LogDebug("L1TGlobal") << " pass(es) the correlation condition.\n" << std::endl;
    }

    return condResult;

}

const l1t::L1Candidate * CorrWithOverlapRemovalCondition::getCandidate ( const int  bx, const int  indexCand  ) const

private

load candidates

Definition at line 2213 of file CorrWithOverlapRemovalCondition.cc.

References l1t::GlobalBoard::getCandL1EG(), l1t::GlobalBoard::getCandL1Jet(), l1t::GlobalBoard::getCandL1Tau(), l1t::gtEG, l1t::gtJet, l1t::gtTau, m_gtCorrelationWithOverlapRemovalTemplate, m_uGtB, and GlobalCondition::objectType().

Referenced by getuGtB().

                                                                                                              {

    // 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_gtCorrelationWithOverlapRemovalTemplate->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 GlobalBoard* l1t::CorrWithOverlapRemovalCondition::getuGtB ( ) const

inline

get / set the pointer to uGt GlobalBoard

Definition at line 84 of file CorrWithOverlapRemovalCondition.h.

References checkObjectParameter(), copy(), SimDataFormats::CaloAnalysis::cp, getCandidate(), m_uGtB, setScales(), and setuGtB().

Referenced by copy().

                                              {
        return m_uGtB;
    }

const CorrelationWithOverlapRemovalTemplate* l1t::CorrWithOverlapRemovalCondition::gtCorrelationWithOverlapRemovalTemplate ( ) const

inline

get / set the pointer to a Condition

Definition at line 77 of file CorrWithOverlapRemovalCondition.h.

References m_gtCorrelationWithOverlapRemovalTemplate, and setGtCorrelationWithOverlapRemovalTemplate().

Referenced by copy().

                                                                                                        {
        return m_gtCorrelationWithOverlapRemovalTemplate;
    }

l1t::CorrWithOverlapRemovalCondition & CorrWithOverlapRemovalCondition::operator=

(

const CorrWithOverlapRemovalCondition &

cp

)

Definition at line 128 of file CorrWithOverlapRemovalCondition.cc.

References copy().

                                                                                                                              {
    copy(cp);
    return *this;
}

void CorrWithOverlapRemovalCondition::print ( std::ostream &  myCout ) const

overridevirtual

print condition

Reimplemented from l1t::ConditionEvaluation.

Definition at line 2253 of file CorrWithOverlapRemovalCondition.cc.

References m_gtCorrelationWithOverlapRemovalTemplate, l1t::ConditionEvaluation::print(), and CorrelationWithOverlapRemovalTemplate::print().

Referenced by l1t::GlobalBoard::runGTL().

                                                                       {

    myCout << "Dummy Print for CorrWithOverlapRemovalCondition" << std::endl;
    m_gtCorrelationWithOverlapRemovalTemplate->print(myCout);


    ConditionEvaluation::print(myCout);

}

void CorrWithOverlapRemovalCondition::setGtCorrelationWithOverlapRemovalTemplate

(

const CorrelationWithOverlapRemovalTemplate *

caloTempl

)

Definition at line 134 of file CorrWithOverlapRemovalCondition.cc.

References m_gtCorrelationWithOverlapRemovalTemplate.

Referenced by gtCorrelationWithOverlapRemovalTemplate().

                                                                                                                                          {

    m_gtCorrelationWithOverlapRemovalTemplate = caloTempl;

}

void CorrWithOverlapRemovalCondition::setScales

(

const GlobalScales *

sc

)

Definition at line 148 of file CorrWithOverlapRemovalCondition.cc.

References m_gtScales, and SimDataFormats::CaloAnalysis::sc.

Referenced by getuGtB(), and l1t::GlobalBoard::runGTL().

{
    m_gtScales = sc;
}

void CorrWithOverlapRemovalCondition::setuGtB

(

const GlobalBoard *

ptrGTB

)

set the pointer to uGT GlobalBoard

Definition at line 141 of file CorrWithOverlapRemovalCondition.cc.

References m_uGtB.

Referenced by getuGtB().

                                                                          {

    m_uGtB = ptrGTB;

}

Member Data Documentation

const GlobalCondition* l1t::CorrWithOverlapRemovalCondition::m_gtCond0

private

Definition at line 127 of file CorrWithOverlapRemovalCondition.h.

Referenced by evaluateCondition().

const GlobalCondition* l1t::CorrWithOverlapRemovalCondition::m_gtCond1

private

Definition at line 128 of file CorrWithOverlapRemovalCondition.h.

Referenced by evaluateCondition().

const GlobalCondition* l1t::CorrWithOverlapRemovalCondition::m_gtCond2

private

Definition at line 129 of file CorrWithOverlapRemovalCondition.h.

Referenced by evaluateCondition().

const CorrelationWithOverlapRemovalTemplate* l1t::CorrWithOverlapRemovalCondition::m_gtCorrelationWithOverlapRemovalTemplate

private

pointer to a CorrelationWithOverlapRemovalTemplate

Definition at line 123 of file CorrWithOverlapRemovalCondition.h.

Referenced by copy(), evaluateCondition(), getCandidate(), gtCorrelationWithOverlapRemovalTemplate(), print(), and setGtCorrelationWithOverlapRemovalTemplate().

const GlobalScales* l1t::CorrWithOverlapRemovalCondition::m_gtScales

private

Definition at line 134 of file CorrWithOverlapRemovalCondition.h.

Referenced by evaluateCondition(), and setScales().

const GlobalBoard* l1t::CorrWithOverlapRemovalCondition::m_uGtB

private

pointer to uGt GlobalBoard, to be able to get the trigger objects

Definition at line 132 of file CorrWithOverlapRemovalCondition.h.

Referenced by copy(), evaluateCondition(), getCandidate(), getuGtB(), and setuGtB().