gTowerMakerFromGfexTowers.cxx

Go to the documentation of this file.

/*
    Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
//***************************************************************************
//                           gTowerMakerFromGfexTowers  -  description
//                     ---------------------------------------------------------
//      This algorithm is meant to create from the xAOD::gFexTowerContainer (EDM) a gTowerContainer (a SG object the gFEX simulation needs)
//      It needs to get both inputs available:
//          * Decoded gFex input data, known as L1_gFexDataTowers
//          * Emulated gFex input data, known as L1_gFexEmulatedTowers (to be confirmed if this is the name in gFex)
//      
//     begin                : 14 07 2023
//     email                : cecilia.tosciri@cern.ch
//     
//***************************************************************************/
 
#include "xAODTrigL1Calo/gFexTowerContainer.h"
 
#include "L1CaloFEXSim/gTower.h"
#include "gTowerBuilder.h"
#include "L1CaloFEXSim/gTowerContainer.h"
#include "gTowerMakerFromGfexTowers.h"
#include "L1CaloFEXSim/gFEXCompression.h"
 
#include "StoreGate/WriteHandle.h"
#include "StoreGate/ReadHandle.h"
 
 
namespace LVL1 {
    
gTowerMakerFromGfexTowers::gTowerMakerFromGfexTowers(const std::string& name, ISvcLocator* pSvcLocator)
    :  AthReentrantAlgorithm(name, pSvcLocator)
{}
 
 
StatusCode gTowerMakerFromGfexTowers::initialize()
{
    ATH_CHECK( m_gDataTowerKey.initialize() );
    ATH_CHECK( m_gSuperCellTowerMapperTool.retrieve() );
    ATH_CHECK( m_gTowerBuilderTool.retrieve() );
    ATH_CHECK( m_gTowerContainerSGKey.initialize() );
 
    return StatusCode::SUCCESS;
 
}
 
 
StatusCode gTowerMakerFromGfexTowers::execute(const EventContext& ctx) const
{
    ATH_MSG_DEBUG("Executing " << name() << ", input: " << m_gDataTowerKey.key() << ", output: " << m_gTowerContainerSGKey.key());
 
    //Reading the decoded Data gTower container
    SG::ReadHandle<xAOD::gFexTowerContainer> gDataTowerContainer = SG::ReadHandle<xAOD::gFexTowerContainer>(m_gDataTowerKey, ctx);
    if(!gDataTowerContainer.isValid()) {
        ATH_MSG_FATAL("Could not retrieve collection " << gDataTowerContainer.key() );
        return StatusCode::FAILURE;
    }      
 
    // STEP 0 - Make a fresh local gTowerContainer
    std::unique_ptr<gTowerContainer> local_gTowerContainerRaw = std::make_unique<gTowerContainer>();
 
    // STEP 1 - Make some gTowers and fill the local container (This is the one the simulation reads)
    m_gTowerBuilderTool->BuildAllTowers(local_gTowerContainerRaw);
    
    // STEP 2 - Mapping gFexTowers with decoded Energies
    if( !gDataTowerContainer->empty() ) {
        
        ATH_MSG_DEBUG("Collection used to build the gTower for simulation: " << gDataTowerContainer.key() << " with size: "<< gDataTowerContainer->size() << ". Expected towers 1152");
 
        for(const xAOD::gFexTower* my_gTower : *gDataTowerContainer) {
 
            unsigned int TTID = my_gTower->gFEXtowerID(); //This is the simulation tower ID
 
            // Find the simulation ID from this firmware ID
            int ID = local_gTowerContainerRaw->getIDfromFWID(TTID);
            if (ID == -1) {
                ATH_MSG_WARNING("Cannot find simulation ID from firmware ID - This gFexTower will be ignored. (Needs investigation).  Please report this!" );
                continue;
            }
 
            LVL1::gTower *targetTower;
            if( (targetTower = local_gTowerContainerRaw->findTower(ID)) ) {
 
                targetTower->setTotalEt(my_gTower->towerEt());
                targetTower->setIsSaturated(my_gTower->isSaturated());
                
            }
            else {
                ATH_MSG_WARNING("Tower ID is officially unknown - it will be ignored. (Needs investigation).  Please report this!" );
                continue;
            }
        }
    }
    else{
        ATH_MSG_DEBUG("Falling into the legacy path");
        ATH_CHECK(m_gSuperCellTowerMapperTool->AssignSuperCellsToTowers(local_gTowerContainerRaw));
        ATH_CHECK(m_gSuperCellTowerMapperTool->AssignTriggerTowerMapper(local_gTowerContainerRaw));        
    }
 
    // STEP 3 - Write the completed gTowerContainer into StoreGate (move the local copy in memory)
    SG::WriteHandle<LVL1::gTowerContainer> gTowerContainerSG(m_gTowerContainerSGKey, ctx);
    ATH_CHECK(gTowerContainerSG.record(std::move( local_gTowerContainerRaw ) ) );
 
    return StatusCode::SUCCESS;
}
 
 
} // end of LVL1 namespace