cluster::DBScan3DAlg Class Reference

#include "DBScan3DAlg.h"

Public Member Functions
	DBScan3DAlg (fhicl::ParameterSet const &pset)
virtual	~DBScan3DAlg ()
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)

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

Detailed Description

Definition at line 75 of file DBScan3DAlg.h.

Constructor & Destructor Documentation

cluster::DBScan3DAlg::DBScan3DAlg

(

fhicl::ParameterSet const &

pset

)

Definition at line 13 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;
}

cluster::DBScan3DAlg::~DBScan3DAlg ( )

virtual

Definition at line 24 of file DBScan3DAlg.cxx.

{
}

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.

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 65 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 133 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 120 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  )

private

Definition at line 207 of file DBScan3DAlg.cxx.

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

Referenced by get_epsilon_neighbours().

{
  float dx = a->sp->XYZ()[0] - b->sp->XYZ()[0];
  float dy = a->sp->XYZ()[1] - b->sp->XYZ()[1];
  float dz = a->sp->XYZ()[2] - b->sp->XYZ()[2];
  float dist = dx*dx + dy*dy + dz*dz - (a->nbadchannels + b->nbadchannels)*(a->nbadchannels + b->nbadchannels)*badchannelweight*badchannelweight;
  //std::cout<<dx*dx + dy*dy + dz*dz<<" "<<(a->nbadchannels + b->nbadchannels)*(a->nbadchannels + b->nbadchannels)*badchannelweight*badchannelweight<<std::endl;
  if ( dist < 0 ) dist = 0;
  return dist;
}

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 96 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 util::absDiff(), badchannelmap, point_s::cluster_id, hits(), geo::GeometryCore::IteratePlaneIDs(), geo::GeometryCore::IterateWireIDs(), 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>()->GetProvider();
    geo::GeometryCore const* geom = &*(art::ServiceHandle<geo::Geometry>());
    // 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.

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

Referenced by init().

double cluster::DBScan3DAlg::badchannelweight

private

Definition at line 92 of file DBScan3DAlg.h.

Referenced by dist().

double cluster::DBScan3DAlg::epsilon

private

Definition at line 90 of file DBScan3DAlg.h.

Referenced by DBScan3DAlg(), and get_epsilon_neighbours().

unsigned int cluster::DBScan3DAlg::minpts

private

Definition at line 91 of file DBScan3DAlg.h.

Referenced by expand(), and spread().

unsigned int cluster::DBScan3DAlg::neighbors

private

Definition at line 93 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:

• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/RecoAlg/DBScan3DAlg.h
• /cvmfs/larsoft.opensciencegrid.org/products/larreco/v07_10_02/source/larreco/RecoAlg/DBScan3DAlg.cxx