ECLNeighbours Class Reference

Class to get the neighbours for a given cell id. More...

#include <ECLNeighbours.h>

Public Member Functions
	ECLNeighbours (const std::string &neighbourDef, const double par, const bool sorted=false)
	Constructor: Fix number of neighbours ("N") in the seed theta ring, fraction cross ("F"), radius ("R") with par = n or par = fraction (0.1-1.0) or par = radius [cm].
	~ECLNeighbours ()
	Destructor.
const std::vector< short int > &	getNeighbours (short int cid) const
	Return the neighbours for a given cell ID.
short int	getCrystalsPerRing (const short int thetaid) const
	return number of crystals in a given theta ring

Private Member Functions
void	initializeN (const int nneighbours, const bool sorted=false)
	initialize the mask neighbour list.
void	initializeNC (const int nneighbours)
	initialize the mask neighbour list, remove corners.
void	initializeNLegacy (const int nneighbours)
	initialize the mask neighbour list, legacy code.
void	initializeNCLegacy (const int nneighbours, const int corners)
	initialize the mask neighbour list, remove corners, legacy code.
void	initializeR (const double radius)
	initialize the radius neighbour list.
void	initializeF (const double fraction)
	initialize the fractional cross neighbour list.
short int	decreasePhiId (const short int phiid, const short int thetaid, const short int n)
	return the previous phi id.
short int	increasePhiId (const short int phiid, const short int thetaid, const short int n)
	return the next phi id.
std::vector< short int >	getPhiIdsInBetween (const short int phiInc, const short int phiDec, const short int theta)
	return a list of phi ids between two phi ids
std::vector< short int >	getPhiIdsInBetweenC (const short int phiInc, const short int phiDec, const short int theta, const int corners)
	return a list of phi ids between two phi ids minus edges
double	getDistance (const double alpha, const double R)
	return the chord length between cells

Private Attributes
std::vector< std::vector< short int > >	m_neighbourMap
	list of list of neighbour cids.
std::vector< std::vector< short int > >	m_neighbourMapTemp
	temporary list of list of neighbour cids.
const short	m_crystalsPerRing [69]
	Number of crystals in each theta ring.

Detailed Description

Class to get the neighbours for a given cell id.

Definition at line 25 of file ECLNeighbours.h.

Constructor & Destructor Documentation

ECLNeighbours()

ECLNeighbours	(	const std::string &	neighbourDef,
		const double	par,
		const bool	sorted = false
	)

Constructor: Fix number of neighbours ("N") in the seed theta ring, fraction cross ("F"), radius ("R") with par = n or par = fraction (0.1-1.0) or par = radius [cm].

The sorted parameter will sort ascending thetaid and clockwise phi for the "N" case.

Definition at line 27 of file ECLNeighbours.cc.

