diff --git a/Event/xAOD/xAODTrigger/Root/jFexSRJetRoI_v1.cxx b/Event/xAOD/xAODTrigger/Root/jFexSRJetRoI_v1.cxx
index 942e9767b7df7bc9e8eda893220887ce2ee0ea1d..3653194bb29d51b101252a5de3099049ad940069 100644
--- a/Event/xAOD/xAODTrigger/Root/jFexSRJetRoI_v1.cxx
+++ b/Event/xAOD/xAODTrigger/Root/jFexSRJetRoI_v1.cxx
@@ -18,7 +18,28 @@ namespace xAOD {
const float jFexSRJetRoI_v1::s_towerEtaWidth = 0.1;
const float jFexSRJetRoI_v1::s_towerPhiWidth = 0.1;
const float jFexSRJetRoI_v1::s_minEta = -4.9;
-
+
+
+ // globalEta/Phi calculation in the FCAL varies depending on position in eta space due to TT granularity change.
+ //| Region | eta region | TT (eta x phi)
+ //---------------------------------------------------------
+ // Region 1 EMB | |eta| < 25 | (1 x 1)
+ // Region 2 EMIE | 25 < |eta|< 31 | (2 x 2)
+ // Region 3 TRANS | 31 < |eta| < 32 | (1 x 2)
+ // Region 4 FCAL | |eta| > 32 | (2 x 4)
+
+ //eta position in array for jfex module 0
+ const std::vector<int> jFexSRJetRoI_v1::s_EtaPosition_C_Side = {28, 36, //Region 1
+ 25, 27, //Region 2
+ 24, //Region 3
+ 13, 23}; //Region 4
+ //eta position in array for jfex module 5
+ const std::vector<int> jFexSRJetRoI_v1::s_EtaPosition_A_Side = { 8, 16, //Region 1
+ 17, 19, //Region 2
+ 20, //Region 3
+ 21, 31}; //Region 4
+
+
jFexSRJetRoI_v1::jFexSRJetRoI_v1()
: SG::AuxElement() {
}
@@ -118,12 +139,37 @@ namespace xAOD {
int jFexSRJetRoI_v1::unpackGlobalEta() const{
int globalEta = 0;
+
if(jFexNumber()==0){
- globalEta = -25+tobLocalEta(); //-25 is the minimum eta for the most granular part of module 0 - needs to be modified for the EMEC/HEC and FCAL
+ //Region 2
+ if((s_EtaPosition_C_Side[2] <= tobLocalEta()) && (tobLocalEta() <=s_EtaPosition_C_Side[3])){
+ globalEta = 25 + (2*(tobLocalEta() -16));
+ }
+ //Region 3
+ if(s_EtaPosition_C_Side[5] == tobLocalEta()){
+ globalEta = 32;
+ }
+ //Region 4
+ if((s_EtaPosition_C_Side[6] <= tobLocalEta()) && (tobLocalEta() <=s_EtaPosition_C_Side[7])){
+ globalEta = 32 + (tobLocalEta()-20);
+ }
}
- else if(jFexNumber()==5){
- globalEta = 16+tobLocalEta(); //16 is the minimum eta for the most granular part of module 5 - needs to be modified for the EMEC/HEC and FCAL
+
+ if(jFexNumber()==5){
+ //Region 2
+ if((s_EtaPosition_A_Side[2] <= tobLocalEta()) && (tobLocalEta() <=s_EtaPosition_A_Side[3])){
+ globalEta = -25 - (2*(tobLocalEta() -16));
+ }
+ //Region 3
+ if(s_EtaPosition_A_Side[5] == tobLocalEta()){
+ globalEta = -32;
+ }
+ //Region 4
+ if((s_EtaPosition_A_Side[6] <= tobLocalEta()) && (tobLocalEta() <=s_EtaPosition_A_Side[7])){
+ globalEta = -32 - (tobLocalEta()-20);
+ }
}
+ //Region 1
else{
globalEta = tobLocalEta()+(8*(jFexNumber() - 3)) ; // for module 1 to 4
}
@@ -131,8 +177,25 @@ namespace xAOD {
}
uint jFexSRJetRoI_v1::unpackGlobalPhi() const{
- uint globalPhi = tobLocalPhi() + (fpgaNumber() * 16);
- return globalPhi;
+ uint globalPhi = 0;
+ //16 is the phi height of an FPGA
+ if(jFexNumber()==0 || jFexNumber()==5){
+ //Region 2
+ if((s_EtaPosition_A_Side[2] <= tobLocalEta()) && (tobLocalEta() <=s_EtaPosition_A_Side[3])){
+ globalPhi = 16*fpgaNumber() + (2*(tobLocalPhi()-4));
+ }
+ //Region 3
+ if(s_EtaPosition_A_Side[5] == tobLocalEta()){
+ globalPhi = 16*fpgaNumber() + (2*(tobLocalPhi()-4));
+ }
+ //Region 4
+ if((s_EtaPosition_A_Side[6] <= tobLocalEta()) && (tobLocalEta() <=s_EtaPosition_A_Side[7])){
+ globalPhi = (16*fpgaNumber()) + (4*(tobLocalPhi() -2));
+ }
+ }
+ //Region 1
+ else{ globalPhi = tobLocalPhi() + (fpgaNumber() * 16);}
+ return globalPhi;
}
} // namespace xAOD
diff --git a/Event/xAOD/xAODTrigger/xAODTrigger/versions/jFexSRJetRoI_v1.h b/Event/xAOD/xAODTrigger/xAODTrigger/versions/jFexSRJetRoI_v1.h
index 7932c848d2c83abd5e9b008da38c0695d0a344c9..1b58531a1c2d5cce454d3d4c0062238d355df615 100644
--- a/Event/xAOD/xAODTrigger/xAODTrigger/versions/jFexSRJetRoI_v1.h
+++ b/Event/xAOD/xAODTrigger/xAODTrigger/versions/jFexSRJetRoI_v1.h
@@ -78,6 +78,8 @@ namespace xAOD {
static const float s_towerEtaWidth;
static const float s_towerPhiWidth;
static const float s_minEta;
+ static const std::vector<int> s_EtaPosition_C_Side;
+ static const std::vector<int> s_EtaPosition_A_Side;
// Data locations within word
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/FEXAlgoSpaceDefs.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/FEXAlgoSpaceDefs.h
index b34ccaeff5bb34379a1a234bce186f8ccfabdd06..c50e1cecac28fc1cac29347e1a5039f1ef05e064 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/FEXAlgoSpaceDefs.h
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/FEXAlgoSpaceDefs.h
@@ -25,7 +25,44 @@ namespace LVL1 {
constexpr static int jFEX_wide_algoSpace_width = 45;
constexpr static int jFEX_thin_algoSpace_width = 24;
- constexpr static int jFEX_algoSpace_height = 32;
+ constexpr static int jFEX_algoSpace_height = 32;
+
+//Array breakdown of jFEX_wide_algoSpace_width matric to indicate different eta and phi regions
+
+//A side (jFEX Module 5):
+
+ //Eta space for core area
+ constexpr static int jFEX_algoSpace_A_EMB_eta = 8;
+ constexpr static int jFEX_algoSpace_A_EMIE_eta = 17;
+ constexpr static int jFEX_algoSpace_A_FCAL_start_eta = 21;
+ constexpr static int jFEX_algoSpace_A_FCAL_end_eta = 33;
+
+ //Eta space for core and overlaps, EM only
+ constexpr static int jFEX_algoSpace_A_lowerEM_eta = 0;
+ constexpr static int jFEX_algoSpace_A_upperEM_eta = 32;
+
+//C side (jFEX module 0):
+//there are more values on the C side as the matrix cannot be flipped in the bitwise framework.
+
+ //Eta space for core area
+ constexpr static int jFEX_algoSpace_C_EMB_start_eta = 28;
+ constexpr static int jFEX_algoSpace_C_EMB_end_eta = 37;
+ constexpr static int jFEX_algoSpace_C_EMIE_start_eta = 24;
+ constexpr static int jFEX_algoSpace_C_EMIE_end_eta = 28;
+ constexpr static int jFEX_algoSpace_C_FCAL_start_eta = 12;
+ constexpr static int jFEX_algoSpace_C_FCAL_end_eta = 24;
+
+ //Eta space for core and overlaps, EM only
+ constexpr static int jFEX_algoSpace_C_lowerEM_eta = 13;
+ constexpr static int jFEX_algoSpace_C_upperEM_eta = 45;
+
+//Phi space breakdown
+ constexpr static int jFEX_algoSpace_EMB_start_phi = 8;
+ constexpr static int jFEX_algoSpace_EMB_end_phi = 24;
+ constexpr static int jFEX_algoSpace_EMIE_start_phi = 4;
+ constexpr static int jFEX_algoSpace_EMIE_end_phi = 12;
+ constexpr static int jFEX_algoSpace_FCAL_start_phi = 2;
+ constexpr static int jFEX_algoSpace_FCAL_end_phi = 6;
};
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXFPGA.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXFPGA.h
index 130cc10db9acb40221d9a00ae19cd02a168b6ed8..8848686d06dcaf6c3c8f2e7768c4551685a6fc41 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXFPGA.h
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXFPGA.h
@@ -23,11 +23,14 @@
#include "L1CaloFEXToolInterfaces/IjFEXtauAlgo.h"
#include "L1CaloFEXToolInterfaces/IjFEXsumETAlgo.h"
#include "L1CaloFEXToolInterfaces/IjFEXmetAlgo.h"
+#include "L1CaloFEXToolInterfaces/IjFEXForwardJetsAlgo.h"
#include "CaloEvent/CaloCellContainer.h"
#include "CaloIdentifier/CaloIdManager.h"
#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
#include "L1CaloFEXSim/jFEXOutputCollection.h"
#include "L1CaloFEXSim/FEXAlgoSpaceDefs.h"
+#include "StoreGate/WriteHandle.h"
+#include "StoreGate/ReadHandle.h"
namespace LVL1 {
@@ -99,24 +102,23 @@ namespace LVL1 {
int m_jTowersIDs [FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width] = {{0}};
std::map<int,jTower> m_jTowersColl;
+ std::map<int, jFEXForwardJetsInfo> m_FCALJets;
+
CaloCellContainer m_sCellsCollection;
SG::ReadHandleKey<LVL1::jTowerContainer> m_jFEXFPGA_jTowerContainerKey {this, "MyETowers", "jTowerContainer", "Input container for jTowers"};
- SG::ReadHandleKey<jFEXOutputCollection> m_jFEXFPGA_jFEXOutputCollectionKey {this, "MyOutputs", "jFEXOutputCollection", "Input container for jFEXOutputCollection"};
+ SG::WriteHandleKey<LVL1::jFEXOutputCollection> m_jFEXFPGA_jFEXOutputCollectionKey {this, "jFEXOutputCollection", "jFEXOutputCollection", "Input container for jFEXOutputCollection"};
ToolHandle<IjFEXSmallRJetAlgo> m_jFEXSmallRJetAlgoTool {this, "jFEXSmallRJetAlgoTool", "LVL1::jFEXSmallRJetAlgo", "Tool that runs the jFEX Small R Jet algorithm"};
ToolHandle<IjFEXLargeRJetAlgo> m_jFEXLargeRJetAlgoTool {this, "jFEXLargeRJetAlgoTool", "LVL1::jFEXLargeRJetAlgo", "Tool that runs the jFEX Large R Jet algorithm"};
ToolHandle<IjFEXtauAlgo> m_jFEXtauAlgoTool {this, "jFEXtauAlgoTool" , "LVL1::jFEXtauAlgo" , "Tool that runs the jFEX tau algorithm"};
ToolHandle<IjFEXsumETAlgo> m_jFEXsumETAlgoTool {this, "jFEXsumETAlgoTool" , "LVL1::jFEXsumETAlgo" , "Tool that runs the jFEX sumET algorithm"};
ToolHandle<IjFEXmetAlgo> m_jFEXmetAlgoTool {this, "jFEXmetAlgoTool" , "LVL1::jFEXmetAlgo" , "Tool that runs the jFEX met algorithm"};
- //ToolHandle<IjFEXegAlgo> m_jFEXegAlgoTool {this, "jFEXegAlgoTool", "LVL1::jFEXegAlgo", "Tool that runs the jFEX e/gamma algorithm"};
+ ToolHandle<IjFEXForwardJetsAlgo> m_jFEXForwardJetsAlgoTool {this, "jFEXForwardJetsAlgoTool" , "LVL1::jFEXForwardJetsAlgo" , "Tool that runs the jFEX FCAL Jets algorithm"};
};
} // end of namespace
-//CLASS_DEF( LVL1::jFEXFPGA , 136060357 , 1 )
-
-
#endif
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXForwardJetsAlgo.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXForwardJetsAlgo.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f2495f40f728bc8449d5c9008064ec1760e6436
--- /dev/null
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXForwardJetsAlgo.h
@@ -0,0 +1,63 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+//***************************************************************************
+// jFEXForwardJetsAlgo - Algorithm for small R jet Algorithm in jFEX
+// -------------------
+// begin : 07 06 2021
+// email : varsiha.sothilingam@cern.ch
+//***************************************************************************
+
+#ifndef jFEXForwardJetsAlgo_H
+#define jFEXForwardJetsAlgo_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "L1CaloFEXToolInterfaces/IjFEXForwardJetsAlgo.h"
+#include "AthenaKernel/CLASS_DEF.h"
+//#include "L1CaloFEXSim/jFEXSmallRJetTOB.h"
+#include "L1CaloFEXSim/jTowerContainer.h"
+#include "L1CaloFEXSim/jFEXForwardJetsInfo.h"
+#include "L1CaloFEXSim/FEXAlgoSpaceDefs.h"
+#include "CaloEvent/CaloCellContainer.h"
+#include "CaloIdentifier/CaloIdManager.h"
+#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/StoreGateSvc.h"
+
+
+namespace LVL1 {
+
+ class jFEXForwardJetsAlgo : public AthAlgTool, virtual public IjFEXForwardJetsAlgo {
+
+ public:
+ /** Constructors */
+ jFEXForwardJetsAlgo(const std::string& type, const std::string& name, const IInterface* parent);
+
+ /** standard Athena-Algorithm method */
+ virtual StatusCode initialize() override;
+
+ /** Destructor */
+ virtual ~jFEXForwardJetsAlgo();
+
+ virtual StatusCode safetyTest() override;
+
+ virtual void setup(int inputTable[FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width]) override;
+ //virtual int realValue(int ID, int eta) override;
+ virtual float globalPhi(int nphi, int neta) override;
+ virtual float globalEta(int nphi, int neta) override;
+ virtual unsigned int localPhi(int nphi, int neta) override;
+ virtual unsigned int localEta(int nphi, int neta) override;
+ virtual unsigned int getTTowerET(int nphi, int neta) override;
+
+ virtual std::map<int, jFEXForwardJetsInfo> FcalJetsTowerIDLists();
+ virtual std::map<int, jFEXForwardJetsInfo> isSeedLocalMaxima();
+ virtual std::map<int, jFEXForwardJetsInfo> calculateJetETs();
+ protected:
+
+ private:
+ SG::ReadHandleKey<LVL1::jTowerContainer> m_jFEXForwardJetsAlgo_jTowerContainerKey {this, "MyjTowers", "jTowerContainer", "Input container for jTowers"};
+ int m_jFEXalgoTowerID[FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width];
+ bool m_storeEnergyRingTTIDs;
+ };
+}//end of namespace
+#endif
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXForwardJetsInfo.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXForwardJetsInfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..5b3d0e2a25800d6ce8e3032ec9189227315d5d6b
--- /dev/null
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXForwardJetsInfo.h
@@ -0,0 +1,80 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+//***************************************************************************
+// jFEXForwardJetsInfo - Class to store information about trigger towers
+// in the fcal and associated jet information.
+// -------------------
+// begin : 07 07 2021
+// email : varsiha.sothilingam@cern.ch
+//***************************************************************************
+#ifndef jFEXForwardJetsInfo_H
+#define jFEXForwardJetsInfo_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "AthenaKernel/CLASS_DEF.h"
+#include "L1CaloFEXSim/jTowerContainer.h"
+#include "L1CaloFEXSim/FEXAlgoSpaceDefs.h"
+#include "CaloEvent/CaloCellContainer.h"
+#include "CaloIdentifier/CaloIdManager.h"
+#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/StoreGateSvc.h"
+
+namespace LVL1 {
+ class jFEXForwardJetsInfo{
+
+ public:
+ void setCentreTTID(int TT_ID);
+ int getCentreTTID();
+
+ void setCentreTTEta(float centreTTEta);
+ float getCentreTTEta();
+
+ void setCentreTTPhi(float centreTTPhi);
+ float getCentreTTPhi();
+
+ void setCentreLocalTTEta(float centreLocalTTEta);
+ float getCentreLocalTTEta();
+ void setCentreLocalTTPhi(float centreLocalTTPhi);
+ float getCentreLocalTTPhi();
+
+ void includeTTinSeed(int TT_ID);
+ std::vector<int> getTTinSeed();
+
+ void addToSeedET(int seed_ET);
+ int getSeedET();
+
+ void addToFirstEnergyRingET(int firstER_ET);
+ int getFirstEnergyRingET();
+
+ void includeTTIDinFirstER(int firstER_TTID);
+ std::vector<int> getTTIDinFirstER();
+
+ void addToSecondEnergyRingET(int secondER_ET);
+ int getSecondEnergyRingET();
+
+ void includeTTIDinSecondER(int secondER_TTID);
+ std::vector<int> getTTIDinSecondER();
+
+ private:
+ int m_centre_TTID;
+ float m_centreTTPhi;
+ float m_centreTTEta;
+
+ int m_centreLocalTTPhi;
+ int m_centreLocalTTEta;
+
+ int m_seed_ET =0;
+ int m_firstEnergyRing_ET =0;
+ int m_secondEnergyRing_ET =0;
+ std::vector<int> m_TTsInSeed ={};
+ std::vector<int> m_firstEnergyRing_TTIDs = {};
+ std::vector<int> m_secondEnergyRing_TTIDs = {};
+
+ };
+
+
+
+}//end of namespace
+#endif
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXNtupleWriter.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXNtupleWriter.h
index 97e20718f98885297a9ea3d26200a14abdbecae4..3d8375a5551239d5c75ac939f0a775361e0ec804 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXNtupleWriter.h
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXNtupleWriter.h
@@ -47,7 +47,10 @@ private:
std::vector<int> m_smallRJetTOB_phi;
std::vector<int> m_smallRJetTOB_ET;
std::vector<int> m_smallRJetTOB_sat;
-
+ std::vector<int> m_smallRJetTOB_word;
+ std::vector<int> m_smallRJetTOB_jfexID;
+ std::vector<int> m_smallRJetTOB_fpgaID;
+
std::vector<int> m_largeRJet_eta;
std::vector<int> m_largeRJet_phi;
std::vector<int> m_largeRJet_ET;
@@ -57,6 +60,9 @@ private:
std::vector<int> m_largeRJetTOB_eta;
std::vector<int> m_largeRJetTOB_phi;
std::vector<int> m_largeRJetTOB_sat;
+ std::vector<int> m_largeRJetTOB_word;
+ std::vector<int> m_largeRJetTOB_jfexID;
+ std::vector<int> m_largeRJetTOB_fpgaID;
std::vector<int> m_tau_isLocalMax;
std::vector<int> m_tau_TT_ID;
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXOutputCollection.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXOutputCollection.h
index ece6322512b43eb90acae6d5822deaa6353ac309..2ec6acfd23f02d046a3a4ea8143f76b9dd00cee4 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXOutputCollection.h
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXOutputCollection.h
@@ -14,6 +14,7 @@
#define JFEX_OUTPUT_COLLECTION_H
#include "AthenaKernel/CLASS_DEF.h"
+#include "StoreGate/StoreGateSvc.h"
#include <map>
#include <iostream>
#include <vector>
@@ -26,24 +27,24 @@ namespace LVL1 {
jFEXOutputCollection() {};
~jFEXOutputCollection();
void clear();
- void addValue_smallRJet(std::string, float);
+ void addValue_smallRJet(std::string, int);
void fill_smallRJet();
- void addValue_largeRJet(std::string, float);
+ void addValue_largeRJet(std::string, int);
void fill_largeRJet();
void addValue_tau(std::string, int);
void fill_tau();
int SRsize();
int LRsize();
int tausize();
- std::map<std::string, float>* get_smallRJet(int);
- std::map<std::string, float>* get_largeRJet(int);
+ std::map<std::string, int>* get_smallRJet(int);
+ std::map<std::string, int>* get_largeRJet(int);
std::map<std::string, int>* get_tau(int);
private:
- std::map<std::string, float> m_values_tem_smallRJet;
- std::vector<std::map<std::string, float>*> m_allvalues_smallRJet;
- std::map<std::string, float> m_values_tem_largeRJet;
- std::vector<std::map<std::string, float>*> m_allvalues_largeRJet;
+ std::map<std::string, int> m_values_tem_smallRJet;
+ std::vector<std::map<std::string, int>*> m_allvalues_smallRJet;
+ std::map<std::string, int> m_values_tem_largeRJet;
+ std::vector<std::map<std::string, int>*> m_allvalues_largeRJet;
std::map<std::string, int> m_values_tem_tau;
std::vector<std::map<std::string, int>*> m_allvalues_tau;
};
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXSmallRJetAlgo.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXSmallRJetAlgo.h
index 97636895b9894d969c2c5af4efad46f8164185c6..22af33267db2b50918f146dee0d64d3f191c16c4 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXSmallRJetAlgo.h
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jFEXSmallRJetAlgo.h
@@ -39,7 +39,7 @@ namespace LVL1 {
virtual ~jFEXSmallRJetAlgo();
virtual StatusCode safetyTest() override;
- virtual void setup(int inputTable[7][7], bool barrel_region) override;
+ virtual void setup(int inputTable[7][7]) override;
virtual int realValue(int ID, int eta) override;
virtual unsigned int getRealPhi() override;
virtual int getRealEta() override;
@@ -48,6 +48,7 @@ namespace LVL1 {
virtual bool isSeedLocalMaxima() override;
virtual unsigned int getSmallClusterET() override;
virtual unsigned int getSmallETRing() override;
+ virtual bool checkDisplacedLM() override;
virtual std::unique_ptr<jFEXSmallRJetTOB> getSmallRJetTOBs() override;
// virtual jFEXSmallRJetTOB* getSmallRJetTOBs() override;
//LVL1::jFEXSmallRJetAlgoTOB * LVL1::jFEXSmallRJetAlgo::getSmallRJetTOB()
@@ -59,7 +60,7 @@ protected:
int m_jFEXalgoTowerID[7][7];
int m_jFEXalgoSearchWindowSeedET[5][5];
bool m_seedSet;
- bool m_barrel_region;
+ bool m_LMDisplaced;
};
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jTower.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jTower.h
index e1814c2a5bc1e1492caae00fcfd30f248fad4b35..b6196d0aba84bf86e2afa4459c9aa0b7eecf21cb 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jTower.h
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jTower.h
@@ -43,7 +43,7 @@ namespace LVL1 {
/** Constructors */
jTower();
- jTower(float eta, float phi, int eta_modifier_input, int id_modifier, int posneg, float centre_eta = 0.0, float centre_phi = 0.0, int fcal_layer = -1);
+ jTower(float eta, float phi, int eta_modifier_input, int id_modifier, int posneg, float centre_eta = -1.0, float centre_phi = -1.0, int fcal_layer = -1);
/** Destructor */
virtual ~jTower() = default;
@@ -136,8 +136,8 @@ namespace LVL1 {
float m_phi;
int m_tower_id;
int m_posneg = 0;
- float m_centre_eta;
- float m_centre_phi;
+ float m_centre_eta =0;
+ float m_centre_phi =0;
std::vector<Identifier> m_EM_scID;
std::vector<Identifier> m_HAD_scID;
std::vector<int> m_et;
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jTowerBuilder.h b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jTowerBuilder.h
index 0fdc5fa7f5302346b622644e1d9ba9c0bcfd33d8..74573bb1dc7b67790c4f6bc147d378ddfd41e7be 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jTowerBuilder.h
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/L1CaloFEXSim/jTowerBuilder.h
@@ -32,7 +32,6 @@ class jTowerBuilder: public AthAlgTool, virtual public IjTowerBuilder {
virtual void reset() override ;
private:
-
virtual void BuildEMBjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const override ;
virtual void BuildTRANSjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const override ;
virtual void BuildEMEjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const override ;
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/share/jFEXDriverJobOptions.py b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/share/jFEXDriverJobOptions.py
index af02440e3050a29493e0e24f3d7467d1b5107eaa..1d93f7c0696fff2fa8e7df82a7d16b064ed5c91a 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/share/jFEXDriverJobOptions.py
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/share/jFEXDriverJobOptions.py
@@ -65,11 +65,10 @@ xaodStream.AddItem( ["xAOD::jFexSumETRoIAuxContainer"] )
xaodStream.AddItem( ["xAOD::jFexMETRoIContainer"] )
xaodStream.AddItem( ["xAOD::jFexMETRoIAuxContainer"] )
-
#######################################################
log.info("==========================================================")
log.info("Scheduling jFEXDriver")
athAlgSeq += CfgMgr.LVL1__jFEXDriver('MyjFEXDriver')
-athAlgSeq += CfgMgr.LVL1__jFEXNtupleWriter('MyjFEXNtupleWriter')
+#athAlgSeq += CfgMgr.LVL1__jFEXNtupleWriter('MyjFEXNtupleWriter')
log.info("==========================================================")
#######################################################
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/components/FEXDriver_entries.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/components/FEXDriver_entries.cxx
index 27e2f9a8a3685c99c6b75357f115c188c75987d6..10810af1385ceeb533c405b0a8a3ce7550c37fbb 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/components/FEXDriver_entries.cxx
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/components/FEXDriver_entries.cxx
@@ -20,6 +20,7 @@
#include "L1CaloFEXSim/jFEXsumETAlgo.h"
#include "L1CaloFEXSim/jFEXmetAlgo.h"
#include "L1CaloFEXSim/jFEXLargeRJetAlgo.h"
+#include "L1CaloFEXSim/jFEXForwardJetsAlgo.h"
#include "L1CaloFEXSim/jFEXNtupleWriter.h"
#include "L1CaloFEXSim/eFEXFPGATowerIdProvider.h"
#include "L1CaloFEXSim/eFEXSuperCellTowerIdProvider.h"
@@ -55,4 +56,5 @@ DECLARE_COMPONENT(jFEXtauAlgo)
DECLARE_COMPONENT(jFEXsumETAlgo)
DECLARE_COMPONENT(jFEXmetAlgo)
DECLARE_COMPONENT(jFEXLargeRJetAlgo)
+DECLARE_COMPONENT(jFEXForwardJetsAlgo)
DECLARE_COMPONENT(jFEXNtupleWriter)
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXFPGA.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXFPGA.cxx
index 87cefd7d6fbfd703b906a9155040ac507297a2e4..b420cf33c7f1c07c87fcb6c1f413f86b76fe05bb 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXFPGA.cxx
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXFPGA.cxx
@@ -23,6 +23,8 @@
#include "L1CaloFEXSim/jFEXsumETTOB.h"
#include "L1CaloFEXSim/jFEXmetAlgo.h"
#include "L1CaloFEXSim/jFEXmetTOB.h"
+#include "L1CaloFEXSim/jFEXForwardJetsAlgo.h"
+#include "L1CaloFEXSim/jFEXForwardJetsInfo.h"
#include "CaloEvent/CaloCellContainer.h"
#include "CaloIdentifier/CaloIdManager.h"
#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
@@ -47,7 +49,6 @@ jFEXFPGA::jFEXFPGA(const std::string& type,const std::string& name,const IInterf
declareInterface<IjFEXFPGA>(this);
}
-
/** Destructor */
jFEXFPGA::~jFEXFPGA()
{
@@ -59,11 +60,10 @@ StatusCode jFEXFPGA::initialize()
{
ATH_CHECK(m_jFEXFPGA_jTowerContainerKey.initialize());
- //ATH_CHECK(m_jFEXFPGA_jFEXOutputCollectionKey.initialize());
+ ATH_CHECK(m_jFEXFPGA_jFEXOutputCollectionKey.initialize());
return StatusCode::SUCCESS;
}
-
StatusCode jFEXFPGA::init(int id, int jfexid)
{
m_id = id;
@@ -92,8 +92,7 @@ StatusCode jFEXFPGA::execute() {
ATH_MSG_FATAL("Could not retrieve jk_jFEXFPGA_jTowerContainer " << m_jFEXFPGA_jTowerContainerKey.key() );
return StatusCode::FAILURE;
}
-
-
+
//std::cout<< "******************************************** "<<m_jfexid<<std::endl;
if(m_id==0 || m_id==2){
if(m_jfexid > 0 && m_jfexid < 5){
@@ -154,8 +153,9 @@ StatusCode jFEXFPGA::execute() {
}
- //-----------jFEXSmallRJetAlgo-----------------
+ //-----------jFEXSmallRJet & Large R Jet Algo-----------------
ATH_MSG_DEBUG("==== jFEXSmallRJetAlgo ========");
+
jFEXOutputCollection* jFEXOutputs;
StatusCode sc_tobs = evtStore()->retrieve(jFEXOutputs, "jFEXOutputCollection");
@@ -163,29 +163,16 @@ StatusCode jFEXFPGA::execute() {
ATH_MSG_DEBUG("\n==== jFEXSmallRJetAlgo ======== Failed to find jFEXOutputCollection in jFEXFPGA");
}
- int Jets_eta_limit = -99;
- bool barrel_region = false;
-
- if(m_jfexid > 0 && m_jfexid < 5){
- Jets_eta_limit = FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width -8;
- barrel_region = true;
- //return StatusCode::SUCCESS;
- }
-
- if(m_jfexid == 0 || m_jfexid == 5){
- Jets_eta_limit = FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width -8;
- return StatusCode::SUCCESS;
- }
+ //Central region algorithms
+ if(m_jfexid > 0 && m_jfexid < 5){
+ for(int mphi = 8; mphi < FEXAlgoSpaceDefs::jFEX_algoSpace_height -8; mphi++) {
+ for(int meta = 8; meta < FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width -8; meta++) {
- for(int mphi = 8; mphi < 24; mphi++) {
- for(int meta = 8; meta < Jets_eta_limit; meta++) {
-
//create search window including towerIDs required for seeding.
int SRJet_SearchWindow[7][7] = {{0}};
for(int i = -3 ; i <4; i++){
for(int j = -3; j <4; j++){
- if(barrel_region){SRJet_SearchWindow[3 + i][3 + j] = m_jTowersIDs_Thin[mphi + i][meta +j];}
- else{SRJet_SearchWindow[3 + i][3 + j] = m_jTowersIDs_Wide[mphi + i][meta +j];}
+ SRJet_SearchWindow[3 + i][3 + j] = m_jTowersIDs_Thin[mphi + i][meta +j];
}
}
int largeRCluster_IDs[15][15]= {{0}};
@@ -194,6 +181,7 @@ StatusCode jFEXFPGA::execute() {
largeRCluster_IDs[7 +i][7 +j] = m_jTowersIDs_Thin[mphi + i][meta +j];
}
}
+
//remove corners from large ET ring
for(int i =4; i <8; i++) {
if( i != 7) {
@@ -222,64 +210,175 @@ StatusCode jFEXFPGA::execute() {
}
}
- m_jFEXSmallRJetAlgoTool->setup(SRJet_SearchWindow, barrel_region);
+ m_jFEXSmallRJetAlgoTool->setup(SRJet_SearchWindow);
m_jFEXLargeRJetAlgoTool->setupCluster(largeRCluster_IDs);
m_jFEXSmallRJetAlgoTool->buildSeeds();
- bool SRJet_LM = m_jFEXSmallRJetAlgoTool->isSeedLocalMaxima();
+ bool SRJet_LM = m_jFEXSmallRJetAlgoTool->isSeedLocalMaxima();
+
jFEXOutputs->addValue_smallRJet("smallRJet_isCentralTowerSeed", SRJet_LM);
- if(!SRJet_LM){continue;}
- int smallClusterET = m_jFEXSmallRJetAlgoTool->getSmallClusterET();
-
+
+ int smallClusterET = m_jFEXSmallRJetAlgoTool->getSmallClusterET();
//These are plots of the central TT for each 5x5 search window.
jFEXOutputs->addValue_smallRJet("smallRJet_ET", m_jFEXSmallRJetAlgoTool->getTTowerET());
- jFEXOutputs->addValue_smallRJet("smallRJet_phi",m_jFEXSmallRJetAlgoTool->getRealPhi()/10.);
- jFEXOutputs->addValue_smallRJet("smallRJet_eta",m_jFEXSmallRJetAlgoTool->getRealEta()/10.);
+ jFEXOutputs->addValue_smallRJet("smallRJet_phi",m_jFEXSmallRJetAlgoTool->getRealPhi());
+ jFEXOutputs->addValue_smallRJet("smallRJet_eta",m_jFEXSmallRJetAlgoTool->getRealEta());
jFEXOutputs->addValue_smallRJet("smallRJet_clusterET", smallClusterET);
+
+
+ if(!SRJet_LM){continue;}
std::unique_ptr<jFEXSmallRJetTOB> tmp_SRJet_tob = m_jFEXSmallRJetAlgoTool->getSmallRJetTOBs();
-
- bool SR_TOB_saturated = false;
-
- // for plotting variables in TOBS- internal check:
- jFEXOutputs->addValue_smallRJet("smallRJetTOB_eta", tmp_SRJet_tob->setEta(meta));
- jFEXOutputs->addValue_smallRJet("smallRJetTOB_phi", tmp_SRJet_tob->setPhi(mphi));
- jFEXOutputs->addValue_smallRJet("smallRJetTOB_ET", tmp_SRJet_tob->setET(smallClusterET));
- jFEXOutputs->addValue_smallRJet("smallRJetTOB_sat", tmp_SRJet_tob->setSat(SR_TOB_saturated));
+ bool check = m_jFEXSmallRJetAlgoTool->checkDisplacedLM();
+ //to check if Local Maxima is displaced.
+ int meta_LM = meta;
+ int mphi_LM = mphi;
+ if(check && SRJet_LM){
+ meta_LM = meta -1;
+ mphi_LM = mphi -1;
+
+ }
-
- uint32_t SRJet_tobword = formSmallRJetTOB(mphi, meta);
+ bool SR_TOB_saturated = false;
+ if (smallClusterET/200. > 0x7ff) SR_TOB_saturated = true;
- if ( SRJet_tobword != 0 ) m_SRJet_tobwords.push_back(SRJet_tobword);
-
+ // for plotting variables in TOBS- internal check:
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_eta", tmp_SRJet_tob->setEta(meta_LM)-8);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_phi", tmp_SRJet_tob->setPhi(mphi_LM)-8);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_ET", tmp_SRJet_tob->setET(smallClusterET/200));
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_sat", tmp_SRJet_tob->setSat(SR_TOB_saturated));
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_jfexID", m_jfexid);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_fpgaID", m_id);
+
+ uint32_t SRJet_tobword = formSmallRJetTOB(mphi_LM, meta_LM);
+ m_SRJet_tobwords.push_back(SRJet_tobword);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_word",SRJet_tobword);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_jfexID", m_jfexid);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_fpgaID", m_id);
+
jFEXOutputs->fill_smallRJet();
ATH_MSG_DEBUG("==== jFEXLargeRJetAlgo ========");
//LargeRJetAlgo is here as SmallRJetlocalMaxima is a requirement
unsigned int largeClusterET = m_jFEXLargeRJetAlgoTool->getLargeClusterET(m_jFEXSmallRJetAlgoTool->getSmallClusterET(),m_jFEXLargeRJetAlgoTool->getRingET());
- ATH_MSG_DEBUG("jFEXFPGA: large RJet algo, check large cluster ET: "<< largeClusterET);
- jFEXOutputs->addValue_largeRJet("largeRJet_ET", largeClusterET);
-
std::unique_ptr<jFEXLargeRJetTOB> tmp_LRJet_tob = m_jFEXLargeRJetAlgoTool->getLargeRJetTOBs();
unsigned int LR_TOB_saturated = 0;
- if (largeClusterET/200. > 13) LR_TOB_saturated = 1;
+ if (largeClusterET/200. > 0x1fff) LR_TOB_saturated = 1;
jFEXOutputs->addValue_largeRJet("largeRJet_ET", largeClusterET);
jFEXOutputs->addValue_largeRJet("largeRJet_phi", m_jFEXSmallRJetAlgoTool->getRealPhi());
jFEXOutputs->addValue_largeRJet("largeRJet_eta", m_jFEXSmallRJetAlgoTool->getRealEta());
- jFEXOutputs->addValue_largeRJet("largeRJetTOB_ET",tmp_LRJet_tob->setET(largeClusterET));
- jFEXOutputs->addValue_largeRJet("largeRJetTOB_eta",tmp_LRJet_tob->setEta(meta));
- jFEXOutputs->addValue_largeRJet("largeRJetTOB_phi",tmp_LRJet_tob->setPhi(mphi));
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_ET",tmp_LRJet_tob->setET(largeClusterET/200));
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_eta",tmp_SRJet_tob->setEta(meta));
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_phi",tmp_SRJet_tob->setPhi(mphi));
jFEXOutputs->addValue_largeRJet("largeRJetTOB_sat",tmp_LRJet_tob->setSat(LR_TOB_saturated));
-
- jFEXOutputs->fill_largeRJet();
-
+ jFEXOutputs->fill_largeRJet();
uint32_t LRJet_tobword = formLargeRJetTOB(mphi, meta);
if ( LRJet_tobword != 0 ) m_LRJet_tobwords.push_back(LRJet_tobword);
-
+ m_SRJet_tobwords.push_back(SRJet_tobword);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_word", LRJet_tobword);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_jfexID", m_jfexid);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_fpgaID", m_id);
}
}
+} //end of if statement for checking if in central jfex modules
+
+jFEXOutputs->fill_smallRJet();
+jFEXOutputs->fill_largeRJet();
+
+//**********Forward Jets***********************
+
+//FCAL region algorithm
+if(m_jfexid ==0 || m_jfexid ==5){
+//This is currently masked due to on going debugging in this FCAL Jets Algorithm
+ return StatusCode::SUCCESS;
+
+ m_jFEXForwardJetsAlgoTool->setup(m_jTowersIDs_Wide);
+ m_FCALJets = m_jFEXForwardJetsAlgoTool->calculateJetETs();
+
+ for(std::map<int, jFEXForwardJetsInfo>::iterator it = m_FCALJets.begin(); it!=(m_FCALJets.end()); ++it){
+
+ jFEXForwardJetsInfo FCALJets = it->second;
+ int iphi = FCALJets.getCentreLocalTTPhi();
+ int ieta = FCALJets.getCentreLocalTTEta();
+
+ uint32_t SRFCAL_Jet_tobword = formSmallRJetTOB(iphi, ieta);
+ if ( SRFCAL_Jet_tobword != 0 ) m_SRJet_tobwords.push_back(SRFCAL_Jet_tobword);
+ uint32_t LRFCAL_Jet_tobword = formLargeRJetTOB(iphi, ieta);
+ if ( LRFCAL_Jet_tobword != 0 ) m_LRJet_tobwords.push_back(LRFCAL_Jet_tobword);
+
+ float centre_eta = std::round(FCALJets.getCentreTTEta()*10);
+ float centre_phi = std::round(FCALJets.getCentreTTPhi()*10);
+ int output_centre_eta = static_cast<int> (centre_eta);
+ int output_centre_phi = static_cast<int> (centre_phi);
+ int SRJetET = FCALJets.getSeedET() + FCALJets.getFirstEnergyRingET();
+ int LRJetET = SRJetET + FCALJets.getSecondEnergyRingET();
+
+ int SRFCAL_TOB_saturated = 0;
+ if (SRJetET/200. > 0x7ff) SRFCAL_TOB_saturated = 1;
+
+ unsigned int LRFCAL_TOB_saturated = 0;
+ if (LRJetET/200. > 0x1fff) LRFCAL_TOB_saturated = 1;
+
+ //Output Collection for Small R Jet
+ jFEXOutputs->addValue_smallRJet("smallRJet_phi", output_centre_phi);
+ jFEXOutputs->addValue_smallRJet("smallRJet_eta", output_centre_eta);
+ jFEXOutputs->addValue_smallRJet("smallRJet_clusterET", SRJetET);
+ jFEXOutputs->addValue_smallRJet("smallRJet_sat", SRFCAL_TOB_saturated);
+ jFEXOutputs->addValue_smallRJet("smallRJet_isCentralTowerSeed",true);
+
+ if(m_jfexid == 0){
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_eta", 37-ieta);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_eta", 37-ieta);
+ }
+
+ if(m_jfexid == 5){
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_eta", ieta-8);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_eta", ieta-8);
+ }
+
+ if(iphi >=FEXAlgoSpaceDefs::jFEX_algoSpace_EMB_start_phi && iphi< FEXAlgoSpaceDefs::jFEX_algoSpace_EMB_end_phi){
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_phi", iphi-8);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_phi", iphi-8);
+ }
+
+ if(iphi >=FEXAlgoSpaceDefs::jFEX_algoSpace_EMIE_start_phi && iphi< FEXAlgoSpaceDefs::jFEX_algoSpace_EMIE_end_phi){
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_phi", iphi-4);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_phi", iphi-4);
+ }
+
+ if(iphi >=FEXAlgoSpaceDefs::jFEX_algoSpace_FCAL_start_phi && iphi< FEXAlgoSpaceDefs::jFEX_algoSpace_FCAL_end_phi){
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_phi", iphi-2);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_phi", iphi-2);
+ }
+
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_ET", SRJetET/200);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_sat", SRFCAL_TOB_saturated);
+
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_word", SRFCAL_Jet_tobword);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_jfexID", m_jfexid);
+ jFEXOutputs->addValue_smallRJet("smallRJetTOB_fpgaID", m_id);
+
+ jFEXOutputs->fill_smallRJet();
+
+ //Output Collection for Large R Jet
+ jFEXOutputs->addValue_largeRJet("largeRJet_ET", LRJetET);
+ jFEXOutputs->addValue_largeRJet("largeRJet_phi", output_centre_phi);
+ jFEXOutputs->addValue_largeRJet("largeRJet_eta", output_centre_eta);
+ jFEXOutputs->addValue_largeRJet("largeRJet_sat", LRFCAL_TOB_saturated);
+
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_ET", LRJetET/200);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_sat",LRFCAL_TOB_saturated);
+
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_word", LRFCAL_Jet_tobword);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_jfexID", m_jfexid);
+ jFEXOutputs->addValue_largeRJet("largeRJetTOB_fpgaID", m_id);
+
+ jFEXOutputs->fill_largeRJet();
+
+ }
+}
//******************************** TAU **********************************************
@@ -315,8 +414,7 @@ StatusCode jFEXFPGA::execute() {
ATH_MSG_DEBUG("============================ jFEXtauAlgo ============================");
for(int mphi = 8; mphi < 24; mphi++) {
for(int meta = 8; meta < max_meta; meta++) {
-
-
+
int TT_seed_ID[3][3]={{0}};
int TT_searchWindow_ID[5][5]={{0}};
int TT_First_ETring[36]={0};
@@ -338,17 +436,14 @@ StatusCode jFEXFPGA::execute() {
}
}
}
-
ATH_CHECK( m_jFEXtauAlgoTool.retrieve());
ATH_CHECK( m_jFEXtauAlgoTool->safetyTest());
m_jFEXtauAlgoTool->setup(TT_searchWindow_ID,TT_seed_ID);
m_jFEXtauAlgoTool->buildSeeds();
bool is_tau_LocalMax = m_jFEXtauAlgoTool->isSeedLocalMaxima();
- //m_jFEXtauAlgoTool->isSeedLocalMaxima();
m_jFEXtauAlgoTool->setFirstEtRing(TT_First_ETring);
-
jFEXOutputs->addValue_tau("tau_ET", m_jFEXtauAlgoTool->getTTowerET());
jFEXOutputs->addValue_tau("tau_clusterET", m_jFEXtauAlgoTool->getClusterEt());
jFEXOutputs->addValue_tau("tau_eta",abs(m_jFEXtauAlgoTool->getRealEta())) ;
@@ -377,6 +472,8 @@ StatusCode jFEXFPGA::execute() {
jFEXOutputs->fill_tau();
}
}
+
+
return StatusCode::SUCCESS;
} //end of the execute function
@@ -407,10 +504,7 @@ void jFEXFPGA::SetTowersAndCells_SG(int tmp_jTowersIDs_subset[][FEXAlgoSpaceDefs
//this prints out the jTower IDs that each FPGA is responsible for
ATH_MSG_DEBUG("\n==== jFEXFPGA ========= FPGA (" << m_id << ") [on jFEX " << m_jfexid << "] IS RESPONSIBLE FOR jTOWERS :");
-
- //comment below due to mapping bug 12.01.21
-
-
+
for (int thisRow=rows-1; thisRow>=0; thisRow--){
for (int thisCol=0; thisCol<cols; thisCol++){
if(thisCol != cols-1){ ATH_MSG_DEBUG("| " << m_jTowersIDs_Thin[thisRow][thisCol] << " "); }
@@ -446,25 +540,37 @@ std::vector <uint32_t> jFEXFPGA::getLargeRJetTOBs()
}
-
-
-uint32_t jFEXFPGA::formSmallRJetTOB(int & iphi, int &ieta )
+uint32_t jFEXFPGA::formSmallRJetTOB(int &iphi, int &ieta)
{
uint32_t tobWord = 0;
const unsigned int jFEXETResolution = 200; //LSB is 200MeV
+ int eta = 0;
+ int phi = 0;
+ unsigned int et = 0;
+ unsigned int jFEXSmallRJetTOBEt = 0;
+ int Res = 0; // 11 bits reserved
+ int Sat = 0; // 1 bit for saturation. Set to 1 when jet energy is saturated
- unsigned int et = m_jFEXSmallRJetAlgoTool->getSmallClusterET();
- unsigned int jFEXSmallRJetTOBEt = et/jFEXETResolution;
+ if(m_jfexid > 0 && m_jfexid < 5){
+ et = m_jFEXSmallRJetAlgoTool->getSmallClusterET();
+ jFEXSmallRJetTOBEt = et/jFEXETResolution;
+ eta = ieta -8;
+ phi = iphi -8;
+ }
- int eta = ieta -8;
- int phi = iphi -8;
- int Res = 0; //11 bits reserved
- int Sat = 0; //1 bit for saturation. Set to 1 if saturated.
-
+ if(m_jfexid ==0 || m_jfexid ==5){
+ for(std::map<int, jFEXForwardJetsInfo>::iterator it = m_FCALJets.begin(); it!=(m_FCALJets.end()); ++it){
+ jFEXForwardJetsInfo FCALJetInfo = it->second;
+ eta = ieta -8;
+ phi = iphi -8;
+ et = FCALJetInfo.getSeedET() + FCALJetInfo.getFirstEnergyRingET();
+ jFEXSmallRJetTOBEt = et/jFEXETResolution;
+ }
+ }
if (jFEXSmallRJetTOBEt > 0x7ff){
- jFEXSmallRJetTOBEt = 0x7ff;//0x7ff is 11 bits
- Sat = 1;
+ jFEXSmallRJetTOBEt = 0x7ff;
+ Sat = 1;
}
//create basic tobword with 32 bits
@@ -477,18 +583,34 @@ uint32_t jFEXFPGA::formSmallRJetTOB(int & iphi, int &ieta )
else return tobWord;
}
-uint32_t jFEXFPGA::formLargeRJetTOB(int & iphi, int &ieta )
+uint32_t jFEXFPGA::formLargeRJetTOB(int & iphi, int &ieta)
{
uint32_t tobWord = 0;
const unsigned int jFEXETResolution = 200; //LSB is 200MeV
+ int eta = 0;
+ int phi = 0;
+ unsigned int et = 0;
+ unsigned int jFEXLargeRJetTOBEt = 0;
+ int Res = 0; // 9 bits reserved
+ int Sat = 0; // 1 bit for saturation. Set to 1 when jet energy is saturated
- unsigned int et = m_jFEXLargeRJetAlgoTool->getLargeClusterET(m_jFEXSmallRJetAlgoTool->getSmallClusterET(),m_jFEXLargeRJetAlgoTool->getRingET());
- unsigned int jFEXLargeRJetTOBEt = et/jFEXETResolution;
+ if(m_jfexid > 0 && m_jfexid < 5){
+ et = m_jFEXLargeRJetAlgoTool->getLargeClusterET(m_jFEXSmallRJetAlgoTool->getSmallClusterET(),m_jFEXLargeRJetAlgoTool->getRingET());
+ jFEXLargeRJetTOBEt = et/jFEXETResolution;
+ eta = ieta -8;
+ phi = iphi -8;
+ }
+
+ if(m_jfexid ==0 || m_jfexid ==5){
+ for(std::map<int, jFEXForwardJetsInfo>::iterator it = m_FCALJets.begin(); it!=(m_FCALJets.end()); ++it){
+ jFEXForwardJetsInfo FCALJetInfo = it->second;
+ eta = ieta -8;
+ phi = iphi -8;
+ et = FCALJetInfo.getSeedET() + FCALJetInfo.getFirstEnergyRingET() + FCALJetInfo.getSecondEnergyRingET();
+ jFEXLargeRJetTOBEt = et/jFEXETResolution;
+ }
+ }
- int eta = ieta -8;
- int phi = iphi -8;
- int Res = 0; //9 bits reserved
- int Sat = 1; //1 bit for saturation flag, not coded yet
if (jFEXLargeRJetTOBEt > 0x1fff){
jFEXLargeRJetTOBEt = 0x1fff; //0x1fff is 13 bits
Sat = 1;
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXForwardJetsAlgo.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXForwardJetsAlgo.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..a7c3ceb60cae7739c55d799477e494f3c075a20b
--- /dev/null
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXForwardJetsAlgo.cxx
@@ -0,0 +1,278 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+//***************************************************************************
+// jFEXForwardJetsAlgo - Algorithm for forward Jets in jFEX
+// -------------------
+// begin : 07 06 2021
+// email : varsiha.sothilingam@cern.ch
+//***************************************************************************
+#include <iostream>
+#include <vector>
+#include <string>
+#include <map>
+#include "L1CaloFEXSim/jFEXForwardJetsAlgo.h"
+#include "L1CaloFEXSim/jTower.h"
+#include "L1CaloFEXSim/jTowerContainer.h"
+#include "L1CaloFEXSim/jFEXForwardJetsInfo.h"
+#include "L1CaloFEXSim/FEXAlgoSpaceDefs.h"
+#include "CaloEvent/CaloCellContainer.h"
+#include "CaloIdentifier/CaloIdManager.h"
+#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/StoreGateSvc.h"
+
+namespace LVL1{
+
+//Default Constructor
+LVL1::jFEXForwardJetsAlgo::jFEXForwardJetsAlgo(const std::string& type, const std::string& name, const IInterface* parent):
+ AthAlgTool(type, name, parent)
+ {
+ declareInterface<IjFEXForwardJetsAlgo>(this);
+ }
+
+/** Destructor */
+LVL1::jFEXForwardJetsAlgo::~jFEXForwardJetsAlgo()
+{
+}
+StatusCode LVL1::jFEXForwardJetsAlgo::initialize()
+{
+ ATH_CHECK(m_jFEXForwardJetsAlgo_jTowerContainerKey.initialize());
+ return StatusCode::SUCCESS;
+
+}
+
+//calls container for TT
+StatusCode LVL1::jFEXForwardJetsAlgo::safetyTest(){
+
+ SG::ReadHandle<jTowerContainer> jk_jFEXForwardJetsAlgo_jTowerContainer(m_jFEXForwardJetsAlgo_jTowerContainerKey);
+
+ if(! jk_jFEXForwardJetsAlgo_jTowerContainer.isValid()){
+ ATH_MSG_FATAL("Could not retrieve jk_jFEXForwardJetsAlgo_jTowerContainer " << m_jFEXForwardJetsAlgo_jTowerContainerKey.key());
+
+ return StatusCode::FAILURE;
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+void LVL1::jFEXForwardJetsAlgo::setup(int inputTable[FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width]) {
+ std::copy(&inputTable[0][0], &inputTable[0][0] + (FEXAlgoSpaceDefs::jFEX_algoSpace_height*FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width), &m_jFEXalgoTowerID[0][0]);
+}
+
+//Gets geometric global centre Phi coord of the TT
+float LVL1::jFEXForwardJetsAlgo::globalPhi(int nphi, int neta) {
+
+ SG::ReadHandle<jTowerContainer> jk_jFEXForwardJetsAlgo_jTowerContainer(m_jFEXForwardJetsAlgo_jTowerContainerKey/*,ctx*/);
+ float phi = jk_jFEXForwardJetsAlgo_jTowerContainer->findTower(m_jFEXalgoTowerID[nphi][neta])->centrePhi();
+ return phi;
+}
+
+//Gets geometric global centre Eta coord of the TT
+float LVL1::jFEXForwardJetsAlgo::globalEta(int nphi, int neta) {
+
+ SG::ReadHandle<jTowerContainer> jk_jFEXForwardJetsAlgo_jTowerContainer(m_jFEXForwardJetsAlgo_jTowerContainerKey/*,ctx*/);
+ float eta = jk_jFEXForwardJetsAlgo_jTowerContainer->findTower(m_jFEXalgoTowerID[nphi][neta])->centreEta();
+ return eta;
+
+}
+
+//Gets Phi of the TT
+unsigned int LVL1::jFEXForwardJetsAlgo::localPhi(int nphi, int neta) {
+
+ SG::ReadHandle<jTowerContainer> jk_jFEXForwardJetsAlgo_jTowerContainer(m_jFEXForwardJetsAlgo_jTowerContainerKey/*,ctx*/);
+ unsigned int phi = jk_jFEXForwardJetsAlgo_jTowerContainer->findTower(m_jFEXalgoTowerID[nphi][neta])->phi();
+ return phi;
+}
+//Gets Eta of the TT
+unsigned int LVL1::jFEXForwardJetsAlgo::localEta(int nphi, int neta) {
+
+ SG::ReadHandle<jTowerContainer> jk_jFEXForwardJetsAlgo_jTowerContainer(m_jFEXForwardJetsAlgo_jTowerContainerKey/*,ctx*/);
+ unsigned int eta = jk_jFEXForwardJetsAlgo_jTowerContainer->findTower(m_jFEXalgoTowerID[nphi][neta])->eta();
+ return eta;
+}
+
+//Return ET of TT. Should be FCAL 0 + 1 + 2 //maybe check this
+unsigned int LVL1::jFEXForwardJetsAlgo::getTTowerET(int nphi, int neta){
+
+ SG::ReadHandle<jTowerContainer> jk_jFEXForwardJetsAlgo_jTowerContainer(m_jFEXForwardJetsAlgo_jTowerContainerKey/*,ctx*/);
+ const LVL1::jTower * tmpTower = jk_jFEXForwardJetsAlgo_jTowerContainer->findTower(m_jFEXalgoTowerID[nphi][neta]);
+ unsigned int et = tmpTower->getTotalET();
+ return et;
+}
+
+std::map<int, jFEXForwardJetsInfo> LVL1::jFEXForwardJetsAlgo::FcalJetsTowerIDLists(){
+
+ std::map<int, jFEXForwardJetsInfo> FCALJetTowerIDLists;
+ static constexpr float TT_Size = M_PI/32;
+
+ //This flag determines if the TT ID which are in the first and second energy rings are stored
+ //in the jFEXForwardJetsInfo class. It is set to false to reduce quantity data stored in class
+ m_storeEnergyRingTTIDs = false;
+
+ std::vector<int> lower_centre_neta;
+ std::vector<int> upper_centre_neta;
+ int lowerEM_eta = 0;
+ int upperEM_eta = 0;
+
+ //STEP 1: check if we are in module 0 or 5 and assign corrrect eta FEXAlgoSpace parameters
+ if(m_jFEXalgoTowerID[31][0] == 0){
+ //Module 0
+ lower_centre_neta.assign({FEXAlgoSpaceDefs::jFEX_algoSpace_C_EMB_start_eta, FEXAlgoSpaceDefs::jFEX_algoSpace_C_EMIE_start_eta, FEXAlgoSpaceDefs::jFEX_algoSpace_C_FCAL_start_eta});
+ upper_centre_neta.assign({FEXAlgoSpaceDefs::jFEX_algoSpace_C_EMB_end_eta, FEXAlgoSpaceDefs::jFEX_algoSpace_C_EMIE_end_eta,FEXAlgoSpaceDefs::jFEX_algoSpace_C_FCAL_end_eta });
+
+ lowerEM_eta = FEXAlgoSpaceDefs::jFEX_algoSpace_C_lowerEM_eta;
+ upperEM_eta = FEXAlgoSpaceDefs::jFEX_algoSpace_C_upperEM_eta;
+ }
+
+ else{
+ //Module 5
+ lower_centre_neta.assign({FEXAlgoSpaceDefs::jFEX_algoSpace_A_EMB_eta, FEXAlgoSpaceDefs::jFEX_algoSpace_A_EMIE_eta, FEXAlgoSpaceDefs::jFEX_algoSpace_A_FCAL_start_eta});
+ upper_centre_neta.assign({FEXAlgoSpaceDefs::jFEX_algoSpace_A_EMIE_eta, FEXAlgoSpaceDefs::jFEX_algoSpace_A_FCAL_start_eta, FEXAlgoSpaceDefs::jFEX_algoSpace_A_FCAL_end_eta});
+
+ lowerEM_eta = FEXAlgoSpaceDefs::jFEX_algoSpace_A_lowerEM_eta;
+ upperEM_eta = FEXAlgoSpaceDefs::jFEX_algoSpace_A_upperEM_eta;
+ }
+
+ //STEP 2: define phi FEXAlgoSpace parameters
+ std::vector<int> lower_centre_nphi{FEXAlgoSpaceDefs::jFEX_algoSpace_EMB_start_phi, FEXAlgoSpaceDefs::jFEX_algoSpace_EMIE_start_phi, FEXAlgoSpaceDefs::jFEX_algoSpace_FCAL_start_phi};
+ std::vector<int> upper_centre_nphi{FEXAlgoSpaceDefs::jFEX_algoSpace_EMB_end_phi, FEXAlgoSpaceDefs::jFEX_algoSpace_EMIE_end_phi, FEXAlgoSpaceDefs::jFEX_algoSpace_FCAL_end_phi};
+
+
+ //STEP 3: loop over different EM/FCAL0 eta phi core fpga regions. These are potential central trigger towers for jets
+ for(int myCounter = 0; myCounter<3; myCounter++){
+ for(int centre_nphi = lower_centre_nphi[myCounter]; centre_nphi < upper_centre_nphi[myCounter]; centre_nphi++) {
+ for(int centre_neta = lower_centre_neta[myCounter]; centre_neta < upper_centre_neta[myCounter]; centre_neta++) {
+
+ //STEP 4: define TTID which will be the key for class in map
+ int myTTIDKey = m_jFEXalgoTowerID[centre_nphi][centre_neta];
+
+ //STEP 5: ignore when tower ID is zero.
+ if(myTTIDKey == 0){continue;}
+
+ //STEP 6: define class
+ jFEXForwardJetsInfo TriggerTowerInformation;
+
+ //STEP 7: fill local eta phi coords
+ TriggerTowerInformation.setCentreLocalTTPhi(centre_nphi);
+ TriggerTowerInformation.setCentreLocalTTEta(centre_neta);
+
+ float centreTT_phi = globalPhi(centre_nphi, centre_neta);
+ float centreTT_eta = globalEta(centre_nphi, centre_neta);
+ TriggerTowerInformation.setCentreTTPhi(centreTT_phi);
+ TriggerTowerInformation.setCentreTTEta(centreTT_eta);
+
+ //STEP 8: loop over all FCAL0 TTIDs and fill TT IDs for seed and calculate seed energy
+ for(int nphi = 0; nphi < 32; nphi++) {
+ for(int neta = lowerEM_eta; neta < upperEM_eta; neta++) {
+ if(((nphi == centre_nphi) && (neta == centre_neta)) ||(m_jFEXalgoTowerID[nphi][neta])==0 ){continue;}
+ float TT_phi = globalPhi(nphi, neta);
+ float TT_eta = globalEta(nphi, neta);
+ float R = sqrt(pow((centreTT_eta - TT_eta),2) + pow((centreTT_phi - TT_phi),2));
+ if((R > 0) && (R <( 2 * TT_Size))){
+ //STEP 9: fill TTID in seed
+ TriggerTowerInformation.includeTTinSeed(m_jFEXalgoTowerID[nphi][neta]);
+ //STEP 10: add ET value to seed
+ TriggerTowerInformation.addToSeedET(getTTowerET(nphi, neta));
+ }
+ }
+ }
+ //STEP 11: Store filled class into map, with central TT ID as Key
+ FCALJetTowerIDLists[myTTIDKey] = TriggerTowerInformation;
+ }//end of centre_nphi loop
+ }//end of centre_mphi loop
+ }//end of myCounter loop
+ return FCALJetTowerIDLists;
+}
+
+
+
+std::map<int, jFEXForwardJetsInfo> LVL1::jFEXForwardJetsAlgo::isSeedLocalMaxima(){
+ std::vector<int> localMaximas;
+ std::map<int, jFEXForwardJetsInfo> localMaximaLists = FcalJetsTowerIDLists();
+ size_t isLocalMaxima = 0;
+ int totalLM = 0;
+ for(std::map<int, jFEXForwardJetsInfo>::iterator it = localMaximaLists.begin(); it != (localMaximaLists.end()); ++it)
+ {
+ isLocalMaxima = 0;
+ int myTTKey = it->first;
+ jFEXForwardJetsInfo myFCALJetInfoClass = it ->second;
+ //Local maxima check takes place here
+ SG::ReadHandle<jTowerContainer> jk_jFEXForwardJetsAlgo_jTowerContainer(m_jFEXForwardJetsAlgo_jTowerContainerKey/*,ctx*/);
+ float centre_phi = myFCALJetInfoClass.getCentreTTPhi();
+ float centre_eta = myFCALJetInfoClass.getCentreTTPhi();
+ float centre_energy = myFCALJetInfoClass.getSeedET();
+ std::vector<int> TTinSeed = myFCALJetInfoClass.getTTinSeed();
+ for (std::size_t i = 0, max = TTinSeed.size(); i != max; ++i){
+ float seed_phi = jk_jFEXForwardJetsAlgo_jTowerContainer->findTower(TTinSeed[i])->centrePhi();
+ float seed_eta = jk_jFEXForwardJetsAlgo_jTowerContainer->findTower(TTinSeed[i])->centreEta();
+
+ float delta_phi = seed_phi - centre_phi;
+ float delta_eta = seed_eta - centre_eta;
+ float seed_energy = localMaximaLists[TTinSeed[i]].getSeedET();
+
+ if( ((delta_eta + delta_phi) < 0) || ((delta_eta + delta_phi == 0) && (delta_eta < 0)) )
+ {
+ if(centre_energy >= seed_energy){isLocalMaxima++;}
+ }
+ else
+ {
+ if(centre_energy > seed_energy){isLocalMaxima++;}
+ }
+ }
+ //if it is a local maxima, here we save the TT ID
+ if((isLocalMaxima == TTinSeed.size()) &&(isLocalMaxima !=0)){localMaximas.push_back(myTTKey); totalLM++;}
+ }
+
+ //now with a list of localmaxima centre TT IDs, we can remove all the other not LM keys and jfexforward jet classes from the map
+ for(std::map<int, jFEXForwardJetsInfo>::iterator it = localMaximaLists.begin(); it !=localMaximaLists.end(); ++it)
+ {
+ std::vector<int>::iterator itr;
+ itr = std::find(localMaximas.begin(), localMaximas.end(), it->first);
+ if(itr !=localMaximas.end())
+ {continue;}
+ else{
+ localMaximaLists.erase(it->first);
+ }
+ }
+
+ return localMaximaLists;
+}
+
+std::map<int, jFEXForwardJetsInfo> LVL1::jFEXForwardJetsAlgo::calculateJetETs(){
+ std::map<int, jFEXForwardJetsInfo> localMaximas = isSeedLocalMaxima();
+ static constexpr float TT_Size = M_PI/32;
+
+ //here we loop over all trigger towers, fcal 0 1 2 and calculate energy of TT which lays in the 0.4
+ //and 0.8 radius to be stored.
+ for(std::map<int, jFEXForwardJetsInfo>::iterator it = localMaximas.begin(); it !=localMaximas.end(); ++it){
+ int key = it->first;
+ float centreTT_phi = localMaximas[key].getCentreTTPhi();
+ float centreTT_eta = localMaximas[key].getCentreTTEta();
+
+ for(int nphi = 0; nphi < FEXAlgoSpaceDefs::jFEX_algoSpace_height; nphi++) {
+ for(int neta = 0; neta < FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width; neta++) {
+
+ if((m_jFEXalgoTowerID[nphi][neta] == (it->first))){continue;}
+ float TT_phi = globalPhi(nphi, neta);
+ float TT_eta = globalEta(nphi, neta);
+ float R = sqrt(pow((centreTT_eta - TT_eta),2) + pow((centreTT_phi - TT_phi),2));
+
+ if((R> (2 * TT_Size)) && (R< (4 * TT_Size))){
+ localMaximas[it->first].addToFirstEnergyRingET(getTTowerET(nphi, neta));
+ if(m_storeEnergyRingTTIDs){localMaximas[it->first].includeTTIDinFirstER(m_jFEXalgoTowerID[nphi][neta]);}
+ }
+
+ if((R> (4 * TT_Size)) && (R< (8 * TT_Size))){
+ localMaximas[it->first].addToSecondEnergyRingET(getTTowerET(nphi, neta));
+ if(m_storeEnergyRingTTIDs){localMaximas[it->first].includeTTIDinSecondER(m_jFEXalgoTowerID[nphi][neta]);}
+ }
+
+ }
+ }
+ }
+ return localMaximas;
+}
+
+}// end of namespace LVL1
+
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXForwardJetsInfo.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXForwardJetsInfo.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..0fd940abd46081fb2e3040618d9f71d04d53538e
--- /dev/null
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXForwardJetsInfo.cxx
@@ -0,0 +1,122 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+//***************************************************************************
+// jFEXForwardJetsInfo -
+// -------------------
+// begin : 07 07 2021
+// email : varsiha.sothilingam@cern.ch
+//***************************************************************************
+#include <iostream>
+#include <vector>
+#include <string>
+#include <map>
+//#include "L1CaloFEXSim/jFEXForwardJetsAlgo.h"
+#include "L1CaloFEXSim/jTower.h"
+#include "L1CaloFEXSim/jTowerContainer.h"
+#include "L1CaloFEXSim/jFEXForwardJetsInfo.h"
+#include "L1CaloFEXSim/FEXAlgoSpaceDefs.h"
+#include "CaloEvent/CaloCellContainer.h"
+#include "CaloIdentifier/CaloIdManager.h"
+#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/StoreGateSvc.h"
+
+void LVL1::jFEXForwardJetsInfo::setCentreTTEta(float centreTTEta)
+{
+ m_centreTTEta = centreTTEta;
+}
+
+float LVL1::jFEXForwardJetsInfo::getCentreTTEta()
+{
+ return m_centreTTEta;
+}
+
+void LVL1::jFEXForwardJetsInfo::setCentreTTPhi(float centreTTPhi)
+{
+ m_centreTTPhi = centreTTPhi;
+}
+
+float LVL1::jFEXForwardJetsInfo::getCentreTTPhi()
+{
+ return m_centreTTPhi;
+}
+void LVL1::jFEXForwardJetsInfo::setCentreLocalTTEta(float centreLocalTTEta)
+{
+ m_centreLocalTTEta = centreLocalTTEta;
+}
+
+float LVL1::jFEXForwardJetsInfo::getCentreLocalTTEta()
+{
+ return m_centreLocalTTEta;
+}
+
+void LVL1::jFEXForwardJetsInfo::setCentreLocalTTPhi(float centreLocalTTPhi)
+{
+ m_centreLocalTTPhi = centreLocalTTPhi;
+}
+
+float LVL1::jFEXForwardJetsInfo::getCentreLocalTTPhi()
+{
+ return m_centreLocalTTPhi;
+}
+
+void LVL1::jFEXForwardJetsInfo::includeTTinSeed(int TT_ID)
+{
+ m_TTsInSeed.push_back(TT_ID);
+}
+
+std::vector<int> LVL1::jFEXForwardJetsInfo::getTTinSeed()
+{
+ return m_TTsInSeed;
+}
+
+void LVL1::jFEXForwardJetsInfo::addToSeedET(int seed_ET)
+{
+ m_seed_ET += seed_ET;
+}
+
+int LVL1::jFEXForwardJetsInfo::getSeedET()
+{
+ return m_seed_ET;
+}
+
+void LVL1::jFEXForwardJetsInfo::addToFirstEnergyRingET(int firstER_ET)
+{
+ m_firstEnergyRing_ET = firstER_ET;
+}
+int LVL1::jFEXForwardJetsInfo::getFirstEnergyRingET()
+{
+ return m_firstEnergyRing_ET;
+}
+
+void LVL1::jFEXForwardJetsInfo::includeTTIDinFirstER(int firstER_TTID)
+{
+ m_firstEnergyRing_TTIDs.push_back(firstER_TTID);
+}
+std::vector<int> LVL1::jFEXForwardJetsInfo::getTTIDinFirstER()
+{
+ return m_firstEnergyRing_TTIDs;
+}
+
+
+void LVL1::jFEXForwardJetsInfo::includeTTIDinSecondER(int secondER_TTID)
+{
+ m_secondEnergyRing_TTIDs.push_back(secondER_TTID);
+}
+std::vector<int> LVL1::jFEXForwardJetsInfo::getTTIDinSecondER()
+{
+ return m_secondEnergyRing_TTIDs;
+}
+
+void LVL1::jFEXForwardJetsInfo::addToSecondEnergyRingET(int secondER_ET)
+{
+ m_secondEnergyRing_ET = secondER_ET;
+}
+
+int LVL1::jFEXForwardJetsInfo::getSecondEnergyRingET()
+{
+ return m_secondEnergyRing_ET;
+}
+
+
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXNtupleWriter.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXNtupleWriter.cxx
index 53a722a0f4965e7fa7e8a6b3ab2abfaed2fd8ef1..2e333a91d9a8d44ffda6f1352f826b63624f867a 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXNtupleWriter.cxx
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXNtupleWriter.cxx
@@ -67,6 +67,10 @@ StatusCode LVL1::jFEXNtupleWriter::initialize () {
m_myTree->Branch ("smallRJetTOB_phi", &m_smallRJetTOB_phi);
m_myTree->Branch ("smallRJetTOB_ET", &m_smallRJetTOB_ET);
m_myTree->Branch ("smallRJetTOB_sat", &m_smallRJetTOB_sat);
+ m_myTree->Branch ("smallRJetTOB_word", &m_smallRJetTOB_word);
+ m_myTree->Branch ("smallRJetTOB_jfexID", &m_smallRJetTOB_jfexID);
+ m_myTree->Branch ("smallRJetTOB_fpgaID", &m_smallRJetTOB_fpgaID);
+
m_myTree->Branch ("largeRJet_eta", &m_largeRJet_eta);
m_myTree->Branch ("largeRJet_phi", &m_largeRJet_phi);
@@ -78,6 +82,10 @@ StatusCode LVL1::jFEXNtupleWriter::initialize () {
m_myTree->Branch ("largeRJetTOB_phi", &m_largeRJetTOB_phi);
m_myTree->Branch ("largeRJetTOB_sat", &m_largeRJetTOB_sat);
+ m_myTree->Branch ("largeRJetTOB_word", &m_largeRJetTOB_word);
+ m_myTree->Branch ("largeRJetTOB_jfexID", &m_largeRJetTOB_jfexID);
+ m_myTree->Branch ("largeRJetTOB_fpgaID", &m_largeRJetTOB_fpgaID);
+
m_myTree->Branch ("tau_TT_ID" , &m_tau_TT_ID);
m_myTree->Branch ("tau_isLocalMax" , &m_tau_isLocalMax);
m_myTree->Branch ("tau_ET" , &m_tau_ET);
@@ -132,6 +140,10 @@ StatusCode LVL1::jFEXNtupleWriter::loadsmallRJetAlgoVariables() {
m_smallRJetTOB_phi.clear();
m_smallRJetTOB_ET.clear();
m_smallRJetTOB_sat.clear();
+ m_smallRJetTOB_word.clear();
+ m_smallRJetTOB_jfexID.clear();
+ m_smallRJetTOB_fpgaID.clear();
+
for (int i = 0; i < m_jFEXOutputCollection->SRsize(); i++)
{
m_smallRJet_isCentralTowerSeed.push_back((*(m_jFEXOutputCollection->get_smallRJet(i)))["smallRJet_isCentralTowerSeed"]);
@@ -143,6 +155,9 @@ StatusCode LVL1::jFEXNtupleWriter::loadsmallRJetAlgoVariables() {
m_smallRJetTOB_phi.push_back((*(m_jFEXOutputCollection->get_smallRJet(i)))["smallRJetTOB_phi"]);
m_smallRJetTOB_ET.push_back((*(m_jFEXOutputCollection->get_smallRJet(i)))["smallRJetTOB_ET"]);
m_smallRJetTOB_sat.push_back((*(m_jFEXOutputCollection->get_smallRJet(i)))["smallRJetTOB_sat"]);
+ m_smallRJetTOB_word.push_back((*(m_jFEXOutputCollection->get_smallRJet(i)))["smallRJetTOB_word"]);
+ m_smallRJetTOB_jfexID.push_back((*(m_jFEXOutputCollection->get_smallRJet(i)))["smallRJetTOB_jfexID"]);
+ m_smallRJetTOB_fpgaID.push_back((*(m_jFEXOutputCollection->get_smallRJet(i)))["smallRJetTOB_fpgaID"]);
}
return StatusCode::SUCCESS;
}
@@ -153,6 +168,12 @@ StatusCode LVL1::jFEXNtupleWriter::loadlargeRJetAlgoVariables() {
m_largeRJet_eta.clear();
m_largeRJet_phi.clear();
m_largeRJetTOB_ET.clear();
+ m_largeRJetTOB_eta.clear();
+ m_largeRJetTOB_phi.clear();
+ m_largeRJetTOB_sat.clear();
+ m_largeRJetTOB_word.clear();
+ m_largeRJetTOB_fpgaID.clear();
+ m_largeRJetTOB_jfexID.clear();
for (int i = 0; i < m_jFEXOutputCollection->LRsize(); i++)
{
@@ -161,6 +182,12 @@ StatusCode LVL1::jFEXNtupleWriter::loadlargeRJetAlgoVariables() {
m_largeRJet_eta.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJet_eta"]);
m_largeRJet_phi.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJet_phi"]);
m_largeRJetTOB_ET.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJetTOB_ET"]);
+ m_largeRJetTOB_eta.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJetTOB_eta"]);
+ m_largeRJetTOB_phi.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJetTOB_phi"]);
+ m_largeRJetTOB_sat.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJetTOB_sat"]);
+ m_largeRJetTOB_word.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJetTOB_word"]);
+ m_largeRJetTOB_fpgaID.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJetTOB_fpgaID"]);
+ m_largeRJetTOB_jfexID.push_back((*(m_jFEXOutputCollection->get_largeRJet(i)))["largeRJetTOB_jfexID"]);
}
return StatusCode::SUCCESS;
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXOutputCollection.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXOutputCollection.cxx
index 28646725595e66eb1d21780ce64c9ed6afcc289a..67f6d5fe8c9d1e1a17d800d74e51adcc1de8b50d 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXOutputCollection.cxx
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXOutputCollection.cxx
@@ -40,12 +40,12 @@ void LVL1::jFEXOutputCollection::clear()
}
}
-void LVL1::jFEXOutputCollection::addValue_smallRJet(std::string key, float value)
+void LVL1::jFEXOutputCollection::addValue_smallRJet(std::string key, int value)
{
m_values_tem_smallRJet.insert(std::make_pair(key, value));
}
-void LVL1::jFEXOutputCollection::addValue_largeRJet(std::string key, float value)
+void LVL1::jFEXOutputCollection::addValue_largeRJet(std::string key, int value)
{
m_values_tem_largeRJet.insert(std::make_pair(key, value));
}
@@ -57,14 +57,14 @@ void LVL1::jFEXOutputCollection::addValue_tau(std::string key, int value)
void LVL1::jFEXOutputCollection::fill_smallRJet()
{
- std::map<std::string, float>* values_local = new std::map<std::string, float>(m_values_tem_smallRJet);
+ std::map<std::string, int>* values_local = new std::map<std::string, int>(m_values_tem_smallRJet);
m_allvalues_smallRJet.push_back(values_local);
m_values_tem_smallRJet.clear();
}
void LVL1::jFEXOutputCollection::fill_largeRJet()
{
- std::map<std::string, float>* values_local = new std::map<std::string, float>(m_values_tem_largeRJet);
+ std::map<std::string, int>* values_local = new std::map<std::string, int>(m_values_tem_largeRJet);
m_allvalues_largeRJet.push_back(values_local);
m_values_tem_largeRJet.clear();
@@ -92,11 +92,11 @@ int LVL1::jFEXOutputCollection::tausize()
return m_allvalues_tau.size();
}
-std::map<std::string, float>* LVL1::jFEXOutputCollection::get_smallRJet(int location)
+std::map<std::string, int>* LVL1::jFEXOutputCollection::get_smallRJet(int location)
{
return m_allvalues_smallRJet[location];
}
-std::map<std::string, float>* LVL1::jFEXOutputCollection::get_largeRJet(int location)
+std::map<std::string, int>* LVL1::jFEXOutputCollection::get_largeRJet(int location)
{
return m_allvalues_largeRJet[location];
}
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXSmallRJetAlgo.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXSmallRJetAlgo.cxx
index 82567784d4ae2a121d56bf4f75acd8babf72e69f..420ef18c3fc60364f910b40fcb77a2f609f3bc9a 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXSmallRJetAlgo.cxx
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jFEXSmallRJetAlgo.cxx
@@ -54,11 +54,9 @@ StatusCode LVL1::jFEXSmallRJetAlgo::safetyTest(){
return StatusCode::SUCCESS;
}
-void LVL1::jFEXSmallRJetAlgo::setup(int inputTable[7][7], bool barrel_region) {
+void LVL1::jFEXSmallRJetAlgo::setup(int inputTable[7][7]) {
std::copy(&inputTable[0][0], &inputTable[0][0] + 49, &m_jFEXalgoTowerID[0][0]);
- m_barrel_region = barrel_region;
-
}
@@ -99,6 +97,7 @@ void LVL1::jFEXSmallRJetAlgo::buildSeeds()
{
m_seedSet = false;
+ m_LMDisplaced = false;
SG::ReadHandle<jTowerContainer> jk_jFEXSmallRJetAlgo_jTowerContainer(m_jFEXSmallRJetAlgo_jTowerContainerKey);
for(int mphi = 1; mphi < 6; mphi++){
@@ -110,15 +109,19 @@ void LVL1::jFEXSmallRJetAlgo::buildSeeds()
const LVL1::jTower * tmpTower = jk_jFEXSmallRJetAlgo_jTowerContainer->findTower(m_jFEXalgoTowerID[meta + ieta][mphi + iphi]);
//for that TT, build the seed
//here we sum TT ET to calculate seed
- et_tmp = tmpTower->getTotalET(); //in the fcal it already only considers the EM layer as the hcal layer 1 and 2 are considered seperate jTower Objects
+ et_tmp = tmpTower->getTotalET();
seedTotalET += et_tmp;
}
}
m_jFEXalgoSearchWindowSeedET[meta -1][mphi -1] = seedTotalET;
}
- }
-
+ }
+
+ int centralTT_ET = getTTowerET();
+ if(centralTT_ET==m_jFEXalgoSearchWindowSeedET[3][3]){
+ m_LMDisplaced = true;
+ }
m_seedSet = true;
}
@@ -127,11 +130,10 @@ void LVL1::jFEXSmallRJetAlgo::buildSeeds()
bool LVL1::jFEXSmallRJetAlgo::isSeedLocalMaxima()
{
if(m_seedSet == false) {
- //ATH_MSG_DEBUG("Local Maxima not checked due to seed not calculated.");
+ ATH_MSG_DEBUG("Local Maxima not checked due to seed not calculated.");
}
if(m_seedSet == true) {
- //ATH_MSG_DEBUG("Local Maxima checking begins.");
//here put the 24 conditions to determine if the [2][2] TT seed is a local maxima.
int central_seed = m_jFEXalgoSearchWindowSeedET[2][2];
@@ -160,6 +162,11 @@ bool LVL1::jFEXSmallRJetAlgo::isSeedLocalMaxima()
return true;
}
+bool LVL1::jFEXSmallRJetAlgo::checkDisplacedLM()
+{
+ return m_LMDisplaced;
+}
+
//in this clustering func, the central TT in jet is the parameters
unsigned int LVL1::jFEXSmallRJetAlgo::getSmallClusterET(){
@@ -203,9 +210,7 @@ std::unique_ptr<jFEXSmallRJetTOB> LVL1::jFEXSmallRJetAlgo::getSmallRJetTOBs(){
std::unique_ptr<jFEXSmallRJetTOB> tob = std::make_unique<jFEXSmallRJetTOB>();
unsigned int et = getSmallClusterET();
- // unsigned int phi = getRealPhi(phi);
- // unsigned int eta = getRealEta(eta);
-
+
tob->setET(et);
tob->setPhi(getRealPhi());
tob->setEta(getRealEta());
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jSuperCellTowerMapper.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jSuperCellTowerMapper.cxx
index 16ba2ad6a5bd96c6dd6313ecba87a4ac77b127f7..26010c51782c8a90e9485e349b22ae4962c86e06 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jSuperCellTowerMapper.cxx
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jSuperCellTowerMapper.cxx
@@ -86,10 +86,10 @@ StatusCode jSuperCellTowerMapper::AssignTriggerTowerMapper(std::unique_ptr<jTowe
int towerid = FindTowerIDForSuperCell(i_eta, i_phi) + towerID_Modifier;
LVL1::jTower * targetTower;
if((targetTower = my_jTowerContainerRaw->findTower(towerid))) {
- if (targetTower->getET_float(4, 0) > 0) {
+ if (targetTower->getET_float(1, 0) > 0) {
ATH_MSG_WARNING("\n==== jSuperCellTowerMapper ============ Hadronic layer energy filled more than once - it will be ignored. (Needs investigation). Please report this!");
}
- targetTower->setET(10, int(eachTower->cpET()) * 500., 4); // cf 0.5 * 1000.0
+ targetTower->setET(1, int(eachTower->cpET()) * 500., 4); // cf 0.5 * 1000.0
} else {
ATH_MSG_WARNING("\n==== jSuperCellTowerMapper ============ Tower ID is officially unknown - it will be ignored. (Needs investigation). Please report this!");
}
@@ -843,16 +843,19 @@ void jSuperCellTowerMapper::ConnectSuperCellToTower(std::unique_ptr<jTowerContai
case CaloSampling::FCAL0: {
if(pos_neg < 0){ towerID_Modifier = 700000; }
else if(pos_neg > 0){ towerID_Modifier = 800000; }
+ iCell = 0;
break;
}
case CaloSampling::FCAL1: {
if(pos_neg < 0){ towerID_Modifier = 900000; }
else if(pos_neg > 0){ towerID_Modifier = 1000000; }
+ iCell = 1;
break;
}
case CaloSampling::FCAL2: {
if(pos_neg < 0){ towerID_Modifier = 1100000; }
else if(pos_neg > 0){ towerID_Modifier = 1200000; }
+ iCell = 1;
break;
}
default: {
@@ -860,7 +863,7 @@ void jSuperCellTowerMapper::ConnectSuperCellToTower(std::unique_ptr<jTowerContai
}
}
- iCell = 0;
+ //iCell = 0;
layer = 0;
towereta = eta_index;
towerphi = phi_index;
diff --git a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jTowerBuilder.cxx b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jTowerBuilder.cxx
index b6bda0ad5cf1edb98329eae1b37b817de2202535..2197ebcfab022af159fe17c5f2b40a4bc22488c1 100644
--- a/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jTowerBuilder.cxx
+++ b/Trigger/TrigT1/L1CaloFEX/L1CaloFEXSim/src/jTowerBuilder.cxx
@@ -101,8 +101,8 @@ void jTowerBuilder::BuildTRANSjTowers(std::unique_ptr<jTowerContainer> & jTowerC
void jTowerBuilder::BuildEMEjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const
{
-static constexpr float TT_Size = M_PI/32;
- // Region 1
+ static constexpr float TT_Size = M_PI/32;
+ // Region 1
int EME_MODIFIER = 15;
int tmpVal = EME_MODIFIER;
@@ -162,7 +162,7 @@ static constexpr float TT_Size = M_PI/32;
// EMIE = Electromagnetic Inner ECAL - i.e. the forward ECAL region at high eta
void jTowerBuilder::BuildEMIEjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const
{
-static constexpr float TT_Size = M_PI/32;
+ static constexpr float TT_Size = M_PI/32;
int EMIE_MODIFIER = 25;
int tmpVal = EMIE_MODIFIER;
int cellCountEta = 0;
@@ -195,7 +195,7 @@ static constexpr float TT_Size = M_PI/32;
void jTowerBuilder::BuildFCALjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const
{
-static constexpr float TT_Size = M_PI/32;
+ static constexpr float TT_Size = M_PI/32;
int FCAL_MODIFIER = 29; // there's 0.1 overlap with EMIE here in eta, but in counting we pretend it's the next one along.
int tmpVal = FCAL_MODIFIER;
@@ -272,7 +272,6 @@ static constexpr float TT_Size = M_PI/32;
void jTowerBuilder::BuildHECjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const
{
-
// Region 0
int HEC_MODIFIER = 29;
int tmpVal = HEC_MODIFIER;
@@ -315,7 +314,7 @@ static constexpr float TT_Size = M_PI/32;
void jTowerBuilder::BuildAllTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const
{
- BuildSingleTower(jTowerContainerRaw, 0.0, 0.0, 0, -1.0, 0, 0.0, 0.0, 0);
+// BuildSingleTower(jTowerContainerRaw, 0.0, 0.0, 0, -1.0, 0, 0.0, 0.0, 0);
BuildEMBjTowers(jTowerContainerRaw);
BuildTRANSjTowers(jTowerContainerRaw);
BuildEMEjTowers(jTowerContainerRaw);
diff --git a/Trigger/TrigT1/L1CaloFEXToolInterfaces/L1CaloFEXToolInterfaces/IjFEXForwardJetsAlgo.h b/Trigger/TrigT1/L1CaloFEXToolInterfaces/L1CaloFEXToolInterfaces/IjFEXForwardJetsAlgo.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a5b7bbcb7b1eaabf47a2e736d8aced1c106d297
--- /dev/null
+++ b/Trigger/TrigT1/L1CaloFEXToolInterfaces/L1CaloFEXToolInterfaces/IjFEXForwardJetsAlgo.h
@@ -0,0 +1,51 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+//***************************************************************************
+// Interface for jFEXForwardJetsAlgo - Algorithm for forward Jets in jFEX
+// -------------------
+// begin : 07 06 2021
+// email : varsiha.sothilingam@cern.ch
+//***************************************************************************
+
+#ifndef IjFEXFORWARDJETSALGO_H
+#define IjFEXFORWARDJETSALGO_H
+
+#include "GaudiKernel/IAlgTool.h"
+//#include "L1CaloFEXSim/jFEXForwardJetsAlgo.h"
+#include "L1CaloFEXSim/jFEXForwardJetsInfo.h"
+#include "L1CaloFEXSim/jTowerContainer.h"
+#include "L1CaloFEXSim/FEXAlgoSpaceDefs.h"
+
+namespace LVL1{
+
+ static const InterfaceID IID_IjFEXForwardJetsAlgo("LVL1::IjFEXForwardJetsAlgo",1, 0);
+
+ class IjFEXForwardJetsAlgo : virtual public IAlgTool{
+ public:
+ static const InterfaceID& interfaceID ( ) ;
+ virtual StatusCode safetyTest() = 0;
+ virtual void setup(int inputTable[FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width]) = 0;
+// virtual float testfakePhi() =0;
+
+ virtual float globalPhi(int , int ) =0;
+ virtual float globalEta(int , int ) =0;
+ virtual unsigned int localPhi(int , int ) =0;
+ virtual unsigned int localEta(int , int ) =0;
+ virtual unsigned int getTTowerET(int, int) =0;
+
+ virtual std::map<int, jFEXForwardJetsInfo> FcalJetsTowerIDLists() =0;
+ virtual std::map<int, jFEXForwardJetsInfo> isSeedLocalMaxima() =0;
+ virtual std::map<int, jFEXForwardJetsInfo> calculateJetETs() =0;
+
+ private:
+
+ };
+
+ inline const InterfaceID& LVL1::IjFEXForwardJetsAlgo::interfaceID()
+ {
+ return IID_IjFEXForwardJetsAlgo;
+ }
+}
+#endif
+
diff --git a/Trigger/TrigT1/L1CaloFEXToolInterfaces/L1CaloFEXToolInterfaces/IjFEXSmallRJetAlgo.h b/Trigger/TrigT1/L1CaloFEXToolInterfaces/L1CaloFEXToolInterfaces/IjFEXSmallRJetAlgo.h
index fcb7db7d6d4e66b93309d638f54a189a586424f1..c928ee5d18e0a1bcd3c8846b0836d9d034840bb3 100644
--- a/Trigger/TrigT1/L1CaloFEXToolInterfaces/L1CaloFEXToolInterfaces/IjFEXSmallRJetAlgo.h
+++ b/Trigger/TrigT1/L1CaloFEXToolInterfaces/L1CaloFEXToolInterfaces/IjFEXSmallRJetAlgo.h
@@ -23,7 +23,7 @@ namespace LVL1{
public:
static const InterfaceID& interfaceID ( ) ;
virtual StatusCode safetyTest() = 0;
- virtual void setup(int inputTable[7][7], bool barrel_region) = 0;
+ virtual void setup(int inputTable[7][7]) = 0;
virtual int realValue(int ID, int eta) =0;
virtual bool isSeedLocalMaxima() = 0;
virtual void buildSeeds() = 0;
@@ -32,6 +32,7 @@ namespace LVL1{
virtual unsigned int getTTowerET() = 0;
virtual unsigned int getSmallClusterET() =0;
virtual unsigned int getSmallETRing() =0;
+ virtual bool checkDisplacedLM() = 0;
virtual std::unique_ptr<jFEXSmallRJetTOB> getSmallRJetTOBs() = 0;
private: