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"
#include <iostream>
 
 
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
  
  const unsigned int mask = (1U << m_sumBits) - 1U;
  const int overflowValue = -static_cast<int>(mask + 1U);
  m_crateEt = eT[0] + eT[1];
  if (m_crateEt >= mask){
    m_overflowT = 1;
    m_crateEt = mask;
  }
 
 
  if (!m_overflowX) {
    m_crateEx = static_cast<int>(eX[0]) - static_cast<int>(eX[1]);
  } else {
    m_crateEx = overflowValue;
  }
 
  if (!m_overflowY) {
    m_crateEy = static_cast<int>(eY[0]) - static_cast<int>(eY[1]);
  } else {
    m_crateEy = overflowValue;
  }
  
 
  if (m_debug) {
    std::cout << "CrateEnergy: crate " << m_crate << " results " 
              << "\n   Et "  << m_crateEt << " overflow " << m_overflowT 
              << "\n   Ex "  << m_crateEx << " overflow " << m_overflowX 
              << "\n   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 " 
              << "\n   Et "  << m_crateEt << " overflow " << m_overflowT 
              << "\n   Ex "  << m_crateEx << " overflow " << m_overflowX 
              << "\n   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 " 
              << "\n   Et "  << m_crateEt << " overflow " << m_overflowT 
              << "\n   Ex "  << m_crateEx << " overflow " << m_overflowX 
              << "\n   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