CaloNeighbourRegion Class Reference

#include <CaloNeighbours.h>

Collaboration diagram for CaloNeighbourRegion:

Public Types
enum	{   SIDE = 2 , SAMPL = 3 , REGION = 4 , ETA = 5 ,   PHI = 6 , TILESECTION = 1 , TILEPHI = 3 , TILEETA = 4 ,   TILESAMPL = 5 , FCALETA = 4 , FCALPHI = 5 }

Public Member Functions
	CaloNeighbourRegion (const std::string &name, const CaloCell_Base_ID *theCaloId)
virtual	~CaloNeighbourRegion ()
void	setType (const NEIGHBOURTYPE type)
void	setSourceRange (const Range &theRange)
void	setTargetRange (const Range &theRange)
void	setSide (const int side1, const int side2)
void	setPhi (const int phi1, const int phi2)
int	setNeighbours (ExpandedIdentifier &id1, std::vector< ExpandedIdentifier > &id2, std::map< IdentifierHash, std::vector< IdentifierHash >, ltIdHash > &neighbourMapPlus, std::map< IdentifierHash, std::vector< IdentifierHash >, ltIdHash > &neighbourMapMinus)
void	initializeVectors (std::map< IdentifierHash, std::vector< IdentifierHash >, ltIdHash > &neighbourMapPlus, std::map< IdentifierHash, std::vector< IdentifierHash >, ltIdHash > &neighbourMapMinus)
int	getNeighbours (const IdentifierHash caloHash, std::vector< IdentifierHash > &neighbourList) const
NEIGHBOURTYPE	getType () const
const std::string &	getName () const

Private Member Functions
int	getId (ExpandedIdentifier &id, Identifier &rID, const Range &theRange, const int side=+1, const int dphi=0) const

Private Attributes
std::string	m_name
NEIGHBOURTYPE	m_type
const CaloCell_Base_ID *	m_calo_id
Range	m_sourceRange
Range	m_targetRange
bool	m_hasPhi
int	m_iPhiSource
int	m_iPhiTarget
bool	m_hasSide
int	m_iSideSource
int	m_iSideTarget
bool	m_isValidMinus
bool	m_isValidPlus
IdentifierHash	m_minHashMinus
IdentifierHash	m_maxHashMinus
IdentifierHash	m_minHashPlus
IdentifierHash	m_maxHashPlus
std::vector< std::unique_ptr< std::vector< IdentifierHash > > >	m_neighbours_plus
std::vector< std::unique_ptr< std::vector< IdentifierHash > > >	m_neighbours_minus

Detailed Description

Definition at line 40 of file CaloNeighbours.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
SIDE
SAMPL
REGION
ETA
PHI
TILESECTION
TILEPHI
TILEETA
TILESAMPL
FCALETA
FCALPHI

Definition at line 43 of file CaloNeighbours.h.

{SIDE = 2, SAMPL = 3, REGION = 4, ETA = 5, PHI = 6, TILESECTION = 1, TILEPHI = 3, TILEETA = 4, TILESAMPL = 5, FCALETA = 4, FCALPHI = 5};

Constructor & Destructor Documentation

CaloNeighbourRegion()

CaloNeighbourRegion::CaloNeighbourRegion	(	const std::string &	name,
		const CaloCell_Base_ID *	theCaloId )

Definition at line 40 of file CaloNeighbours.cxx.

                                                                            :
  m_name(name),
  m_type(nextInCalo),
  m_calo_id(theCaloId),
  m_hasPhi(false),
  m_iPhiSource(0),
  m_iPhiTarget(0),
  m_hasSide(false),
  m_iSideSource(0),
  m_iSideTarget(0),
  m_isValidMinus(false),
  m_isValidPlus(false)
{
}

~CaloNeighbourRegion()

CaloNeighbourRegion::~CaloNeighbourRegion ( )

virtualdefault

Member Function Documentation

getId()

int CaloNeighbourRegion::getId ( ExpandedIdentifier & id, Identifier & rID, const Range & theRange, const int side = +1, const int dphi = 0 ) const

private

Definition at line 109 of file CaloNeighbours.cxx.

{
  // modify id for side and phi
  //  ExpandedIdentifier id(oid);
  if ( m_hasSide && side != 1 )
    id[SIDE] = side*id[SIDE];
  if ( m_hasPhi && dphi != 0 ) {
    if ( m_calo_id->is_lar_em(id) || m_calo_id->is_lar_hec(id) )
      id[PHI] = id[PHI]+dphi;
    else if ( m_calo_id->is_lar_fcal(id) )
      id[FCALPHI] = id[FCALPHI]+dphi;
    else 
      id[TILEPHI] = id[TILEPHI]+dphi;
  }
 
  // first check if id is in the specified range
  if ( !theRange.match(id) ) {
    std::cout << "CaloNeighbours::set_neighbours ERROR: " << (std::string)id << " is not within the Range " << (std::string)theRange << std::endl;
    return 1;
  }
 
  CaloCell_ID::SUBCALO subCalo;
  if ( m_calo_id->is_lar_em(id) ) {
    subCalo = CaloCell_ID::LAREM;
    rID = m_calo_id->cell_id(subCalo,
                 id[SIDE],
                 id[SAMPL],
                 id[REGION],
                 id[ETA],
                 id[PHI]);
  }
  else if ( m_calo_id->is_lar_hec(id) ) {
    subCalo = CaloCell_ID::LARHEC;
    rID = m_calo_id->cell_id(subCalo,
                 id[SIDE],
                 id[SAMPL],
                 id[REGION],
                 id[ETA],
                 id[PHI]);
  }
  else if ( m_calo_id->is_lar_fcal(id) ) {
    subCalo = CaloCell_ID::LARFCAL;
    rID = m_calo_id->cell_id(subCalo,
                 id[SIDE],
                 id[SAMPL],
                 0,
                 id[FCALETA],
                 id[FCALPHI]);
  }
  else if ( m_calo_id->is_tile(id) ) {
    subCalo = CaloCell_ID::TILE;
    ExpandedIdentifier::element_type sampl = 0;
    if (id.fields() > TILESAMPL)
      sampl = id[TILESAMPL];
    rID = m_calo_id->cell_id(subCalo,
                 id[TILESECTION],
                 id[SIDE],
                 id[TILEPHI],
                 id[TILEETA],
                 sampl);
  }
  else {
    std::cout << "CaloNeighbours::get_id ERROR: " << (std::string)id << " is not in the LAr or Tile calorimeters" << std::endl;
    return 1;
  }
  return 0;
}

getName()

const std::string & CaloNeighbourRegion::getName ( ) const

inline

Definition at line 65 of file CaloNeighbours.h.

                                          {
    return m_name;
  }

getNeighbours()

int CaloNeighbourRegion::getNeighbours	(	const IdentifierHash	caloHash,
		std::vector< IdentifierHash > &	neighbourList ) const

Definition at line 261 of file CaloNeighbours.cxx.

{
  int result = 0; 
  
  if ( m_isValidMinus && caloHash >= m_minHashMinus && caloHash <= m_maxHashMinus && m_neighbours_minus[(unsigned int)(caloHash-m_minHashMinus)] ) {
    neighbourList.insert(neighbourList.end(),
             m_neighbours_minus[(unsigned int)(caloHash-m_minHashMinus)]->begin(),
             m_neighbours_minus[(unsigned int)(caloHash-m_minHashMinus)]->end());
  }
  else if ( m_isValidPlus && caloHash >= m_minHashPlus && caloHash <= m_maxHashPlus && m_neighbours_plus[(unsigned int)(caloHash-m_minHashPlus)] ) {
    neighbourList.insert(neighbourList.end(),
             m_neighbours_plus[(unsigned int)(caloHash-m_minHashPlus)]->begin(),
             m_neighbours_plus[(unsigned int)(caloHash-m_minHashPlus)]->end());
  }
 
  return result;
}

getType()

NEIGHBOURTYPE CaloNeighbourRegion::getType ( ) const

inline

Definition at line 61 of file CaloNeighbours.h.

                                       {
    return m_type;
  }

initializeVectors()

void CaloNeighbourRegion::initializeVectors	(	std::map< IdentifierHash, std::vector< IdentifierHash >, ltIdHash > &	neighbourMapPlus,
		std::map< IdentifierHash, std::vector< IdentifierHash >, ltIdHash > &	neighbourMapMinus )

Definition at line 238 of file CaloNeighbours.cxx.

{
  if ( m_isValidMinus ) {
    m_minHashMinus = neighbourMapMinus.begin()->first;
    m_maxHashMinus = neighbourMapMinus.rbegin()->first;
    m_neighbours_minus.resize((unsigned int)(m_maxHashMinus-m_minHashMinus+1));
    for (const auto& p : neighbourMapMinus) {
      m_neighbours_minus[(unsigned int)(p.first-m_minHashMinus)] = std::make_unique<std::vector<IdentifierHash> >(p.second);
    }
  }
  if ( m_isValidPlus ) {
    m_minHashPlus = neighbourMapPlus.begin()->first;
    m_maxHashPlus = neighbourMapPlus.rbegin()->first;
    m_neighbours_plus.resize((unsigned int)(m_maxHashPlus-m_minHashPlus+1));
    for (const auto& p : neighbourMapPlus) {
      m_neighbours_plus[(unsigned int)(p.first-m_minHashPlus)] = std::make_unique<std::vector<IdentifierHash> >(p.second);
    }
  }
 
}

setNeighbours()

int CaloNeighbourRegion::setNeighbours	(	ExpandedIdentifier &	id1,
		std::vector< ExpandedIdentifier > &	id2,
		std::map< IdentifierHash, std::vector< IdentifierHash >, ltIdHash > &	neighbourMapPlus,
		std::map< IdentifierHash, std::vector< IdentifierHash >, ltIdHash > &	neighbourMapMinus )

Definition at line 179 of file CaloNeighbours.cxx.

{
  int result = 0;
 
  // build an Identifier from the ExpandedIdentifier
  int nMaxSides=1;
  int nMaxPhi=1;
  float  rPhi=1;
  if ( m_hasSide )
    nMaxSides = 2;
  if ( m_hasPhi ) {
    nMaxPhi = m_sourceRange[m_iPhiSource].get_indices();
    rPhi = ((float)m_targetRange[m_iPhiTarget].get_indices())/((float)nMaxPhi);
  }
 
  for (int theSide = 0;theSide<nMaxSides;theSide++) {
    for (int theDPhi = 0;theDPhi<nMaxPhi;theDPhi++) {
      int side = +1;
      int dphi2 = (int)(theDPhi*rPhi+0.05);
      if ( theSide > 0 ) {
    side = -1;
      }
      // only continous region mapping in phi is supported - 
      // therefore theDPhi = delta phi ...
      Identifier myId;
      ExpandedIdentifier myExpID(id1);
      if ( getId(myExpID,myId,m_sourceRange,side,theDPhi) ) {
    return 1;
      }
      // get hash ID's for the source 
      IdentifierHash myHash = m_calo_id->calo_cell_hash (myId);
      // get ID's and hash ID's for the target
      std::vector<IdentifierHash> theTargetHashIDs;
      for (const ExpandedIdentifier& eid : id2) {
    Identifier myTargetId;
    ExpandedIdentifier myNExpID(eid);
    if ( getId(myNExpID,myTargetId,m_targetRange,side,dphi2) ) {
      return 1;
    }
    // get hash ID's for the target
    IdentifierHash myTargetHash = m_calo_id->calo_cell_hash (myTargetId);
    theTargetHashIDs.push_back(myTargetHash);
      }
      if ( id1[SIDE]*side > 0 ) {
    neighbourMapPlus[myHash] = std::move(theTargetHashIDs);
      }
      else {
    neighbourMapMinus[myHash] = std::move(theTargetHashIDs);
      }
    }
  }
  return result;
}

setPhi()

void CaloNeighbourRegion::setPhi	(	const int	phi1,
		const int	phi2 )

Definition at line 99 of file CaloNeighbours.cxx.

{
  m_hasPhi = true;
  m_iPhiSource = phi1;
  m_iPhiTarget = phi2;
 
}

setSide()

void CaloNeighbourRegion::setSide	(	const int	side1,
		const int	side2 )

Definition at line 90 of file CaloNeighbours.cxx.

{
  m_hasSide = true;
  m_iSideSource = side1;
  m_iSideTarget = side2;
}

setSourceRange()

void CaloNeighbourRegion::setSourceRange

(

const Range &

theRange

)

Definition at line 70 of file CaloNeighbours.cxx.

{
  m_sourceRange = theRange;
  for(unsigned int i=0;i<theRange[SIDE].get_indices();i++) {
    if ( theRange[SIDE].get_value_at(i) < 0 )
      m_isValidMinus = true;
    else
      m_isValidPlus = true;
  }
}

setTargetRange()

void CaloNeighbourRegion::setTargetRange

(

const Range &

theRange

)

Definition at line 83 of file CaloNeighbours.cxx.

{
  m_targetRange = theRange;
}

setType()

void CaloNeighbourRegion::setType

(

const NEIGHBOURTYPE

type

)

Definition at line 63 of file CaloNeighbours.cxx.

{
  m_type = type;
}

Member Data Documentation

m_calo_id

const CaloCell_Base_ID* CaloNeighbourRegion::m_calo_id

private

Definition at line 75 of file CaloNeighbours.h.

m_hasPhi

bool CaloNeighbourRegion::m_hasPhi

private

Definition at line 79 of file CaloNeighbours.h.

m_hasSide

bool CaloNeighbourRegion::m_hasSide

private

Definition at line 82 of file CaloNeighbours.h.

m_iPhiSource

int CaloNeighbourRegion::m_iPhiSource

private

Definition at line 80 of file CaloNeighbours.h.

m_iPhiTarget

int CaloNeighbourRegion::m_iPhiTarget

private

Definition at line 80 of file CaloNeighbours.h.

m_iSideSource

int CaloNeighbourRegion::m_iSideSource

private

Definition at line 83 of file CaloNeighbours.h.

m_iSideTarget

int CaloNeighbourRegion::m_iSideTarget

private

Definition at line 83 of file CaloNeighbours.h.

m_isValidMinus

bool CaloNeighbourRegion::m_isValidMinus

private

Definition at line 85 of file CaloNeighbours.h.

m_isValidPlus

bool CaloNeighbourRegion::m_isValidPlus

private

Definition at line 85 of file CaloNeighbours.h.

m_maxHashMinus

IdentifierHash CaloNeighbourRegion::m_maxHashMinus

private

Definition at line 87 of file CaloNeighbours.h.

m_maxHashPlus

IdentifierHash CaloNeighbourRegion::m_maxHashPlus

private

Definition at line 87 of file CaloNeighbours.h.

m_minHashMinus

IdentifierHash CaloNeighbourRegion::m_minHashMinus

private

Definition at line 87 of file CaloNeighbours.h.

m_minHashPlus

IdentifierHash CaloNeighbourRegion::m_minHashPlus

private

Definition at line 87 of file CaloNeighbours.h.

m_name

std::string CaloNeighbourRegion::m_name

private

Definition at line 73 of file CaloNeighbours.h.

m_neighbours_minus

std::vector< std::unique_ptr<std::vector<IdentifierHash> > > CaloNeighbourRegion::m_neighbours_minus

private

Definition at line 89 of file CaloNeighbours.h.

m_neighbours_plus

std::vector< std::unique_ptr<std::vector<IdentifierHash> > > CaloNeighbourRegion::m_neighbours_plus

private

Definition at line 88 of file CaloNeighbours.h.

m_sourceRange

Range CaloNeighbourRegion::m_sourceRange

private

Definition at line 77 of file CaloNeighbours.h.

m_targetRange

Range CaloNeighbourRegion::m_targetRange

private

Definition at line 77 of file CaloNeighbours.h.

m_type

NEIGHBOURTYPE CaloNeighbourRegion::m_type

private

Definition at line 74 of file CaloNeighbours.h.

---

The documentation for this class was generated from the following files:

• CaloNeighbours.h
• CaloNeighbours.cxx