This is an internal class, used in the jet trigger. More...

#include <JEMJetAlgorithm.h>

Collaboration diagram for LVL1::JEMJetAlgorithm:

Public Member Functions
	JEMJetAlgorithm (double eta, double phi, const std::map< int, JetInput * > jiContainer, const TrigConf::L1Menu l1menu)
	~JEMJetAlgorithm ()
double	eta ()
	Accessors.
double	phi ()
	Returns phi coordinate of RoI, using standard ATLAS convention.
int	Core ()
	Returns RoI Core ET.
int	ET4x4 ()
	Returns 4x4 TT cluster ET.
int	ET6x6 ()
	Returns 6x6 TT cluster ET.
int	ET8x8 ()
	Returns 8x8 TT cluster ET.
int	ETLarge ()
	Returns Large cluster ET.
int	ETSmall ()
	Returns Small cluster ET.
bool	isEtMax ()
	Does this window pass the local ET maximum condition.
bool	isRoI ()
	Does this window pass the local ET maximum condition.
xAOD::JEMTobRoI *	jemTobRoI ()
	Create JEMTobRoI and return pointers to it.

Private Member Functions
void	setRoICoord (double eta, double phi)
	Compute RoI coordinate.
void	testEtMax (const std::vector< int > &cores)
	Form all 2x2 clusters within window and test centre is a local ET maximum.
void	passesTrigger ()
	Check trigger condition and set ET values if TOB created.

Private Attributes
double	m_refEta
double	m_refPhi
const TrigConf::L1Menu *	m_l1menu {nullptr}
double	m_eta
	Algorithm results.
double	m_phi
int	m_ET4x4
int	m_ET6x6
int	m_ET8x8
int	m_ETLarge
int	m_ETSmall
bool	m_EtMax

Static Private Attributes
static const int	m_satLarge = 0x3FF
	Algorithm parameters.
static const int	m_satSmall = 0x1FF

Detailed Description

This is an internal class, used in the jet trigger.

The JEMJetAlgorithm:

identifies JetInputs used in a particular trigger window (4x4 towers)
forms sums required for trigger algorithm
identifies whether passes the RoI condition (local ET maximum)
returns sums (with appropriate precision)
returns hit bits and RoI word (if all requirements met)

Definition at line 40 of file JEMJetAlgorithm.h.

Constructor & Destructor Documentation

◆ JEMJetAlgorithm()

LVL1::JEMJetAlgorithm::JEMJetAlgorithm	(	double	eta,
		double	phi,
		const std::map< int, JetInput * > *	jiContainer,
		const TrigConf::L1Menu *	l1menu )

This could potentially be called with the coordinate being the centre
of an RoI or the centre of a JetElement. We want to ensure that we
do the right thing in either case.

Offsetting by JE size/4 should put the coordinates inside the
reference JetElement whether input was reference JetElement
coordinate or RoI centre coordinate. Can't subtract a fixed amount
as the eta size of JetElements varies, so need to work out how much
to subtract first!
To be extra safe, the code below will then compute the centre
of the reference JetElement.

This should all ensure consistent & safe key generation however the
initial coordinate was specified.

Now loop over JetInputs within window and form clusters. ET8x8 = all elements ET4x4 = central 2x2 ET6x6 = most energetic of 4 clusters Interesting one is the 9 RoI cores. The logic below fills these as an a 9-element std::vector. The ordering of the elements is as follows: 2 5 8 1 4 7 0 3 6 So the RoI "ET maximum" condition is that 4 >= 0-3, 4 > 5-8 If you picture the cores in a 3x3 array, cores[iphi][ieta], then the index in the vector above = iphi + 3*ieta.

We use the fact that core[4] = ET4x4 to safe a little time here

