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 78 of file DBScan3DAlg.h.

Constructor & Destructor Documentation

cluster::DBScan3DAlg::DBScan3DAlg

(

fhicl::ParameterSet const &

pset

)

Definition at line 18 of file DBScan3DAlg.cxx.

References epsilon.

  : 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 80 of file DBScan3DAlg.cxx.

References create_node(), FAILURE, epsilon_neighbours_s::head, n, node_s::next, epsilon_neighbours_s::num_members, SUCCESS, and epsilon_neighbours_s::tail.

Referenced by get_epsilon_neighbours(), and spread().

{
  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 68 of file DBScan3DAlg.cxx.

References node_s::index, n, and node_s::next.

Referenced by append_at_end().

{
  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 134 of file DBScan3DAlg.cxx.

References CORE_POINT, expand(), points, and UNCLASSIFIED.

Referenced by cluster::DBCluster3D::produce().

{
  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 121 of file DBScan3DAlg.cxx.

References epsilon_neighbours_s::head, and node_s::next.

Referenced by expand(), get_epsilon_neighbours(), and spread().

{
  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 200 of file DBScan3DAlg.cxx.

References badchannelweight, f, point_s::nbadchannels, point_s::sp, and recob::SpacePoint::XYZ().

Referenced by get_epsilon_neighbours().

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

References CORE_POINT, destroy_epsilon_neighbours(), FAILURE, get_epsilon_neighbours(), epsilon_neighbours_s::head, node_s::index, minpts, node_s::next, NOISE, NOT_CORE_POINT, epsilon_neighbours_s::num_members, points, tca::seeds, and spread().

Referenced by dbscan().

{
  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 99 of file DBScan3DAlg.cxx.

References append_at_end(), destroy_epsilon_neighbours(), dist(), epsilon, FAILURE, and points.

Referenced by expand(), and spread().

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

References lar::util::absDiff(), badchannelmap, point_s::cluster_id, hits(), geo::GeometryCore::Iterate(), point_s::nbadchannels, neighbors, geo::GeometryCore::PlaneWireToChannel(), points, point_s::sp, and UNCLASSIFIED.

Referenced by cluster::DBCluster3D::produce().

{

  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->Iterate<geo::PlaneID>()) {
      for (auto& wid1 : geom->Iterate<geo::WireID>(pid)) {
        unsigned int nbadchs = 0;
        for (auto& wid2 : geom->Iterate<geo::WireID>(pid)) {
          if (wid1 == wid2) continue;
          if (lar::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 172 of file DBScan3DAlg.cxx.

References append_at_end(), point_s::cluster_id, d, destroy_epsilon_neighbours(), FAILURE, get_epsilon_neighbours(), epsilon_neighbours_s::head, node_s::index, minpts, n, node_s::next, NOISE, epsilon_neighbours_s::num_members, points, SUCCESS, and UNCLASSIFIED.

Referenced by expand().

{
  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 93 of file DBScan3DAlg.h.

Referenced by init().

double cluster::DBScan3DAlg::badchannelweight

private

Definition at line 91 of file DBScan3DAlg.h.

Referenced by dist().

double cluster::DBScan3DAlg::epsilon

private

Definition at line 89 of file DBScan3DAlg.h.

Referenced by DBScan3DAlg(), and get_epsilon_neighbours().

unsigned int cluster::DBScan3DAlg::minpts

private

Definition at line 90 of file DBScan3DAlg.h.

Referenced by expand(), and spread().

unsigned int cluster::DBScan3DAlg::neighbors

private

Definition at line 92 of file DBScan3DAlg.h.

Referenced by init().

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

Definition at line 82 of file DBScan3DAlg.h.

Referenced by dbscan(), expand(), get_epsilon_neighbours(), init(), cluster::DBCluster3D::produce(), and spread().

---

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

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