CaloNeighbours Class Reference

#include <CaloNeighbours.h>

Collaboration diagram for CaloNeighbours:

Public Member Functions
	CaloNeighbours ()
virtual	~CaloNeighbours ()
int	initialize (const CaloCell_Base_ID *caloID, const std::string &filename)
int	get_nextInCalo (const IdentifierHash &id, std::vector< IdentifierHash > &neighbourList) const
int	get_prevInCalo (const IdentifierHash &id, std::vector< IdentifierHash > &neighbourList) const

Static Public Member Functions
static int	get_neighbours (const IdentifierHash &id, const std::vector< std::unique_ptr< CaloNeighbourRegion > > &regions, std::vector< IdentifierHash > &neighbourList)

Private Attributes
const CaloCell_Base_ID *	m_calo_id
std::vector< std::unique_ptr< CaloNeighbourRegion > >	m_next_regions
std::vector< std::unique_ptr< CaloNeighbourRegion > >	m_prev_regions

Detailed Description

Definition at line 92 of file CaloNeighbours.h.

Constructor & Destructor Documentation

CaloNeighbours()

CaloNeighbours::CaloNeighbours

(

)

Definition at line 282 of file CaloNeighbours.cxx.

                               :
  m_calo_id(nullptr)
{ }

~CaloNeighbours()

CaloNeighbours::~CaloNeighbours ( )

virtualdefault

Member Function Documentation

get_neighbours()

int CaloNeighbours::get_neighbours ( const IdentifierHash & id, const std::vector< std::unique_ptr< CaloNeighbourRegion > > & regions, std::vector< IdentifierHash > & neighbourList )

static

Definition at line 461 of file CaloNeighbours.cxx.

{
  int result = 0;
  for (const std::unique_ptr<CaloNeighbourRegion>& p : regions) {
    result = p->getNeighbours(id,neighbourList);
    if ( result != 0 )
      return result;
  }
  return result;
}

get_nextInCalo()

int CaloNeighbours::get_nextInCalo	(	const IdentifierHash &	id,
		std::vector< IdentifierHash > &	neighbourList ) const

Definition at line 447 of file CaloNeighbours.cxx.

{
  return get_neighbours(id,m_next_regions,neighbourList);
}

get_prevInCalo()

int CaloNeighbours::get_prevInCalo	(	const IdentifierHash &	id,
		std::vector< IdentifierHash > &	neighbourList ) const

Definition at line 454 of file CaloNeighbours.cxx.

{
  return get_neighbours(id,m_prev_regions,neighbourList);
}

initialize()

int CaloNeighbours::initialize	(	const CaloCell_Base_ID *	caloID,
		const std::string &	filename )

Definition at line 293 of file CaloNeighbours.cxx.