Definition at line 30 of file JEMJetAlgorithm.cxx.

                                                                      :
  m_l1menu(l1menu),
  m_ET4x4(0),
  m_ET6x6(0),
  m_ET8x8(0),
  m_ETLarge(0),
  m_ETSmall(0),
  m_EtMax(false)
  //m_debug(false)
{
 
  // Offset depends on eta. Need to protect against rounding errors even here
  JetInputKey get(phi-0.01,eta-0.01);
  double de = get.dEta()/4.;
  
  // Get coordinate of centre of this "reference element"
  Coordinate refCoord = get.getCentre(phi-M_PI/64., eta-de);
  m_refEta = refCoord.eta();
  m_refPhi = refCoord.phi();
 
  // Set coordinate of centre of RoI, starting from reference tower coordinate
  setRoICoord(m_refEta, m_refPhi);
 
  // Get coordinate of bottom-left JetInput in this window
  int minEtaOffset = -1;
  Coordinate startCoord = get.lowerLeft(m_refPhi,m_refEta);
  if (startCoord.eta() == TrigT1CaloDefs::RegionERROREtaCentre) { // already at left edge
    startCoord = get.downPhi(m_refPhi,m_refEta);
    minEtaOffset = 0;
  }
  double tempEta = startCoord.eta();
  double startPhi = startCoord.phi();
    
 
  std::vector<int> et6x6(4);
  std::vector<int> cores(9);
  for (int etaOffset=minEtaOffset; etaOffset<=2 ; etaOffset++){
    Coordinate tempCoord(startPhi,tempEta);
    for (int phiOffset=-1; phiOffset<=2 ; phiOffset++){
      int tempKey = get.jeKey(tempCoord);
      std::map<int, JetInput*>::const_iterator ji = jiContainer->find(tempKey);
      if (ji != jiContainer->end() ){
        // get ET once here, rather than repeat function calls
        int ET = (ji->second)->energy();
        // 8x8 jet is easy
        m_ET8x8 += ET;
        // but there are 4 possible 6x6 clusters
        if (phiOffset > -1) {
          if (etaOffset < 2)  et6x6[1] += ET;
          if (etaOffset > -1) et6x6[2] += ET;
        }
        if (phiOffset < 2) {
          if (etaOffset < 2)  et6x6[0] += ET;
          if (etaOffset > -1) et6x6[3] += ET;
        }
        // Each JetInput is part of up to 4 RoI core clusters
        
        if (etaOffset >= 0) {
          if (phiOffset >= 0) cores[phiOffset+3*etaOffset] += ET;
          if (phiOffset < 2) cores[phiOffset+3*etaOffset+1] += ET;
        }
        if (etaOffset < 2) {
          if (phiOffset >= 0) cores[phiOffset+3*etaOffset+3] += ET;
          if (phiOffset < 2) cores[phiOffset+3*etaOffset+4] += ET;
        }
      } // end of check that jetinput exists in container
      tempCoord = get.upPhi(tempCoord); // Increment phi coordinate
    } // end phi offset loop
    tempCoord = get.rightEta(tempCoord); // Increment eta coordinate
    tempEta = tempCoord.eta();
    if (tempEta == TrigT1CaloDefs::RegionERROREtaCentre) break; // gone outside coverage
  } // end eta offset loop
 
  // 4x4 cluster = central RoI core
  m_ET4x4 = cores[4];
  
  // find most energetic 6x6 cluster
  for (int i = 0; i < 4; i++) if (et6x6[i] > m_ET6x6) m_ET6x6 = et6x6[i];
 
  // Check whether RoI condition is met.
  testEtMax(cores);
 
  // test trigger conditions
  passesTrigger();
  
}

◆ ~JEMJetAlgorithm()

LVL1::JEMJetAlgorithm::~JEMJetAlgorithm ( )

Definition at line 149 of file JEMJetAlgorithm.cxx.

149 {

150}

Member Function Documentation

◆ Core()

int LVL1::JEMJetAlgorithm::Core ( )

Returns RoI Core ET.

Definition at line 246 of file JEMJetAlgorithm.cxx.

                              {
  return m_ET4x4;
}

