ModuleEnergy.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
/***************************************************************************
                          ModuleEnergy.cxx  -  description
                             -------------------
    begin                : Tues Sep 4 2007
                           Loosely based on Ed Moyse's JetEnergyModule
    email                : Alan.Watson@cern.ch
 ***************************************************************************/
 
#include "TrigT1CaloUtils/ModuleEnergy.h"
#include "TrigT1CaloUtils/QuadLinear.h"
 
#include <math.h>
 
namespace LVL1 {
 
ModuleEnergy::ModuleEnergy(const xAOD::JetElementMap_t* JEContainer, unsigned int crate,
                           unsigned int module, int JEThresholdEtSum, int JEThresholdEtMiss, const std::map<int, int>* TEMasks, int slice):
  m_jetElementThresholdEtSum(JEThresholdEtSum),
  m_jetElementThresholdEtMiss(JEThresholdEtMiss),
  m_Et(0),
  m_Ex(0),
  m_Ey(0),
  m_signX(1),
  m_signY(1),
  m_crate(crate),
  m_module(module),
  m_debug(false)
{
  // Only fill ModuleEnergys where crate, module numbers valid
  if (m_debug) std::cout << "Create ModuleEnergy for crate "
                         << crate << " module " << module << std::endl;
  if (m_crate <= 1 && m_module <= 15) {
    m_signY = ( (module < 8) ? 1 : -1 );
    m_signX = ( (crate == 0) ? m_signY : -m_signY );
    bool saturated = false;
    JetEnergyModuleKey get;
    std::vector<unsigned int> keys = get.jeKeys(crate, module);
    for (unsigned int k : keys) {
      xAOD::JetElementMap_t::const_iterator test=JEContainer->find(k);
      if (test != JEContainer->end()) {
    double eta = test->second->eta();
    int ieta = int((eta + (eta>0 ? 0.005 : -0.005))/0.1);
    if (TEMasks == 0 || TEMasks->find(ieta) == TEMasks->end()) {
          if (test->second->isSaturated()) {
        saturated = true;
          }
          else {
            int jetElementET;
            if (slice < 0) jetElementET = test->second->et();
            else           jetElementET = test->second->sliceET(slice);
            if (jetElementET > m_jetElementThresholdEtMiss) {
              double phi = test->second->phi();
              int cosPhi = 0;
              int sinPhi = 0;
              getSinCos(eta,phi,cosPhi,sinPhi);
              unsigned int EnergyX = ((jetElementET*cosPhi) & 0x7ffffc00);
              unsigned int EnergyY = ((jetElementET*sinPhi) & 0x7ffffc00);
              m_Ex += EnergyX;
              m_Ey += EnergyY;
              if (m_debug) std::cout << "JE phi = " << phi << ", ET = " << jetElementET
                                   << ", Ex = " << (EnergyX>>10) << ", Ey = " << (EnergyY>>10) << std::endl;
            }
            if ( jetElementET > m_jetElementThresholdEtSum )
               m_Et += jetElementET;
          } // End of processing of unsaturated jetElement
        } // End processing of unvetoed element
      } // End check for end of container
    } // End loop through keys

    m_Ex = m_Ex>>12;
    m_Ey = m_Ey>>12;
    
    if (saturated || (m_Ex > (1<<m_EtBits)-1)) m_Ex = (1<<m_EtBits)-1;
    if (saturated || (m_Ey > (1<<m_EtBits)-1)) m_Ey = (1<<m_EtBits)-1;
    if (saturated || (m_Et > (1<<m_EtBits)-1)) m_Et = (1<<m_EtBits)-1;
 
    if (m_debug) {
      std::cout << "Crate " << crate << " Module " << module <<
                   " sums: " << std::endl;
      std::cout << "  Ex = " << static_cast<int>(m_Ex)*m_signX << std::endl; 
      std::cout << "  Ey = " << static_cast<int>(m_Ey)*m_signY << std::endl;
      std::cout << "  Et = " << m_Et << std::endl;
    }
  }
}
 
ModuleEnergy::ModuleEnergy(unsigned int crate, unsigned int module,
                           unsigned int et, unsigned int ex,
               unsigned int ey) :
  m_jetElementThresholdEtSum(0),
  m_jetElementThresholdEtMiss(0),
  m_Et(et),
  m_Ex(ex),
  m_Ey(ey),
  m_signX(1),
  m_signY(1),
  m_crate(crate),
  m_module(module),
  m_debug(false)
{
  // Only fill ModuleEnergys where crate, module numbers valid
  if (m_debug) std::cout << "Create ModuleEnergy for crate "
                         << crate << " module " << module << std::endl;
  if (m_crate <= 1 && m_module <= 15) {
    m_signY = ( (module < 8) ? 1 : -1 );
    m_signX = ( (crate == 0) ? m_signY : -m_signY );
    
    if (m_Ex > (1<<m_EtBits)-1) m_Ex = (1<<m_EtBits)-1;
    if (m_Ey > (1<<m_EtBits)-1) m_Ey = (1<<m_EtBits)-1;
    if (m_Et > (1<<m_EtBits)-1) m_Et = (1<<m_EtBits)-1;
    
    if (m_debug) {
      std::cout << "Crate " << crate << " Module " << module <<
                   " sums: " << std::endl;
      std::cout << "  Ex = " << static_cast<int>(m_Ex)*m_signX << std::endl; 
      std::cout << "  Ey = " << static_cast<int>(m_Ey)*m_signY << std::endl;
      std::cout << "  Et = " << m_Et << std::endl;
    }
  }
}
 
 
ModuleEnergy::~ModuleEnergy(){
}

unsigned int ModuleEnergy::crate() const {
  return m_crate;
}

unsigned int ModuleEnergy::module() const {
  return m_module;
}

unsigned int ModuleEnergy::et() const {
  return m_Et;
}
unsigned int ModuleEnergy::ex() const {
  return m_Ex;
}
unsigned int ModuleEnergy::ey() const {
  return m_Ey;
}

int ModuleEnergy::signX() const {
  return m_signX;
}
int ModuleEnergy::signY() const {
  return m_signY;
}

void ModuleEnergy::getSinCos(double eta, double phi, int& cosPhi, int& sinPhi) {
    
  unsigned int SinCos[8]    = {401,1187,1928,2594,3161,3607,3913,4070};
  unsigned int fwdSinCos[4] = {794,2261,3384,3992};

  float modPhi = fmod(phi, M_PI/2.);

  if (fabs(eta) < 3.2) {
    int phiBin = (int)(modPhi*16/M_PI);
    if (m_crate > 0) {                  
       cosPhi = SinCos[phiBin];
       sinPhi = SinCos[7-phiBin];
    }
    else {                              
       cosPhi = SinCos[7-phiBin];
       sinPhi = SinCos[phiBin];
    }
  }
  else {
    int phiBin = (int)(modPhi*8/M_PI);
    if (m_crate > 0) {
       cosPhi = fwdSinCos[phiBin];
       sinPhi = fwdSinCos[3-phiBin];
    }
    else {
       cosPhi = fwdSinCos[3-phiBin];
       sinPhi = fwdSinCos[phiBin];
    }
  }
 
} // end of getSinCos
 
} // end of namespace bracket