GraphClusterAlg.cxx

Go to the documentation of this file.

//
// GraphClusterAlg class
//
// andrzej.szelc@yale.edu
// ellen.klein@yale.edu
//
//  Methods to use by a dummy producer

#include "lareventdisplay/EventDisplay/GraphClusterAlg.h"
#include "larcore/Geometry/Geometry.h"
#include "lardata/Utilities/PxUtils.h"
#include "lareventdisplay/EventDisplay/InfoTransfer.h"

#include "art/Framework/Principal/Event.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

//-------------------------------------------------
evd::GraphClusterAlg::GraphClusterAlg(fhicl::ParameterSet const& pset)
{
  this->reconfigure(pset);
  art::ServiceHandle<geo::Geometry const> geo;

  fNPlanes = geo->Nplanes();
  //     starthit.resize(fNPlanes);
  //     endhit.resize(fNPlanes);

  /*
    swire.resize(fNPlanes);
    ewire.resize(fNPlanes);
    stime.resize(fNPlanes);
    etime.resize(fNPlanes);*/
}

//-------------------------------------------------
void evd::GraphClusterAlg::reconfigure(fhicl::ParameterSet const& /*pset*/)
{

  return;
}

void evd::GraphClusterAlg::GetHitListAndEndPoints(unsigned int plane,
                                                  art::PtrVector<recob::Hit>& ptrhitlist,
                                                  util::PxLine& startendpoints)
{
  GetHitList(plane, ptrhitlist);
  GetStartEndHits(plane, startendpoints);
}

void evd::GraphClusterAlg::GetStartEndHits(unsigned int plane, util::PxLine& startendpoints)
{
  std::vector<double> starthit;
  std::vector<double> endhit;
  art::ServiceHandle<evd::InfoTransfer const> intr;
  starthit = intr->GetStartHitCoords(plane);
  endhit = intr->GetEndHitCoords(plane);

  startendpoints.w0 = starthit[0];
  startendpoints.t0 = starthit[1];
  startendpoints.w1 = endhit[0];
  startendpoints.t1 = endhit[1];
  startendpoints.plane = plane;
}

//   //----------------------------------------------------------------------------
//   void evd::GraphClusterAlg::GetStartEndHits(unsigned int plane)
//   {
//     std::vector < double > starthit;
//     std::vector < double > endhit;
//     art::ServiceHandle<evd::InfoTransfer const> intr;
//     starthit=intr->GetStartHitCoords(plane);
//     endhit=intr->GetEndHitCoords(plane);
//
//
//     swire[plane]=starthit[0];
//     stime[plane]=starthit[1];
//     ewire[plane]=endhit[0];
//     etime[plane]=endhit[1];
//
//   }

//   //----------------------------------------------------------------------------
//   void evd::GraphClusterAlg::GetStartEndHits(unsigned int plane,
//                                   recob::Hit *starthit,
//                                   recob::Hit *endhit)
//   {
//
//     art::ServiceHandle<evd::InfoTransfer const> intr;
//     art::ServiceHandle<geo::Geometry const>  geo;
//
//     starthit=intr->GetStartHit(plane);
//     endhit=intr->GetEndHit(plane);
//
//     // error checking for bogus transfers
//     if(starthit!=NULL){
//       stime[plane] = starthit->PeakTime() ;
//       try{
//      if(starthit->Wire() != NULL){
//        swire[plane] = starthit->WireID().Wire;
//      }
//      else{
//        swire[plane]=0;
//      }
//       }
//       catch(cet::exception e) {
//      mf::LogWarning("GraphClusterAlg") << "caught exception \n"
//                                     << e;
//      swire[plane]=0;
//       }
//     }
//     else{
//       stime[plane]=0.;
//     }
//
//     if(endhit!=NULL){
//       etime[plane] = endhit->PeakTime();
//       if(endhit->Wire()!=NULL){
//      ewire[plane] = endhit->WireID().Wire;
//       }
//       else{
//      ewire[plane]=0;
//       }
//     }
//     else{
//       etime[plane]=0.;
//     }
//
//   }

//----------------------------------------------------------------------------
//  void evd::GraphClusterAlg::GetHitList(unsigned int plane,std::vector< art::Ptr <recob::Hit> > ptrhitlist)
//  {
//   art::ServiceHandle<evd::InfoTransfer const> intr;
//
//
//   ptrhitlist=intr->GetHitList(plane);
//   //std::vector <recob::Hit *> hitlist_out;
//
//   if(ptrhitlist.size()==0) {
//      WriteMsg("hit list of zero size, please select some hits");
//              return;
//      }
//
//    for(art::PtrVector<recob::Hit>::const_iterator hitIter = ptrhitlist.begin(); hitIter != ptrhitlist.end();  hitIter++){
// //   art::Ptr<recob::Hit> theHit = (*hitIter);
// //   unsigned int plane,cstat,tpc,wire;
// //   hitlist_out.push_back((*hitIter)->Get());
//      }
//
//
//
//
//    return;// hitlist_out;
//  }

//----------------------------------------------------------------------------
void evd::GraphClusterAlg::GetHitList(unsigned int plane, art::PtrVector<recob::Hit>& ptrhitlist)
{
  art::ServiceHandle<evd::InfoTransfer const> intr;

  std::vector<art::Ptr<recob::Hit>> ptlist = intr->GetHitList(plane);

  //std::vector <recob::Hit *> hitlist_out;

  if (ptlist.size() == 0) {
    mf::LogVerbatim("GraphClusterAlg") << ("hit list of zero size, please select some hits");
    return;
  }

  for (art::PtrVector<recob::Hit>::const_iterator hitIter = ptlist.begin(); hitIter != ptlist.end();
       hitIter++) {
    //  art::Ptr<recob::Hit> theHit = (*hitIter);
    //  unsigned int plane,cstat,tpc,wire;
    ptrhitlist.push_back((*hitIter));
  }

  return; // hitlist_out;
}

//----------------------------------------------------------------------------
std::vector<util::PxLine> evd::GraphClusterAlg::GetSeedLines()
{

  art::ServiceHandle<evd::InfoTransfer const> intr;
  //this is where you could create Bezier Tracks if you wanted to do it inside a producer
  std::vector<util::PxLine> plines = intr->GetSeedList();

  std::cout << " Received Seed List of Size: " << plines.size() << std::endl;

  return plines;
}

int evd::GraphClusterAlg::CheckValidity(art::Event& evt)
{
  art::ServiceHandle<evd::InfoTransfer const> intr;
  TestFlag = intr->GetTestFlag();

  fEvent = intr->GetEvtNumber();
  fRun = intr->GetRunNumber();
  fSubRun = intr->GetSubRunNumber();

  if (TestFlag == -1) return -1;

  if (fEvent != (int)evt.id().event() || fRun != (int)evt.id().run() ||
      fSubRun != (int)evt.id().subRun()) {
    mf::LogVerbatim("GraphClusterAlg") << (" old event ");
    return -1;
  }

  return TestFlag;
}