{
  int result =0;
  //  std::cout << " CaloNeighbours::initialize " << std::endl;
  m_calo_id = caloID;
  m_next_regions.resize(0);
  m_prev_regions.resize(0);
  // Find the full path to filename:
  std::string file = PathResolver::find_file (filename, "DATAPATH");
  //    std::cout << "Reading file  " << file << std::endl;
  std::ifstream fin;
  if (!file.empty()) {
    fin.open(file.c_str());
  }
  else {
    std::cout << "CaloNeighbours::initialize ERROR Could not find input file " << filename <<  std::endl;
    return 1;
  }
  if (fin.bad()) {
    std::cout << "CaloNeighbours::initialize ERROR Could not open file " << file << std::endl;
    return 1;
  }
 
  //
  // Parse the input file
  //
 
  char aLine[MAX_BUFFER_LEN],dummy;
  std::string sLine;
  std::string cPrevOrNext,cName,cSourceRange,cTargetRange;
  std::string cExpId;
  Range mySourceRange,myTargetRange;
  std::string oArg;
  bool isComment = true;
  bool isNext = false;
  bool isPrev = false;
  const std::string cmdNext("nextSuperCalo");
  const std::string cmdPrev("prevSuperCalo");
  const std::string cmdPhi("calcPhi(");
  const std::string cmdSide("calcSide(");
 
  while( isComment ) {
    sLine.resize( 0 );
    do {  
      fin.getline(aLine,sizeof(aLine)-1);
      sLine = std::string(aLine);
    } while (sLine.empty() && !fin.eof());
    isComment = ( sLine.find('#') != std::string::npos );
  }
  do {
    while ( sLine.empty() && !fin.eof()) {
      fin.getline(aLine,sizeof(aLine)-1);
      sLine = std::string(aLine);
    }
    std::istringstream header( sLine.c_str() );
    bool hasPhi=false;
    bool hasSide=false;
    int iPhiSource,iPhiTarget;
    int iSideSource,iSideTarget;
    if ( header >> cPrevOrNext >> cName >> cSourceRange >> cTargetRange) {
      mySourceRange.build(cSourceRange);
      myTargetRange.build(cTargetRange);
      while ( header >> oArg ) {
    if (oArg.find(cmdSide) != std::string::npos ) {
      hasSide = true;
      oArg.erase(0,cmdSide.size());
      std::istringstream iside( oArg.c_str() );
      iside >> iSideSource >> dummy >> iSideTarget;
    }
    else if ( oArg.find(cmdPhi) != std::string::npos ) {
      hasPhi = true;
      oArg.erase(0,cmdPhi.size());
      std::istringstream iphi( oArg.c_str() );
      iphi >> iPhiSource >> dummy >> iPhiTarget;
    }
      }
      sLine.resize(0);
      bool endOfBlock = false;
      isNext = (cPrevOrNext.find(cmdNext) != std::string::npos);
      isPrev = (cPrevOrNext.find(cmdPrev) != std::string::npos);
      if ( isNext^isPrev ) {
//  std::cout << (isNext?cmdNext:cmdPrev) << " " 
//        << cName << " " 
//        << (std::string)mySourceRange << " " 
//        << (std::string)myTargetRange;
//  if ( hasSide ) {
//    std::cout << " hasSide(" << iSideSource << "," << iSideTarget << ")";
//  }
//  if ( hasPhi ) {
//    std::cout << " hasPhi(" << iPhiSource << "," << iPhiTarget << ")";
//  }
//  std::cout << std::endl;
    // create new CaloNeighbourRegion
    auto myRegion = std::make_unique<CaloNeighbourRegion>(cName,m_calo_id);
    if ( isNext )
      myRegion->setType(nextInCalo);
    else
      myRegion->setType(prevInCalo);
    if ( hasSide )
      myRegion->setSide(iSideSource,iSideTarget);
    if ( hasPhi )
      myRegion->setPhi(iPhiSource,iPhiTarget);
    myRegion->setSourceRange(mySourceRange);
    myRegion->setTargetRange(myTargetRange);
    // create temporary neighbour maps
    std::map<IdentifierHash, std::vector<IdentifierHash>, ltIdHash> neighbourMapPlus,neighbourMapMinus;
 
    do {
      while ( !endOfBlock && sLine.empty() && !fin.eof()) {
        fin.getline(aLine,sizeof(aLine)-1);
        sLine = std::string(aLine);
        if ( sLine.empty() || fin.eof() )
          endOfBlock = true;
      }
      if (!endOfBlock) {
        std::istringstream neighbour( sLine.c_str() );
        ExpandedIdentifier myCell,myNeighbourCell;
        std::vector<ExpandedIdentifier> myNeighbourCells;
        if ( neighbour >> cExpId ) {
          myCell = ExpandedIdentifier(cExpId);
          // std::cout << (std::string)myCell << ":";
          while ( neighbour >> cExpId ) {
        myNeighbourCell = ExpandedIdentifier(cExpId);
        // std::cout << " " << (std::string)myNeighbourCell;
        myNeighbourCells.push_back(myNeighbourCell);
          }
          // std::cout << std::endl;
          sLine.resize(0);
          result = myRegion->setNeighbours(myCell,myNeighbourCells,neighbourMapPlus,neighbourMapMinus);
          if ( result != 0 ) 
        return result;
        }
      }
    } while (!fin.eof() && !endOfBlock);
    myRegion->initializeVectors(neighbourMapPlus,neighbourMapMinus);
    if (isNext) 
      m_next_regions.push_back(std::move(myRegion));
    else
      m_prev_regions.push_back(std::move(myRegion));
      }
      else {
    std::cout << "CaloNeighbours::initialize ERROR Invalid neighbour dat file, exiting ... " << std::endl;
    return 1;
      }
    }
  }while (!fin.eof()) ;
  fin.close();
  
  return 0;
}

Member Data Documentation

m_calo_id

const CaloCell_Base_ID* CaloNeighbours::m_calo_id

private

Definition at line 113 of file CaloNeighbours.h.

m_next_regions

std::vector<std::unique_ptr<CaloNeighbourRegion> > CaloNeighbours::m_next_regions

private

Definition at line 115 of file CaloNeighbours.h.

m_prev_regions

std::vector<std::unique_ptr<CaloNeighbourRegion> > CaloNeighbours::m_prev_regions

private

Definition at line 116 of file CaloNeighbours.h.

---

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

• CaloNeighbours.h
• CaloNeighbours.cxx