#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.

43 {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:

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ CaloNeighbourRegion()

◆ ~CaloNeighbourRegion()

Member Function Documentation

◆ getId()

◆ getName()

◆ getNeighbours()

◆ getType()

◆ initializeVectors()

◆ setNeighbours()

◆ setPhi()

◆ setSide()

◆ setSourceRange()

◆ setTargetRange()

◆ setType()

Member Data Documentation

◆ m_calo_id

◆ m_hasPhi

◆ m_hasSide

◆ m_iPhiSource

◆ m_iPhiTarget

◆ m_iSideSource

◆ m_iSideTarget

◆ m_isValidMinus

◆ m_isValidPlus

◆ m_maxHashMinus

◆ m_maxHashPlus

◆ m_minHashMinus

◆ m_minHashPlus

◆ m_name

◆ m_neighbours_minus

◆ m_neighbours_plus

◆ m_sourceRange

◆ m_targetRange

◆ m_type