cluster::LineMerger Class Reference

Inheritance diagram for cluster::LineMerger:

Public Member Functions
	LineMerger (fhicl::ParameterSet const &pset)

Private Member Functions
void	produce (art::Event &evt) override
bool	SlopeCompatibility (double slope1, double slope2)
int	EndpointCompatibility (float sclstartwire, float sclstarttime, float sclendwire, float sclendtime, float cl2startwire, float cl2starttime, float cl2endwire, float cl2endtime)

Private Attributes
std::string	fClusterModuleLabel
double	fSlope
double	fEndpointWindow

Detailed Description

Definition at line 47 of file LineMerger_module.cc.

Constructor & Destructor Documentation

cluster::LineMerger::LineMerger ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 467 of file LineMerger_module.cc.

    : EDProducer{pset}
    , fClusterModuleLabel(pset.get<std::string>("ClusterModuleLabel"))
    , fSlope(pset.get<double>("Slope"))
    , fEndpointWindow(pset.get<double>("EndpointWindow"))
  {
    produces<std::vector<recob::Cluster>>();
    produces<art::Assns<recob::Cluster, recob::Hit>>();
  }

Member Function Documentation

int cluster::LineMerger::EndpointCompatibility ( float  sclstartwire, float  sclstarttime, float  sclendwire, float  sclendtime, float  cl2startwire, float  cl2starttime, float  cl2endwire, float  cl2endtime  )

private

Todo:

13.5 ticks/wire. need to make this detector agnostic–spitz

Definition at line 650 of file LineMerger_module.cc.

  {

    /// \todo 13.5 ticks/wire. need to make this detector agnostic--spitz
    float distance =
      std::sqrt((pow(sclendwire - cl2startwire, 2) * 13.5) + pow(sclendtime - cl2starttime, 2));

    //not sure if this line is necessary--spitz
    float distance2 =
      std::sqrt((pow(sclstartwire - cl2endwire, 2) * 13.5) + pow(sclstarttime - cl2endtime, 2));

    //determine which way the two clusters should be merged. TY
    int comp = 0;
    if (distance < fEndpointWindow)
      comp = 1;
    else if (distance2 < fEndpointWindow)
      comp = -1;
    return comp;
  }

void cluster::LineMerger::produce ( art::Event &  evt )

overrideprivate

