JetElement.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
/***************************************************************************
                          JetElement.cpp  -  description
                             -------------------
    begin                : Mon Sep 25 2000
    email                : e.moyse@qmw.ac.uk
 ***************************************************************************/
 
 
 
 
#ifndef  TRIGGERSPACE
#include "TrigT1CaloEvent/JetElement.h"
#else
#include "JetElement.h"
#endif
 
 
namespace LVL1 {
 
JetElement::JetElement():
  m_phi(0.0),
  m_eta(0.0),
  m_key(0),
  m_peak(0),
  m_emEnergy(1),
  m_hadEnergy(1),
  m_em_error(1),
  m_had_error(1),
  m_link_error(1)
{   
}
 
JetElement::JetElement(double phi, double eta,
                       int emEnergy, int hadEnergy, unsigned int key, 
                       int emError, int hadError, int linkError):
  m_phi(phi),
  m_eta(eta),
  m_key(key),
  m_peak(0),
  m_emEnergy(1,emEnergy),
  m_hadEnergy(1,hadEnergy),
  m_em_error(1,emError),
  m_had_error(1,hadError),
  m_link_error(1,linkError)
{
}
 
JetElement::JetElement(double phi, double eta,
                       const std::vector<int>& emEnergy,
                   const std::vector<int>& hadEnergy,
               unsigned int key,
               const std::vector<int>& emError,
               const std::vector<int>& hadError,
               const std::vector<int>& linkError, int peak):
  m_phi(phi),
  m_eta(eta),
  m_key(key),
  m_peak(peak),
  m_emEnergy(emEnergy),
  m_hadEnergy(hadEnergy),
  m_em_error(emError),
  m_had_error(hadError),
  m_link_error(linkError)
{
}
 
JetElement::~JetElement(){
}
 
 
double JetElement::eta() const{
    return m_eta;
}
 
double JetElement::phi() const{
    return m_phi;
}
 
int JetElement::emEnergy() const{
  if (m_emEnergy[m_peak] < m_layerSaturationThreshold) {
    return m_emEnergy[m_peak];
  }
  else {
    return m_layerSaturationThreshold;
  }
}
 
int JetElement::hadEnergy() const{
  if (m_hadEnergy[m_peak] < m_layerSaturationThreshold) {
    return m_hadEnergy[m_peak];
  }
  else {
    return m_layerSaturationThreshold;
  }
}
 
int JetElement::energy() const{
  if ( (m_emEnergy[m_peak]  >= m_layerSaturationThreshold) ||
       (m_hadEnergy[m_peak] >= m_layerSaturationThreshold) ||
       (m_emEnergy[m_peak] + m_hadEnergy[m_peak] >= m_saturationThreshold) ){
    return m_saturationThreshold;
  }else{
    return m_emEnergy[m_peak] + m_hadEnergy[m_peak];
  }
}
 
int JetElement::emSliceEnergy(int slice) const{
  if (slice >=0 && slice < (int)m_emEnergy.size()) {
    if (m_emEnergy[slice] < m_layerSaturationThreshold) {
      return m_emEnergy[slice];
    }
    else {
      return m_layerSaturationThreshold;
    }
  }
  else return 0;
}
 
int JetElement::hadSliceEnergy(int slice) const{
  if (slice >=0 && slice < (int)m_hadEnergy.size()) {
    if (m_hadEnergy[slice] < m_layerSaturationThreshold) {
      return m_hadEnergy[slice];
    }
    else {
      return m_layerSaturationThreshold;
    }
  }
  else return 0;
}
 
int JetElement::sliceEnergy(int slice) const{
  if ( (emSliceEnergy(slice)  >= m_layerSaturationThreshold) ||
       (hadSliceEnergy(slice) >= m_layerSaturationThreshold) ||
       (emSliceEnergy(slice) + hadSliceEnergy(slice) >= m_saturationThreshold) ){
    return m_saturationThreshold;
  }
  else{
    return emSliceEnergy(slice) + hadSliceEnergy(slice);
  }
}
 
void JetElement::addEnergy(int emEnergy, int hadEnergy){
  m_emEnergy[m_peak]  += emEnergy;
  if (m_emEnergy[m_peak] > m_layerSaturationThreshold) 
      m_emEnergy[m_peak] = m_layerSaturationThreshold;
  m_hadEnergy[m_peak] += hadEnergy;
  if (m_hadEnergy[m_peak] > m_layerSaturationThreshold)
      m_hadEnergy[m_peak] = m_layerSaturationThreshold;
  return;
}
 
void JetElement::addSlice(int slice, int emEnergy, int hadEnergy,
                          int emError, int hadError, int linkError){
  m_emEnergy[slice]   = 
   ((emEnergy < m_layerSaturationThreshold) ? emEnergy : m_layerSaturationThreshold);
  m_hadEnergy[slice]  = 
   ((hadEnergy < m_layerSaturationThreshold) ? hadEnergy : m_layerSaturationThreshold);
  m_em_error[slice]   = emError;
  m_had_error[slice]  = hadError;
  m_link_error[slice] = linkError;
  return;
}
 
unsigned int JetElement::key() const{
  return m_key;
}
 
bool JetElement::isSaturated() const{
  if ( (m_emEnergy[m_peak] >= m_layerSaturationThreshold) ||
       (m_hadEnergy[m_peak] >= m_layerSaturationThreshold) ||
       (m_emEnergy[m_peak] + m_hadEnergy[m_peak] >= m_saturationThreshold) ){
    return true;
  }else{
    return false;
  }
}
 
 
bool JetElement::isEmSaturated() const{
  if ( m_emEnergy[m_peak] >= m_layerSaturationThreshold ){
    return true;
  }else{
    return false;
  }
}
 
bool JetElement::isHadSaturated() const{
  if ( m_hadEnergy[m_peak] >= m_layerSaturationThreshold ){
    return true;
  }else{
    return false;
  }
}
 
int JetElement::emError() const{
  return m_em_error[m_peak];
}
 
int JetElement::hadError() const{
  return m_had_error[m_peak];
}
 
int JetElement::linkError() const{
  return m_link_error[m_peak];
}
 
int JetElement::peak() const{
  return m_peak;
}
 
const std::vector<int>& JetElement::emEnergyVec() const{
  return m_emEnergy;
}
 
const std::vector<int>& JetElement::hadEnergyVec() const{
  return m_hadEnergy;
}
 
const std::vector<int>& JetElement::emErrorVec() const{
  return m_em_error;
}
 
const std::vector<int>& JetElement::hadErrorVec() const{
  return m_had_error;
}
 
const std::vector<int>& JetElement::linkErrorVec() const{
  return m_link_error;
}
 
Coordinate JetElement::coord() const{
  return Coordinate(m_phi,m_eta);
}
 
}// end of LVL1 namespace