◆ ET4x4()

int LVL1::JEMJetAlgorithm::ET4x4 ( )

Returns 4x4 TT cluster ET.

Definition at line 251 of file JEMJetAlgorithm.cxx.

                               {
  return ( (m_ET4x4 < m_satLarge) ? m_ET4x4 : m_satLarge );
}

◆ ET6x6()

int LVL1::JEMJetAlgorithm::ET6x6 ( )

Returns 6x6 TT cluster ET.

Definition at line 256 of file JEMJetAlgorithm.cxx.

                               {
  return ( (m_ET6x6 < m_satLarge) ? m_ET6x6 : m_satLarge );
}

◆ ET8x8()

int LVL1::JEMJetAlgorithm::ET8x8 ( )

Returns 8x8 TT cluster ET.

Definition at line 261 of file JEMJetAlgorithm.cxx.

                               {
  return ( (m_ET8x8 < m_satLarge) ? m_ET8x8 : m_satLarge );
}

◆ eta()

double LVL1::JEMJetAlgorithm::eta ( )

Accessors.

Returns eta coordinate of RoI.

Definition at line 286 of file JEMJetAlgorithm.cxx.

                                {
  return m_eta;
}

◆ ETLarge()

int LVL1::JEMJetAlgorithm::ETLarge ( )

Returns Large cluster ET.

Definition at line 266 of file JEMJetAlgorithm.cxx.

                                 {
  return ( (m_ETLarge < m_satLarge) ? m_ETLarge : m_satLarge );
}

◆ ETSmall()

int LVL1::JEMJetAlgorithm::ETSmall ( )

Returns Small cluster ET.

Definition at line 271 of file JEMJetAlgorithm.cxx.

                                 {
  return ( (m_ETSmall < m_satSmall) ? m_ETSmall : m_satSmall );
}

◆ isEtMax()

bool LVL1::JEMJetAlgorithm::isEtMax ( )

Does this window pass the local ET maximum condition.

Definition at line 276 of file JEMJetAlgorithm.cxx.

                                  {
  return m_EtMax;
}

◆ isRoI()

bool LVL1::JEMJetAlgorithm::isRoI ( )

Does this window pass the local ET maximum condition.

Definition at line 281 of file JEMJetAlgorithm.cxx.

                                {
  return ( m_EtMax && (m_ETLarge > 0 || m_ETSmall > 0) );
}

◆ jemTobRoI()

xAOD::JEMTobRoI * LVL1::JEMJetAlgorithm::jemTobRoI ( )

Create JEMTobRoI and return pointers to it.

Returns a JEMTobRoI object, provided the TOB conditions were met.

Will return a null pointer if object does not pass hypothesis. It is the user's responsibility to check

If not will return a null pointer - user's responsibility to check

Definition at line 298 of file JEMJetAlgorithm.cxx.

                                              { 
  
  if (isRoI()) {
    
    // Need to calculate hardware coordinate
    Coordinate coord(m_refPhi, m_refEta);
    CoordToHardware convertor;
  
    int crate = convertor.jepCrate(coord);
    int jem = convertor.jepModule(coord);
    unsigned int jemCoord = convertor.jepLocalCoordinate(coord);
    int frame = (jemCoord>>2);
    int lc = jemCoord&3;
    
    /*
    JetEnergyModuleKey get();
    Coordinate tempCoord(m_refPhi, m_refEta);
    unsigned int quadrant = m_refPhi*2/M_PI;
    unsigned int row = get.row(tempCoord);
    unsigned int col = get.col(tempCoord);
    
    unsigned int crate = quadrant&1;
    unsigned int jem = get.jem(tempCoord);
    unsigned int frame = ((col&2)<<1) + (row>>1);
    unsigned int lc = (col&1) + (row&1)*2;
    */
    xAOD::JEMTobRoI* roi = new xAOD::JEMTobRoI();
    roi->makePrivateStore();
    roi->initialize(crate, jem, frame, lc, ETLarge(), ETSmall());
    return roi;
  }
  
  return 0;
 
}