Definition at line 479 of file LineMerger_module.cc.

  {
    // Get a Handle for the input Cluster object(s).
    art::Handle<std::vector<recob::Cluster>> clusterVecHandle;
    evt.getByLabel(fClusterModuleLabel, clusterVecHandle);

    auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
    auto const detProp =
      art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clockData);
    util::GeometryUtilities const gser{*lar::providerFrom<geo::Geometry>(), clockData, detProp};

    constexpr size_t nViews = 3; // number of views we map

    //one vector for each view in the geometry (holds the index of the cluster)
    std::array<std::vector<size_t>, nViews> ClsIndices;

    //vector with indicators for whether a cluster has been merged already
    std::array<std::vector<int>, nViews> Cls_matches;

    // loop over the input Clusters
    for (size_t i = 0; i < clusterVecHandle->size(); ++i) {

      //get a art::Ptr to each Cluster
      art::Ptr<recob::Cluster> cl(clusterVecHandle, i);

      size_t view = 0;
      switch (cl->View()) {
      case geo::kU: view = 0; break;
      case geo::kV: view = 1; break;
      case geo::kZ: view = 2; break;
      default: continue; // ignore this cluster and process the next one
      }                  // end switch on view

      Cls_matches[view].push_back(0);
      ClsIndices[view].push_back(i);
    } // end loop over input clusters

    auto SuperClusters = std::make_unique<std::vector<recob::Cluster>>();
    auto assn = std::make_unique<art::Assns<recob::Cluster, recob::Hit>>();

    // prepare the algorithm to compute the cluster characteristics;
    // we use the "standard" one here; configuration would happen here,
    // but we are using the default configuration for that algorithm
    ClusterParamsImportWrapper<StandardClusterParamsAlg> ClusterParamAlgo;

    art::FindManyP<recob::Hit> fmh(clusterVecHandle, evt, fClusterModuleLabel);

    for (size_t i = 0; i < nViews; ++i) {

      int clustersfound = 0; // how many merged clusters found in each plane
      int clsnum1 = 0;

      for (size_t c = 0; c < ClsIndices[i].size(); ++c) {
        if (Cls_matches[i][clsnum1] == 1) {
          ++clsnum1;
          continue;
        }

        // make a new cluster to put into the SuperClusters collection
        // because we want to be able to adjust it later;
        // use the hits associated with the current cluster
        recob::Cluster const& StartingCluster = clusterVecHandle->at(ClsIndices[i][c]);
        ClusterAndHitMerger cl1(StartingCluster, fmh.at(ClsIndices[i][c]));
        const recob::Cluster::ID_t clusterID = StartingCluster.ID();

        Cls_matches[i][clsnum1] = 1;
        ++clustersfound;

        int clsnum2 = 0;
        for (size_t c2 = 0; c2 < ClsIndices[i].size(); ++c2) {

          if (Cls_matches[i][clsnum2] == 1) {
            ++clsnum2;
            continue;
          }

          const recob::Cluster& cl2(clusterVecHandle->at(ClsIndices[i][c2]));

          // check that the slopes are the same
          // added 13.5 ticks/wirelength in ArgoNeuT.
          // \todo need to make this detector agnostic
          // would be nice to have a LArProperties function that returns ticks/wire.
          bool sameSlope = SlopeCompatibility(cl1.StartAngle(), cl2.EndAngle()) ||
                           SlopeCompatibility(cl1.EndAngle(), cl2.StartAngle());

          // check that the endpoints fall within a circular window of each other
          // done in place of intercept matching
          int sameEndpoint = EndpointCompatibility(cl1.StartWire(),
                                                   cl1.StartTick(),
                                                   cl1.EndWire(),
                                                   cl1.EndTick(),
                                                   cl2.StartWire(),
                                                   cl2.StartTick(),
                                                   cl2.EndWire(),
                                                   cl2.EndTick());

          // if the slopes and end points are the same, combine the clusters
          // note that after 1 combination cl1 is no longer what we started
          // with
          if (sameSlope && (sameEndpoint != 0)) {
            // combine the hit collections too
            // (find the hits associated with this second cluster);
            // take into account order when merging hits from two clusters: doc-1776
            // if sameEndpoint is 1, the new hits come first
            cl1.Add(cl2, fmh.at(ClsIndices[i][c2]), sameEndpoint == 1);
            Cls_matches[i][clsnum2] = 1;
          }

          ++clsnum2;
        } // end loop over second cluster iterator

        // now add the final version of cl1 to the collection of SuperClusters
        // and create the association between the super cluster and the hits
        ClusterParamAlgo.ImportHits(gser, cl1.Hits());

        // create the recob::Cluster directly in the vector
        SuperClusters->emplace_back(cl1.StartWire(),                            // start_wire
                                    cl1.SigmaStartWire(),                       // sigma_start_wire
                                    cl1.StartTick(),                            // start_tick
                                    cl1.SigmaStartTick(),                       // sigma_start_tick
                                    cl1.StartCharge(),                          // start_charge
                                    cl1.StartAngle(),                           // start_angle
                                    cl1.StartOpeningAngle(),                    // start_opening
                                    cl1.EndWire(),                              // end_wire
                                    cl1.SigmaEndWire(),                         // sigma_end_wire
                                    cl1.EndTick(),                              // end_time
                                    cl1.SigmaEndTick(),                         // sigma_end_tick
                                    cl1.EndCharge(),                            // end_charge
                                    cl1.EndAngle(),                             // end_angle
                                    cl1.EndOpeningAngle(),                      // end_opening
                                    ClusterParamAlgo.Integral().value(),        // integral
                                    ClusterParamAlgo.IntegralStdDev().value(),  // integral_stddev
                                    ClusterParamAlgo.SummedADC().value(),       // summedADC
                                    ClusterParamAlgo.SummedADCStdDev().value(), // summedADC_stddev
                                    ClusterParamAlgo.NHits(),                   // n_hits
                                    ClusterParamAlgo.MultipleHitDensity(), // multiple_hit_density
                                    cl1.Width(),                           // width
                                    clusterID,                             // ID
                                    cl1.View(),                            // view
                                    cl1.Plane(),                           // planeID
                                    recob::Cluster::Sentry                 // sentry
        );

        util::CreateAssn(evt, *SuperClusters, cl1.Hits(), *assn);
        ++clsnum1;

      } // end loop over first cluster iterator
    }   // end loop over planes

    mf::LogVerbatim("Summary") << std::setfill('-') << std::setw(175) << "-" << std::setfill(' ');
    mf::LogVerbatim("Summary") << "LineMerger Summary:";
    for (size_t i = 0; i < SuperClusters->size(); ++i)
      mf::LogVerbatim("Summary") << SuperClusters->at(i);

    evt.put(std::move(SuperClusters));
    evt.put(std::move(assn));
  }

bool cluster::LineMerger::SlopeCompatibility ( double  slope1, double  slope2  )

private

Definition at line 640 of file LineMerger_module.cc.

  {
    double sl1 = atan(slope1);
    double sl2 = atan(slope2);

    //the units of fSlope are radians
    return std::abs(sl1 - sl2) < fSlope;
  }

Member Data Documentation

std::string cluster::LineMerger::fClusterModuleLabel

private

Definition at line 54 of file LineMerger_module.cc.

double cluster::LineMerger::fEndpointWindow

private

Definition at line 56 of file LineMerger_module.cc.

double cluster::LineMerger::fSlope

private

Definition at line 55 of file LineMerger_module.cc.

---

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

• LineMerger_module.cc