SCT_ReClustering Class Reference

This performs reclustering after identifying dead or noisy channels. More...

#include <SCT_ReClustering.h>

Collaboration diagram for SCT_ReClustering:

Static Public Member Functions
static std::vector< std::vector< Identifier > >	recluster (std::vector< std::vector< Identifier > > &, const SCT_ID &)
	called by SCT_ClusteringTool.

Private Types
typedef std::vector< Identifier >	ID_Vector
typedef std::vector< Identifier >::iterator	Discont

Detailed Description

This performs reclustering after identifying dead or noisy channels.

Definition at line 22 of file SCT_ReClustering.h.

Member Typedef Documentation

Discont

typedef std::vector<Identifier>::iterator SCT_ReClustering::Discont

private

Definition at line 32 of file SCT_ReClustering.h.

ID_Vector

typedef std::vector<Identifier> SCT_ReClustering::ID_Vector

private

Definition at line 31 of file SCT_ReClustering.h.

Member Function Documentation

recluster()

std::vector< std::vector< Identifier > > SCT_ReClustering::recluster ( std::vector< std::vector< Identifier > > & idGroups, const SCT_ID & sctID )

static

called by SCT_ClusteringTool.

If some bad channel has broken the cluster (provided as a list of RDOs) in non-consecutive fragments, just split it.

Definition at line 24 of file SCT_ReClustering.cxx.

                                                                      {
 
  /*
    From SCT_ClusteringTool we have a matrix of identifiers - hits on
    neighboring strips are grouped togther (vector of identifiers) and
    these are grouped into one big vector (idGroups) for that event.
    Most of these clusters are just single channels and are now
    excluded if dead/noisy. In the rarer case of several neighbouring
    channels being hit, the cluster gets split up into smaller clusters.
    idGroups is then remade into newidGroups and the original destroyed
  */
  std::vector<ID_Vector> newidGroups;
 
  // Make a vector of iterators. These will point to any discontinuties
  // in the vectors of identifiers
  std::vector<Discont> discontV;
 
  // The vectors of identifiers are copied to new vectors of identifiers
  // and the old ones destroyed
  ID_Vector newvector;
 
  // Need one loop over the group members of idGroups
  std::vector<ID_Vector>::iterator firstGroup = idGroups.begin();
  std::vector<ID_Vector>::iterator lastGroup = idGroups.end();
  for (; firstGroup != lastGroup; ++firstGroup) {
 
    // Need a second loop over the identifiers within each idGroups member
    std::vector<Identifier>::iterator fst = (*firstGroup).begin();
    std::vector<Identifier>::iterator lst = (*firstGroup).end();
    std::vector<Identifier>::iterator prt;
    int prev = sctID.strip(*fst);
 
    // ONE/3 Store an iterator pointing to 1st strip
    discontV.clear();
    discontV.push_back((*firstGroup).begin());
 
    // now look at rest of strips
    prt = fst;
    ++fst;
    for (; fst != lst; ++fst) {
      int current = sctID.strip(*fst);
 
      //**CHECK STRIPS ARE CONSECUTIVE**
 
      // TWO/3 If not store an iterator pointing either side of the
      // discontinuity
      if (current != prev + 1) {
        discontV.push_back(prt);
        discontV.push_back(fst);
        prt = fst;
      }
      prev = current;
    }
    // THREE/3 Store an iterator pointing to last strip
    discontV.push_back((*firstGroup).end() - 1);
 
    /*
      Now we have a vector of pointers discontV to the first and last
      member of each idGroups member and to any discontinuties within
    */
 
    std::vector<Discont>::iterator fst_d = discontV.begin();
    // NB: *fst_d refers to the element pointed to by fst_d, and that
    // element is an iterator!
 
    // Copy the old vector of identifiers into however many new ones
    // are needed. If there were no discontinutities, discontV is
    // of size 2 so we are just making a copy
    for (unsigned int sg = 1; sg < discontV.size(); sg += 2) {
      newvector.clear();
      newvector.assign(*fst_d, (*(fst_d + 1)) + 1);
      newidGroups.push_back(newvector);
      fst_d += 2;
    }
  }
  // delete the old idGroups and return the new one
  idGroups.clear();
  newvector.clear();
  return newidGroups;
}

---

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

• SCT_ReClustering.h
• SCT_ReClustering.cxx