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 "larcore/Geometry/Geometry.h"
#include "lardata/Utilities/PxUtils.h"
#include "lareventdisplay/EventDisplay/GraphClusterAlg.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;
  }