{
  // resize the vector
  std::vector<short int> fakeneighbours;
  fakeneighbours.push_back(0); // insert one fake to avoid the "0" entry
  m_neighbourMap.push_back(fakeneighbours);
 
  int parToInt = int(par);
 
  // fixed number of neighbours:
  if (neighbourDef == "N") {
    B2DEBUG(150, "ECLNeighbours::ECLNeighbours: initialize " << neighbourDef << ", n x n: " << parToInt * 2 + 1 << " x " << parToInt * 2
            + 1);
    if ((parToInt >= 0) and (parToInt < 11)) initializeN(parToInt, sorted);
    else B2FATAL("ECLNeighbours::ECLNeighbours: " << LogVar("parameter", parToInt) << "Invalid parameter (must be between 0 and 10)!");
  } else if (neighbourDef == "NC") {
    B2DEBUG(150, "ECLNeighbours::ECLNeighbours: initialize " << neighbourDef << ", n x n (minus corners): " << parToInt * 2 + 1 << " x "
            <<
            parToInt * 2 + 1);
    if ((parToInt >= 0) and (parToInt < 11)) initializeNC(parToInt);
    else B2FATAL("ECLNeighbours::ECLNeighbours: " << LogVar("parameter", parToInt) << "Invalid parameter (must be between 0 and 10)!");
  } else if (neighbourDef == "NLegacy") {
    B2DEBUG(150, "ECLNeighbours::ECLNeighbours: initialize " << neighbourDef << ", n x n: " << parToInt * 2 + 1 << " x " << parToInt * 2
            + 1);
    if ((parToInt >= 0) and (parToInt < 11)) initializeNLegacy(parToInt);
    else B2FATAL("ECLNeighbours::ECLNeighbours: " << LogVar("parameter", parToInt) << "Invalid parameter (must be between 0 and 10)!");
  } else if (neighbourDef == "NCLegacy") {
    B2DEBUG(150, "ECLNeighbours::ECLNeighbours: initialize " << neighbourDef << ", n x n (minus corners): " << parToInt * 2 + 1 << " x "
            <<
            parToInt * 2 + 1);
    if ((parToInt >= 0) and (parToInt < 11)) initializeNCLegacy(parToInt, 1);
    else B2FATAL("ECLNeighbours::ECLNeighbours: " << LogVar("parameter", parToInt) << "Invalid parameter (must be between 0 and 10)!");
  }
  // or neighbours depend on the distance:
  else if (neighbourDef == "R") {
    B2DEBUG(150, "ECLNeighbours::ECLNeighbours: initialize " << neighbourDef << ", radius: " << par << " cm");
    if ((par > 0.0) and (par < 30.0 * Belle2::Unit::cm)) initializeR(par);
    else B2FATAL("ECLNeighbours::ECLNeighbours: " << par << " is an invalid parameter (must be between 0 cm and 30 cm)!");
  }
  // or neighbours that form a cross, user defined coverage of up to 100% in neighbouring ring:
  else if (neighbourDef == "F") {
    double parChecked = par;
    if (parChecked > 1.0) parChecked = 1.0;
    else if (parChecked < 0.1) parChecked = 0.1;
    B2DEBUG(150, "ECLNeighbours::ECLNeighbours: initialize " << neighbourDef << ", fraction: " << parChecked);
    initializeF(parChecked);
  }
  // or wrong type:
  else {
    B2FATAL("ECLNeighbours::ECLNeighbours (constructor via std::string): Invalid option: " << neighbourDef <<
            " (valid: N(n), NC(n), NLegacy(n), NCLegacy(n), R ( with R<30 cm), F (with 0.1<f<1)");
  }
 
}

~ECLNeighbours()

~ECLNeighbours

(

)

Destructor.

Definition at line 82 of file ECLNeighbours.cc.

{
  ;
}

Member Function Documentation

decreasePhiId()

short int decreasePhiId ( const short int  phiid, const short int  thetaid, const short int  n  )

private

return the previous phi id.

Definition at line 453 of file ECLNeighbours.cc.

{
  short int previousPhiId = ((phiid - n < 0) ? m_crystalsPerRing[thetaid] + phiid - n : phiid - n);     // "underflow"
  return previousPhiId;
}

getCrystalsPerRing()

short int getCrystalsPerRing ( const short int  thetaid ) const

inline

return number of crystals in a given theta ring

Definition at line 39 of file ECLNeighbours.h.

{ return m_crystalsPerRing[thetaid]; }

getDistance()

double getDistance ( const double  alpha, const double  R  )

private

return the chord length between cells

Definition at line 501 of file ECLNeighbours.cc.

{
  return 2.0 * R * TMath::Sin(alpha / 2.0);
}

getNeighbours()

const std::vector< short int > & getNeighbours

(

short int

cid

)

const

Return the neighbours for a given cell ID.

Definition at line 447 of file ECLNeighbours.cc.

{
  return m_neighbourMap.at(cid);
}

getPhiIdsInBetween()

std::vector< short int > getPhiIdsInBetween ( const short int  phiInc, const short int  phiDec, const short int  theta  )

private

return a list of phi ids between two phi ids

Definition at line 467 of file ECLNeighbours.cc.

{
  std::vector<short int> phiList;
  short int loop = phi0;
 
  while (1) {
    phiList.push_back(loop);
    if (loop == phi1) break;
    loop = decreasePhiId(loop, theta, 1);
  }
 
  return phiList;
}

getPhiIdsInBetweenC()

std::vector< short int > getPhiIdsInBetweenC ( const short int  phiInc, const short int  phiDec, const short int  theta, const int  corners  )

private

return a list of phi ids between two phi ids minus edges

Definition at line 481 of file ECLNeighbours.cc.