◆ passesTrigger()

void LVL1::JEMJetAlgorithm::passesTrigger ( )

private

Check trigger condition and set ET values if TOB created.

Definition at line 207 of file JEMJetAlgorithm.cxx.

                                        {
  
  // Belt and braces
  m_ETLarge = 0;
  m_ETSmall = 0;
  
  // Don't waste time if it isn't an RoI candidate
  if (!m_EtMax) return;
  
  // Does this pass min TOB pT cut?
  unsigned int sizeSmall{4}; // the size of the small jets (by default 4)
  unsigned int sizeLarge{8}; // the size of the large jets (by default 8)
  int threshSmall{0}; // the minimum pT of small jet objects sent to TOPO (in counts, not in GeV)
  int threshLarge{0}; // the minimum pT of large jet objects sent to TOPO (in counts, not in GeV)
 
  sizeSmall = 4; // not part of the new menu
  sizeLarge = 8; // not part of the new menu
  float scale = m_l1menu->thrExtraInfo().JET().jetScale();
  threshSmall = m_l1menu->thrExtraInfo().JET().ptMinToTopoSmallWindowCounts()*scale;
  threshLarge = m_l1menu->thrExtraInfo().JET().ptMinToTopoLargeWindowCounts()*scale;
 
  int etLarge = m_ET8x8;
  if (sizeLarge == 6)      etLarge = m_ET6x6;
  else if (sizeLarge == 4) etLarge = m_ET4x4;
 
  int etSmall = m_ET4x4;
  if (sizeSmall == 6)      etLarge = m_ET6x6;
  else if (sizeSmall == 8) etLarge = m_ET8x8;
 
  if (etLarge <= threshLarge && etSmall <= threshSmall) return;
 
  m_ETLarge = etLarge;
  m_ETSmall = etSmall;
 
}

◆ phi()

double LVL1::JEMJetAlgorithm::phi ( )

Returns phi coordinate of RoI, using standard ATLAS convention.

Definition at line 291 of file JEMJetAlgorithm.cxx.

                                {
  return ( (m_phi <= M_PI) ? m_phi : m_phi - 2.*M_PI);
}

◆ setRoICoord()

void LVL1::JEMJetAlgorithm::setRoICoord	(	double	eta,
		double	phi )

private

Compute RoI coordinate.

Input coordinate should be inside "reference tower" of window. Computes RoI coordinate as centre of 2x2 element RoI core

Definition at line 154 of file JEMJetAlgorithm.cxx.

                                                            {
 
  JetInputKey keyLL(phi,eta);
  // Get coordinate of centre of this "reference element"
  Coordinate lowerLeft = keyLL.getCentre(phi, eta);
 
  // Hence find lower-left corner of RoI core
  double lowerEta = lowerLeft.eta() - ( keyLL.dEta()/2. );
  double lowerPhi = lowerLeft.phi() - ( keyLL.dPhi()/2. );
 
  // Get coordinate of opposite corner of RoI core:
  Coordinate upperRight;
  if (keyLL.isFCAL(lowerLeft.eta()) && eta > 0) {
    // Special case: no JE to right, so get centre of element at eta, phi+1
    upperRight = keyLL.upPhi(phi, eta);
  }
  else {
    // Get centre of element at eta+1, phi+1, i.e. opposite corner of RoI core
    upperRight = keyLL.upperRight(phi, eta);
  }
 
  // Now get upper-right corner of RoI core:
  JetInputKey keyUR(upperRight);
  double upperEta = upperRight.eta() + ( keyUR.dEta()/2. );
  double upperPhi = upperRight.phi() + ( keyUR.dPhi()/2. );
  
 
  // CoordinateRange object will compute centre, correcting for wrap-around
  CoordinateRange roi(lowerPhi,upperPhi,lowerEta,upperEta);
  m_eta = roi.eta();
  m_phi = roi.phi();
 
}

