cluster::DBScan3DAlg Class Reference

#include <DBScan3DAlg.h>

Public Member Functions
	DBScan3DAlg (fhicl::ParameterSet const &pset)
void	init (const std::vector< art::Ptr< recob::SpacePoint >> &sps, art::FindManyP< recob::Hit > &hitFromSp)
void	dbscan ()

Public Attributes
std::vector< point_t >	points

Private Member Functions
node_t *	create_node (unsigned int index)
int	append_at_end (unsigned int index, epsilon_neighbours_t *en)
epsilon_neighbours_t *	get_epsilon_neighbours (unsigned int index)
void	destroy_epsilon_neighbours (epsilon_neighbours_t *en)
int	expand (unsigned int index, unsigned int cluster_id)
int	spread (unsigned int index, epsilon_neighbours_t *seeds, unsigned int cluster_id)
float	dist (point_t *a, point_t *b) const

Private Attributes
double	epsilon
unsigned int	minpts
double	badchannelweight
unsigned int	neighbors
std::map< geo::WireID, int >	badchannelmap

Detailed Description

Definition at line 77 of file DBScan3DAlg.h.

Constructor & Destructor Documentation

cluster::DBScan3DAlg::DBScan3DAlg

(

fhicl::ParameterSet const &

pset

)

Definition at line 18 of file DBScan3DAlg.cxx.

  : epsilon(pset.get< float >("epsilon"))
  , minpts(pset.get<unsigned int>("minpts"))
  , badchannelweight(pset.get<double>("badchannelweight"))
  , neighbors(pset.get<unsigned int>("neighbors"))
{
  // square epsilon to eliminate the use of sqrt later on
  epsilon *= epsilon;
}

Member Function Documentation

int cluster::DBScan3DAlg::append_at_end ( unsigned int  index, epsilon_neighbours_t *  en  )

private

Definition at line 77 of file DBScan3DAlg.cxx.

{
  node_t *n = create_node(index);
  if (n == NULL) {
    free(en);
    return FAILURE;
  }
  if (en->head == NULL) {
    en->head = n;
    en->tail = n;
  } else {
    en->tail->next = n;
    en->tail = n;
  }
  ++(en->num_members);
  return SUCCESS;
}

node_t * cluster::DBScan3DAlg::create_node ( unsigned int  index )

private

Definition at line 65 of file DBScan3DAlg.cxx.

{
  node_t *n = (node_t *) calloc(1, sizeof(node_t));
  if (n == NULL)
    perror("Failed to allocate node.");
  else {
    n->index = index;
    n->next = NULL;
  }
  return n;
}

void cluster::DBScan3DAlg::dbscan

(

)

Definition at line 133 of file DBScan3DAlg.cxx.

{
  unsigned int i, cluster_id = 0;
  for (i = 0; i < points.size(); ++i) {
    if (points[i].cluster_id == UNCLASSIFIED) {
      if (expand(i, cluster_id) == CORE_POINT)
        ++cluster_id;
    }
  }
}

void cluster::DBScan3DAlg::destroy_epsilon_neighbours ( epsilon_neighbours_t *  en )

private

Definition at line 120 of file DBScan3DAlg.cxx.

{
  if (en) {
    node_t *t, *h = en->head;
    while (h) {
      t = h->next;
      free(h);
      h = t;
    }
    free(en);
  }
}

float cluster::DBScan3DAlg::dist ( point_t *  a, point_t *  b  ) const

private

Definition at line 207 of file DBScan3DAlg.cxx.

{
  Double32_t const* a_xyz = a->sp->XYZ();
  Double32_t const* b_xyz = b->sp->XYZ();
  auto const nbadchannels = a->nbadchannels + b->nbadchannels;
  float const dx = a_xyz[0] - b_xyz[0];
  float const dy = a_xyz[1] - b_xyz[1];
  float const dz = a_xyz[2] - b_xyz[2];
  float const dist = cet::sum_of_squares(dx, dy, dz) - cet::square(nbadchannels * badchannelweight);
  // Do not return a distance smaller than 0.
  return std::max(dist, 0.f);
}

int cluster::DBScan3DAlg::expand ( unsigned int  index, unsigned int  cluster_id  )

private

Definition at line 144 of file DBScan3DAlg.cxx.

{
  int return_value = NOT_CORE_POINT;
  epsilon_neighbours_t *seeds =
    get_epsilon_neighbours(index);
  if (seeds == NULL)
    return FAILURE;

  if (seeds->num_members < minpts)
    points[index].cluster_id = NOISE;
  else {
    points[index].cluster_id = cluster_id;
    node_t *h = seeds->head;
    while (h) {
      points[h->index].cluster_id = cluster_id;
      h = h->next;
    }

    h = seeds->head;
    while (h) {
      spread(h->index, seeds, cluster_id);
      h = h->next;
    }

    return_value = CORE_POINT;
  }
  destroy_epsilon_neighbours(seeds);
  return return_value;
}

epsilon_neighbours_t * cluster::DBScan3DAlg::get_epsilon_neighbours ( unsigned int  index )

private

Definition at line 96 of file DBScan3DAlg.cxx.

{
  epsilon_neighbours_t *en = (epsilon_neighbours_t *)
    calloc(1, sizeof(epsilon_neighbours_t));
  if (en == NULL) {
    perror("Failed to allocate epsilon neighbours.");
    return en;
  }
  for (unsigned int i = 0; i < points.size(); ++i) {
    if (i == index)
      continue;
    if (dist(&points[index], &points[i]) > epsilon)
      continue;
    else {
      if (append_at_end(i, en) == FAILURE) {
        destroy_epsilon_neighbours(en);
        en = NULL;
        break;
      }
    }
  }
  return en;
}

void cluster::DBScan3DAlg::init	(	const std::vector< art::Ptr< recob::SpacePoint >> &	sps,
		art::FindManyP< recob::Hit > &	hitFromSp
	)

Definition at line 29 of file DBScan3DAlg.cxx.

{

  if (badchannelmap.empty()){
    lariov::ChannelStatusProvider const& channelStatus = art::ServiceHandle<lariov::ChannelStatusService const>()->GetProvider();
    geo::GeometryCore const* geom = &*(art::ServiceHandle<geo::Geometry const>());
    // build a map to count bad channels around each wire ID
    for (auto &pid : geom->IteratePlaneIDs()){
      for (auto& wid1: geom->IterateWireIDs(pid)) {
        unsigned int nbadchs = 0;
        for (auto& wid2: geom->IterateWireIDs(pid)) {
          if (wid1==wid2) continue;
          if (util::absDiff(wid1.Wire,wid2.Wire)<neighbors &&
              !channelStatus.IsGood(geom->PlaneWireToChannel(wid2))) ++nbadchs;
        }
        badchannelmap[wid1] = nbadchs;
      }
    }
    std::cout<<"Done building bad channel map."<<std::endl;
  }

  points.clear();
  for (auto& spt : sps){
    point_t point;
    point.sp = spt;
    point.cluster_id = UNCLASSIFIED;
    // count bad channels
    point.nbadchannels = 0;
    auto &hits = hitFromSp.at(spt.key());
    for (auto & hit : hits){
      point.nbadchannels += badchannelmap[hit->WireID()];
    }
    points.push_back(point);
  }
}

int cluster::DBScan3DAlg::spread ( unsigned int  index, epsilon_neighbours_t *  seeds, unsigned int  cluster_id  )

private

Definition at line 175 of file DBScan3DAlg.cxx.

{
  epsilon_neighbours_t *spread =
    get_epsilon_neighbours(index);
  if (spread == NULL)
    return FAILURE;
  if (spread->num_members >= minpts) {
    node_t *n = spread->head;
    point_t *d;
    while (n) {
      d = &points[n->index];
      if (d->cluster_id == NOISE ||
          d->cluster_id == UNCLASSIFIED) {
        if (d->cluster_id == UNCLASSIFIED) {
          if (append_at_end(n->index, seeds)
              == FAILURE) {
            destroy_epsilon_neighbours(spread);
            return FAILURE;
          }
        }
        d->cluster_id = cluster_id;
      }
      n = n->next;
    }
  }

  destroy_epsilon_neighbours(spread);
  return SUCCESS;
}

Member Data Documentation

std::map<geo::WireID, int> cluster::DBScan3DAlg::badchannelmap

private

Definition at line 95 of file DBScan3DAlg.h.

double cluster::DBScan3DAlg::badchannelweight

private

Definition at line 93 of file DBScan3DAlg.h.

double cluster::DBScan3DAlg::epsilon

private

Definition at line 91 of file DBScan3DAlg.h.

unsigned int cluster::DBScan3DAlg::minpts

private

Definition at line 92 of file DBScan3DAlg.h.

unsigned int cluster::DBScan3DAlg::neighbors

private

Definition at line 94 of file DBScan3DAlg.h.

std::vector<point_t> cluster::DBScan3DAlg::points

Definition at line 83 of file DBScan3DAlg.h.

---

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

• larreco/larreco/RecoAlg/DBScan3DAlg.h
• larreco/larreco/RecoAlg/DBScan3DAlg.cxx