{
  std::vector<short int> phiList;
  if (phi0 == phi1) return phiList; // could be that there is only one crystal in this theta ring definition
 
  short int loop = decreasePhiId(phi0, theta, corners); // start at -n corners
  if (loop == phi1) return phiList; // there will be no neighbours left in this phi ring after removing the first corners
 
  short int stop = increasePhiId(phi1, theta, corners); //stop at +n corners
 
  while (1) {
    phiList.push_back(loop);
    if (loop == stop) break;
    loop = decreasePhiId(loop, theta, 1);
  }
 
  return phiList;
}

increasePhiId()

short int increasePhiId ( const short int  phiid, const short int  thetaid, const short int  n  )

private

return the next phi id.

Definition at line 460 of file ECLNeighbours.cc.

{
  short int nextPhiId = (((phiid + n) > (m_crystalsPerRing[thetaid] - 1)) ? phiid + n - m_crystalsPerRing[thetaid] : phiid +
                         n);       // "overflow"
  return nextPhiId;
}

initializeF()

void initializeF ( const double  fraction )

private

initialize the fractional cross neighbour list.

Definition at line 128 of file ECLNeighbours.cc.

{
  // ECL geometry
  ECLGeometryPar* geom = ECLGeometryPar::Instance();
 
  for (int i = 0; i < ECLElementNumbers::c_NCrystals; i++) {
    // this vector will hold all neighbours for the i-th crystal
    std::vector<short int> neighbours;
 
    // phi and theta coordinates of the central crystal
    geom->Mapping(i);
    const short tid = geom->GetThetaID();
    const short pid = geom->GetPhiID();
 
    // add the two in the same theta ring
    const short int phiInc = increasePhiId(pid, tid, 1);
    const short int phiDec = decreasePhiId(pid, tid, 1);
    neighbours.push_back(geom->GetCellID(tid, pid) + 1);
    neighbours.push_back(geom->GetCellID(tid, phiInc) + 1);
    neighbours.push_back(geom->GetCellID(tid, phiDec) + 1);
 
    double fracPos = (pid + 0.5) / m_crystalsPerRing[tid];
 
    // find the two closest crystals in the inner theta ring
    short int tidinner = tid - 1;
    if (tidinner >= 0) {
 
      short int n1 = -1;
      double dist1 = 999.;
      short int pid1 = -1;
      short int n2 = -1;
      double dist2 = 999.;
 
      for (short int inner = 0; inner < m_crystalsPerRing[tidinner]; ++inner) {
        const double f = (inner + 0.5) / m_crystalsPerRing[tidinner];
        const double dist = fabs(fracPos - f);
        if (dist < dist1) {
          dist2 = dist1;
          dist1 = dist;
          n2 = n1;
          n1 = geom->GetCellID(tidinner, inner);
          pid1 = inner;
        } else if (dist < dist2) {
          dist2 = dist;
          n2 = geom->GetCellID(tidinner, inner);
        }
      }
 
      // check coverage
      double cov = TMath::Min(((double) pid + 1) / m_crystalsPerRing[tid],
                              ((double) pid1 + 1) / m_crystalsPerRing[tidinner]) - TMath::Max(((double) pid) / m_crystalsPerRing[tid],
                                  ((double) pid1) / m_crystalsPerRing[tidinner]);
      cov = cov / (1. / m_crystalsPerRing[tid]);
 
      neighbours.push_back(n1 + 1);
      if (cov < frac - 1e-4) neighbours.push_back(n2 + 1);
    }
 
    // find the two closest crystals in the outer theta ring
    short int tidouter = tid + 1;
    if (tidouter <= 68) {
      short int no1 = -1;
      double disto1 = 999.;
      short int pido1 = -1;
      short int no2 = -1;
      double disto2 = 999.;
 
      for (short int outer = 0; outer < m_crystalsPerRing[tidouter]; ++outer) {
        const double f = (outer + 0.5) / m_crystalsPerRing[tidouter];
        const double dist = fabs(fracPos - f);
        if (dist < disto1) {
          disto2 = disto1;
          disto1 = dist;
          no2 = no1;
          no1 = geom->GetCellID(tidouter, outer);
          pido1 = outer;
        } else if (dist < disto2) {
          disto2 = dist;
          no2 = geom->GetCellID(tidouter, outer);
        }
      }
      // check coverage
      double cov = TMath::Min(((double) pid + 1) / m_crystalsPerRing[tid],
                              ((double) pido1 + 1) / m_crystalsPerRing[tidouter]) - TMath::Max(((double) pid) / m_crystalsPerRing[tid],
                                  ((double) pido1) / m_crystalsPerRing[tidouter]);
      cov = cov / (1. / m_crystalsPerRing[tid]);
 
      neighbours.push_back(no1 + 1);
      if (cov < frac - 1e-4) {
        neighbours.push_back(no2 + 1);
      }
    }
 
    // push back the final vector of IDs
    m_neighbourMap.push_back(neighbours);
  }
 
}

initializeN()

void initializeN ( const int  nneighbours, const bool  sorted = false  )

private

initialize the mask neighbour list.

Definition at line 227 of file ECLNeighbours.cc.

{
  // This is the "NxN-edges" case (in the barrel)
  for (int i = 0; i < ECLElementNumbers::c_NCrystals; i++) {
 
    // this vector will hold all neighbours for the i-th crystal
    std::vector<short int> neighbours;
    neighbours.push_back(i + 1);
 
    std::vector<short int> neighbours_temp;
 
    // iterate next, next-to-next, next-to-next-to-next, ...
    for (int idx = 0; idx < n; idx++) {
      EclNbr tmpNbr;
      for (const auto& nbr : neighbours) {
        const EclNbr& aNbr(tmpNbr.getNbr(nbr - 1)); // uses crystalid, but we store cellids
        for (std::vector<EclNbr::Identifier>::const_iterator newnbr = aNbr.nearBegin(); newnbr != aNbr.nearEnd(); ++newnbr) {
          neighbours_temp.push_back(((short) *newnbr) + 1); // store cellid, not crystalid
        }
      }
 
      // now sort and remove all duplicates from neighbours_temp
      sort(neighbours_temp.begin(), neighbours_temp.end());
      neighbours_temp.erase(unique(neighbours_temp.begin(), neighbours_temp.end()), neighbours_temp.end());
      neighbours.insert(neighbours.end(), neighbours_temp.begin(), neighbours_temp.end());
    }
 
    // push back the final vector of IDs, we have to erease the duplicate first ID
    sort(neighbours.begin(), neighbours.end());
    neighbours.erase(unique(neighbours.begin(), neighbours.end()), neighbours.end());
 
    //sort by theta and phi
    if (sorted == true) {
 
      // ECL geometry
      ECLGeometryPar* geom = ECLGeometryPar::Instance();
 
      // create a simple struct with cellid, thetaid, and phiid (the latter two will be used for sorting)
      struct crystal {
        int cellid;
        int phiid;
        int thetaid;
        int neighbourn; //needed since we can not access local variables in sort
      };
 
      // fill them all into a vector
      std::vector<crystal> crystals;
      for (const auto& nbr : neighbours) {
        geom->Mapping(nbr - 1);
        crystals.push_back({nbr, geom->GetPhiID(), geom->GetThetaID(), n});
      }
 
      //sort this vector using custom metric
      std::sort(crystals.begin(), crystals.end(), [](const auto & left, const auto & right) {
        //primary condition: thetaid
        if (left.thetaid < right.thetaid) return true;
        if (left.thetaid > right.thetaid) return false;
 
        // left.thetaid == right.thetaid for primary condition, go to secondary condition
        // first check if we are crossing a phi=0 boundary by checking if the  difference between phiids is larger than the neighbour size (2*N+1)
        // examples: left.phiid = 0, right.phiid=143 -> returns true (0 ">" 143)
        // examples: left.phiid = 0, right.phiid=1 -> returns false (1 ">" 0)
        // examples: left.phiid = 1, right.phiid=0 -> returns true (1 ">" 0)
        if (fabs(left.phiid - right.phiid) > (2 * left.neighbourn + 1)) {
          return right.phiid > left.phiid;
        } else {
          return left.phiid > right.phiid;
        }
 
        //we should never arrive here by definition
        return true;
      });
 
      //replace the neighbour vector with this newly sorted one
      for (int nbidx = 0; nbidx < int(neighbours.size()); nbidx++) {
        neighbours[nbidx] = crystals[nbidx].cellid;
      }
    }
 
    m_neighbourMap.push_back(neighbours);
 
  }
}

initializeNC()

void initializeNC ( const int  nneighbours )

private

initialize the mask neighbour list, remove corners.

Definition at line 311 of file ECLNeighbours.cc.

{
  // get the normal neighbours
  initializeN(n);
 
  // ECL geometry
  ECLGeometryPar* geom = ECLGeometryPar::Instance();
 
  for (int i = 0; i < ECLElementNumbers::c_NCrystals; i++) {
    std::vector<short int> neighbours = m_neighbourMap.at(i + 1);
    std::vector<short int> neighbours_temp;
 
    geom->Mapping(i);
    const int centerthetaid = geom->GetThetaID();
 
    for (const auto& nbr : neighbours) {
      geom->Mapping(nbr - 1);
      const int thetaid = geom->GetThetaID();
 
      if (abs(thetaid - centerthetaid) == n) {
        const short int phiInc = increasePhiId(geom->GetPhiID(), geom->GetThetaID(), 1);
        const short int phiDec = decreasePhiId(geom->GetPhiID(), geom->GetThetaID(), 1);
        const int cid1 = geom->GetCellID(thetaid, phiInc) + 1;
        const int cid2 = geom->GetCellID(thetaid, phiDec) + 1;
 
        // if that crystal has two neighbours in the same theta-ring, it will not be removed
        if (!((std::find(neighbours.begin(), neighbours.end(), cid1) != neighbours.end()) and
              (std::find(neighbours.begin(), neighbours.end(), cid2) != neighbours.end()))) {
          continue;
        }
      }
      neighbours_temp.push_back(nbr);
 
    }
 
    m_neighbourMap[i + 1] = neighbours_temp;
 
  } // end 8736 loop
 
}

initializeNCLegacy()

void initializeNCLegacy ( const int  nneighbours, const int  corners  )

private

initialize the mask neighbour list, remove corners, legacy code.

Definition at line 398 of file ECLNeighbours.cc.

{
  // ECL geometry
  ECLGeometryPar* geom = ECLGeometryPar::Instance();
 
  // This is the "NxN-edges" minus edges case (in the barrel)
  // in the endcaps we project the neighbours to the outer and inner rings.
  for (int i = 0; i < ECLElementNumbers::c_NCrystals; i++) {
 
    // this vector will hold all neighbours for the i-th crystal
    std::vector<short int> neighbours;
 
    // phi and theta coordinates of the central crystal
    geom->Mapping(i);
    const short tid = geom->GetThetaID();
    const short pid = geom->GetPhiID();
 
    // 'left' and 'right' extremal neighbours in the same theta ring
    const short int phiInc = increasePhiId(pid, tid, n);
    const short int phiDec = decreasePhiId(pid, tid, n);
    const double fractionalPhiInc = static_cast < double >(phiInc) / m_crystalsPerRing [ tid ];
    const double fractionalPhiDec = static_cast < double >(phiDec) / m_crystalsPerRing [ tid ];
 
    // loop over all possible theta rings and add neighbours
    for (int theta = tid - n; theta <= tid + n; theta++) {
      if ((theta > 68) || (theta < 0)) continue;     // valid theta ids are 0..68 (69 in total)
 
      short int thisPhiInc = std::lround(fractionalPhiInc * m_crystalsPerRing [ theta ]);
 
      short int thisPhiDec = std::lround(fractionalPhiDec * m_crystalsPerRing [ theta ]);
      if (thisPhiDec == m_crystalsPerRing [ theta ]) thisPhiDec = 0;
 
      std::vector<short int> phiList;
      if ((theta == tid - n) or (theta == tid + n)) phiList = getPhiIdsInBetweenC(thisPhiInc, thisPhiDec, theta, corners);
      else if (corners == 2 and ((theta == tid - n + 1)
                                 or (theta == tid + n - 1))) phiList = getPhiIdsInBetweenC(thisPhiInc, thisPhiDec, theta, 1);
      else phiList = getPhiIdsInBetween(thisPhiInc, thisPhiDec, theta);
 
      for (unsigned int k = 0; k < phiList.size(); ++k) {
        neighbours.push_back(geom->GetCellID(theta, phiList.at(k)) + 1);
      }
    }
 
    // push back the final vector of IDs
    m_neighbourMap.push_back(neighbours);
 
  }
}

initializeNLegacy()

void initializeNLegacy ( const int  nneighbours )

private

initialize the mask neighbour list, legacy code.

Definition at line 352 of file ECLNeighbours.cc.

