CrateEnergy.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
/***************************************************************************
                          CrateEnergy.h  -  description
                             -------------------
    begin                : 06/09/2007
    email                : Alan.Watson@cern.ch
 ***************************************************************************/
 
 
#include "TrigT1CaloUtils/CrateEnergy.h"
 
namespace LVL1 {
 
CrateEnergy::CrateEnergy(unsigned int crate, const DataVector<ModuleEnergy>* JEMs, uint32_t maskXE, uint32_t maskTE, bool restricted):
  m_crate(crate),
  m_crateEt(0),
  m_crateEx(0),
  m_crateEy(0),
  m_overflowT(0),
  m_overflowX(0),
  m_overflowY(0),
  m_restricted(restricted),
  m_debug(false)
  {
  if (m_crate > 1) return;
 
  if ((maskXE&0xff) != 0xff || (maskTE&0xff) != 0xff) m_restricted = true;
 
  unsigned int eT[2] = {0,0};
  unsigned int eX[2] = {0,0};
  unsigned int eY[2] = {0,0};
  for ( const ModuleEnergy* jem : *JEMs ) {
    int moduleInQuad = jem->module() % 8;
    if (jem->crate() == m_crate) {
      int quad = ( jem->module() < 8 ? 0 : 1 );
      if ((maskTE>>moduleInQuad)&1) {
        eT[quad] += jem->et();
        if ( jem->et() >= m_jemEtSaturation ) m_overflowT = 1;
      }
      if ((maskXE>>moduleInQuad)&1) {
        eX[quad] += jem->ex();
        eY[quad] += jem->ey();
        if ( jem->ex() >= m_jemEtSaturation ) m_overflowX = 1;
        if ( jem->ey() >= m_jemEtSaturation ) m_overflowY = 1;
      } 
    }  // Right crate?
  }   // Loop over JEMs
  
  unsigned int mask = (1 << m_sumBits) - 1;
 
  m_crateEt = eT[0] + eT[1];
  if (m_crateEt >= mask){
    m_overflowT = 1;
    m_crateEt = mask;
  }
 
 
  if (!m_overflowX){
    m_crateEx = eX[0] - eX[1];
  } else{
    m_crateEx = -(mask + 1);
  }
  if (!m_overflowY){
    m_crateEy = eY[0] - eY[1];
  }else{
    m_crateEy = -(mask + 1);
  }
  
 
  if (m_debug) {
    std::cout << "CrateEnergy: crate " << m_crate << " results " << std::endl
              << "   Et "  << m_crateEt << " overflow " << m_overflowT << std::endl
              << "   Ex "  << m_crateEx << " overflow " << m_overflowX << std::endl
              << "   Ey "  << m_crateEy << " overflow " << m_overflowY << std::endl;
              
  }
  
}
 
CrateEnergy::CrateEnergy(unsigned int crate, const DataVector<EnergyCMXData>* JEMs, uint32_t maskXE, uint32_t maskTE, bool restricted):
  m_crate(crate),
  m_crateEt(0),
  m_crateEx(0),
  m_crateEy(0),
  m_overflowT(0),
  m_overflowX(0),
  m_overflowY(0),
  m_restricted(restricted),
  m_debug(false)
  {
  if (m_crate > 1) return;
 
  if ((maskXE&0xff) != 0xff || (maskTE&0xff) != 0xff) m_restricted = true;
 
  unsigned int eT[2] = {0,0};
  unsigned int eX[2] = {0,0};
  unsigned int eY[2] = {0,0};
  for ( const EnergyCMXData* jem : *JEMs ) {
    int moduleInQuad = jem->module() % 8;
    if ((unsigned int)jem->crate() == m_crate) {
      int quad = ( jem->module() < 8 ? 0 : 1 );
 
      if ((maskTE>>moduleInQuad)&1) {
        eT[quad] += jem->Et();
        if ( jem->Et() >= m_jemEtSaturation ) m_overflowT = 1;
      }
      if ((maskXE>>moduleInQuad)&1) {
        eX[quad] += jem->Ex();
        eY[quad] += jem->Ey();
        if ( jem->Ex() >= m_jemEtSaturation ) m_overflowX = 1;
        if ( jem->Ey() >= m_jemEtSaturation ) m_overflowY = 1;
      } 
    }
  }
  
  unsigned int mask = (1<<m_sumBits) - 1;
 
 
  m_crateEt = eT[0] + eT[1];
  if (m_crateEt >= mask){
    m_overflowT = 1;
    m_crateEt = mask;
  }
 
  if (!m_overflowX){
    m_crateEx = eX[0] - eX[1];
  } else{
    m_crateEx = -(mask + 1);
  }
  if (!m_overflowY){
    m_crateEy = eY[0] - eY[1];
  }else{
    m_crateEy = -(mask + 1);
  }
 
  if (m_debug) {
    std::cout << "CrateEnergy: crate " << m_crate << " results " << std::endl
              << "   Et "  << m_crateEt << " overflow " << m_overflowT << std::endl
              << "   Ex "  << m_crateEx << " overflow " << m_overflowX << std::endl
              << "   Ey "  << m_crateEy << " overflow " << m_overflowY << std::endl;
              
  }
  
}
 
CrateEnergy::CrateEnergy(unsigned int crate, unsigned int et, unsigned int exTC,
             unsigned int eyTC, unsigned int overflowT, unsigned int overflowX,
         unsigned int overflowY, bool restricted) :
  m_crate(crate),
  m_crateEt(0),
  m_crateEx(0),
  m_crateEy(0),
  m_overflowT(0),
  m_overflowX(0),
  m_overflowY(0),
  m_restricted(restricted),
  m_debug(false)
{
  if (m_crate > 1) return;
  m_crateEt = et;
  m_crateEx = decodeTC(exTC);
  m_crateEy = decodeTC(eyTC);
  m_overflowT = overflowT;
  m_overflowX = overflowX;
  m_overflowY = overflowY;
 
  if (m_debug) {
    std::cout << "CrateEnergy: crate " << m_crate << " results " << std::endl
              << "   Et "  << m_crateEt << " overflow " << m_overflowT << std::endl
              << "   Ex "  << m_crateEx << " overflow " << m_overflowX << std::endl
              << "   Ey "  << m_crateEy << " overflow " << m_overflowY << std::endl;
              
  }
}
 
 
CrateEnergy::~CrateEnergy(){
}
 
unsigned int CrateEnergy::crate() const {
  return m_crate;
}
 
int CrateEnergy::et() const {
  return m_crateEt;
}
 
int CrateEnergy::ex() const {
  return m_crateEx;
}
 
int CrateEnergy::ey() const {
  return m_crateEy;
}
 
unsigned int CrateEnergy::etOverflow() const {
  return m_overflowT;
}
 
unsigned int CrateEnergy::exOverflow() const {
  return m_overflowX;
}
 
unsigned int CrateEnergy::eyOverflow() const {
  return m_overflowY;
}
 
bool CrateEnergy::restricted() const {
  return m_restricted;
}
 
unsigned int CrateEnergy::exTC() const {
  return encodeTC(m_crateEx);
}
 
unsigned int CrateEnergy::eyTC() const {
  return encodeTC(m_crateEy);
}
 
unsigned int CrateEnergy::encodeTC(int input) const {
  unsigned int value;
 
  if (input > 0) {
    value = input;
  }
  else {
    value = (1<<m_sumBitsTC) + input;
  }
 
  int mask = (1<<m_sumBitsTC) - 1;
  return value&mask ;
}
 
int CrateEnergy::decodeTC(unsigned int input) const {
 
  int mask = (1<<m_sumBitsTC) - 1;
  int value = input&mask;
 
  if ((value >> (m_sumBitsTC - 1))) {
    value += (~0U) << m_sumBitsTC;
  }
 
  return value;
}
} // end of ns