◆ testEtMax()

void LVL1::JEMJetAlgorithm::testEtMax ( const std::vector< int > & cores )

private

Form all 2x2 clusters within window and test centre is a local ET maximum.

Input clusters form a list, arranged as
2 5 8
1 4 7
0 3 6
Then 4 = this window's RoI core, and ET max condition is
4 >= 0, 1, 2, 3 && 4 < 5, 6, 7, 8

Definition at line 189 of file JEMJetAlgorithm.cxx.

                                                               {
  
 
  // RoI condition test
  m_EtMax = true;
  for (int i = 0; i < 4; i++) if (cores[4] < cores[i])  m_EtMax = false;
  for (int i = 5; i < 9; i++) if (cores[4] <= cores[i]) m_EtMax = false;
  
}

Member Data Documentation

◆ m_ET4x4

int LVL1::JEMJetAlgorithm::m_ET4x4

private

Definition at line 73 of file JEMJetAlgorithm.h.

◆ m_ET6x6

int LVL1::JEMJetAlgorithm::m_ET6x6

private

Definition at line 74 of file JEMJetAlgorithm.h.

◆ m_ET8x8

int LVL1::JEMJetAlgorithm::m_ET8x8

private

Definition at line 75 of file JEMJetAlgorithm.h.

◆ m_eta

double LVL1::JEMJetAlgorithm::m_eta

private

Algorithm results.

Definition at line 71 of file JEMJetAlgorithm.h.

◆ m_ETLarge

int LVL1::JEMJetAlgorithm::m_ETLarge

private

Definition at line 76 of file JEMJetAlgorithm.h.

◆ m_EtMax

bool LVL1::JEMJetAlgorithm::m_EtMax

private

Definition at line 78 of file JEMJetAlgorithm.h.

◆ m_ETSmall

int LVL1::JEMJetAlgorithm::m_ETSmall

private

Definition at line 77 of file JEMJetAlgorithm.h.

◆ m_l1menu

const TrigConf::L1Menu* LVL1::JEMJetAlgorithm::m_l1menu {nullptr}

private

Definition at line 68 of file JEMJetAlgorithm.h.

68{nullptr};

◆ m_phi

double LVL1::JEMJetAlgorithm::m_phi

private

Definition at line 72 of file JEMJetAlgorithm.h.

◆ m_refEta

double LVL1::JEMJetAlgorithm::m_refEta

private

Definition at line 66 of file JEMJetAlgorithm.h.

◆ m_refPhi

double LVL1::JEMJetAlgorithm::m_refPhi

private

Definition at line 67 of file JEMJetAlgorithm.h.

◆ m_satLarge

const int LVL1::JEMJetAlgorithm::m_satLarge = 0x3FF

staticprivate

Algorithm parameters.

Definition at line 83 of file JEMJetAlgorithm.h.

◆ m_satSmall

const int LVL1::JEMJetAlgorithm::m_satSmall = 0x1FF

staticprivate

Definition at line 84 of file JEMJetAlgorithm.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ JEMJetAlgorithm()

◆ ~JEMJetAlgorithm()

Member Function Documentation

◆ Core()

◆ ET4x4()

◆ ET6x6()

◆ ET8x8()

◆ eta()

◆ ETLarge()

◆ ETSmall()

◆ isEtMax()

◆ isRoI()

◆ jemTobRoI()

◆ passesTrigger()

◆ phi()

◆ setRoICoord()

◆ testEtMax()

Member Data Documentation

◆ m_ET4x4

◆ m_ET6x6

◆ m_ET8x8

◆ m_eta

◆ m_ETLarge

◆ m_EtMax

◆ m_ETSmall

◆ m_l1menu

◆ m_phi

◆ m_refEta

◆ m_refPhi

◆ m_satLarge

◆ m_satSmall