{
  // ECL geometry
  ECLGeometryPar* geom = ECLGeometryPar::Instance();
 
  // This is the "NxN-edges" case (in the barrel)
  // in the endcaps we project the neighbours to the outer and inner rings.
  for (int i = 0; i < ECLElementNumbers::c_NCrystals; i++) {
 
    // this vector will hold all neighbours for the i-th crystal
    std::vector<short int> neighbours;
 
    // phi and theta coordinates of the central crystal
    geom->Mapping(i);
    const short tid = geom->GetThetaID();
    const short pid = geom->GetPhiID();
 
    // 'left' and 'right' extremal neighbours in the same theta ring
    const short int phiInc = increasePhiId(pid, tid, n);
    const short int phiDec = decreasePhiId(pid, tid, n);
    const double fractionalPhiInc = static_cast < double >(phiInc) / m_crystalsPerRing [ tid ];
    const double fractionalPhiDec = static_cast < double >(phiDec) / m_crystalsPerRing [ tid ];
 
    // loop over all possible theta rings and add neighbours
    for (int theta = tid - n; theta <= tid + n; theta++) {
      if ((theta > 68) || (theta < 0)) continue;     // valid theta ids are 0..68 (69 in total)
 
      short int thisPhiInc = std::lround(fractionalPhiInc * m_crystalsPerRing [ theta ]);
 
      short int thisPhiDec = std::lround(fractionalPhiDec * m_crystalsPerRing [ theta ]);
      if (thisPhiDec == m_crystalsPerRing [ theta ]) thisPhiDec = 0;
 
      const std::vector<short int> phiList = getPhiIdsInBetween(thisPhiInc, thisPhiDec, theta);
 
      for (unsigned int k = 0; k < phiList.size(); ++k) {
        neighbours.push_back(geom->GetCellID(theta, phiList.at(k)) + 1);
      }
    }
 
    // push back the final vector of IDs
    m_neighbourMap.push_back(neighbours);
 
  }
}

initializeR()

void initializeR ( const double  radius )

private

initialize the radius neighbour list.

Definition at line 87 of file ECLNeighbours.cc.

{
  // resize the vector
  std::vector<short int> fakeneighbours;
  fakeneighbours.push_back(0); // insert one fake to avoid the "0" entry
  m_neighbourMapTemp.push_back(fakeneighbours);
 
  // distance calculations take a "long" time, so reduce the number of candidates first:
  initializeN(6);
 
  // ECL geometry
  ECLGeometryPar* geom = ECLGeometryPar::Instance();
 
  for (int i = 0; i < ECLElementNumbers::c_NCrystals; i++) {
    // get the central one
    ROOT::Math::XYZVector direction = geom->GetCrystalVec(i);
    ROOT::Math::XYZVector position  = geom->GetCrystalPos(i);
 
    // get all nearby crystals
    std::vector<short int> neighbours = getNeighbours(i + 1);
    std::vector<short int> neighboursTemp;
 
    // ... and calculate the shortest distance between the central one and all possible neighbours (of the reduced set)
    for (auto const& id : neighbours) {
      const ROOT::Math::XYZVector& directionNeighbour = geom->GetCrystalVec(id - 1);
      const double alpha = ROOT::Math::VectorUtil::Angle(
                             direction, directionNeighbour);
      const double R        = position.R();
      const double distance = getDistance(alpha, R);
 
      if (distance <= radius) neighboursTemp.push_back(id);
    }
 
    m_neighbourMapTemp.push_back(neighboursTemp);
  }
 
  // all done, reoplace the original map
  m_neighbourMap = m_neighbourMapTemp;
 
}

Member Data Documentation

m_crystalsPerRing

const short m_crystalsPerRing[69]

private

Initial value:

= {
        48, 48, 64, 64, 64, 96, 96, 96, 96, 96, 96, 144, 144, 
        144, 144, 144, 144, 144, 144, 144,  
        144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 
        144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 
        144, 144, 144, 144, 144, 144, 144, 144, 144, 144, 
        144, 144, 144, 144, 144, 144, 144, 144, 144, 
        144, 144, 96, 96, 96, 96, 96, 64, 64, 64
      }

Number of crystals in each theta ring.

Definition at line 49 of file ECLNeighbours.h.

m_neighbourMap

std::vector< std::vector < short int > > m_neighbourMap

private

list of list of neighbour cids.

Definition at line 43 of file ECLNeighbours.h.

m_neighbourMapTemp

std::vector< std::vector < short int > > m_neighbourMapTemp

private

temporary list of list of neighbour cids.

Definition at line 46 of file ECLNeighbours.h.

---

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

• ecl/geometry/include/ECLNeighbours.h
• ecl/geometry/src/ECLNeighbours.cc