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

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 >> &	,
		const SCT_ID &
	)

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: