cnn::RegCNNEvaluator Class Reference

Inheritance diagram for cnn::RegCNNEvaluator:

Public Member Functions
	RegCNNEvaluator (fhicl::ParameterSet const &pset)
	~RegCNNEvaluator ()
void	produce (art::Event &evt)
void	beginJob ()
void	endJob ()
Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)
template<typename Config >
	EDProducer (Table< Config > const &config)
std::string	workerType () const
Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept
	Producer (fhicl::ParameterSet const &)
	Producer (Producer const &)=delete
	Producer (Producer &&)=delete
Producer &	operator= (Producer const &)=delete
Producer &	operator= (Producer &&)=delete
void	doBeginJob (SharedResources const &resources)
void	doEndJob ()
void	doRespondToOpenInputFile (FileBlock const &fb)
void	doRespondToCloseInputFile (FileBlock const &fb)
void	doRespondToOpenOutputFiles (FileBlock const &fb)
void	doRespondToCloseOutputFiles (FileBlock const &fb)
bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)
Public Member Functions inherited from art::Modifier
	~Modifier () noexcept
	Modifier ()
	Modifier (Modifier const &)=delete
	Modifier (Modifier &&)=delete
Modifier &	operator= (Modifier const &)=delete
Modifier &	operator= (Modifier &&)=delete
Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept
	ModuleBase ()
ModuleDescription const &	moduleDescription () const
void	setModuleDescription (ModuleDescription const &)
std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const
void	sortConsumables (std::string const &current_process_name)
template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)
template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
void	PrepareEvent (const art::Event &event)
bool	insideContVol (const double posX, const double posY, const double posZ)
void	getCM (const RegPixelMap &pm, std::vector< float > &cm_list)

Private Attributes
art::ServiceHandle< geo::Geometry >	fGeom
std::string	fPixelMapInput
std::string	fResultLabel
std::string	fCNNType
std::string	fTarget
cnn::TFRegNetHandler	fTFHandler
cnn::RegCNNVtxHandler	fRegCNNVtxHandler
cnn::RegCNNNumuHandler	fRegCNNNumuHandler
std::string	fHitsModuleLabel
std::string	fTrackModuleLabel
double	fContVolCut
bool	fLongestTrackContained

Additional Inherited Members
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer
using	WorkerType = WorkerT< EDProducer >
Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >
Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >
Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)
Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()
template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)
template<typename T , BranchType = InEvent>
void	consumesMany ()
template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)
template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 56 of file RegCNNEvaluator_module.cc.

Constructor & Destructor Documentation

cnn::RegCNNEvaluator::RegCNNEvaluator ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 96 of file RegCNNEvaluator_module.cc.

                                                               :
    EDProducer(pset),
    fPixelMapInput     (pset.get<std::string>         ("PixelMapInput")),
    fResultLabel       (pset.get<std::string>         ("ResultLabel")),
    fCNNType           (pset.get<std::string>         ("CNNType")),
    fTarget            (pset.get<std::string>         ("Target")),
    fTFHandler         (pset.get<fhicl::ParameterSet> ("TFNetHandler")),
    fRegCNNVtxHandler  (pset.get<fhicl::ParameterSet> ("RegCNNVtxHandler")),
    fRegCNNNumuHandler (pset.get<fhicl::ParameterSet> ("RegCNNNumuHandler")),
    fHitsModuleLabel   (pset.get<std::string>         ("HitsModuleLabel")),
    fTrackModuleLabel  (pset.get<std::string>         ("TrackModuleLabel")),
    fContVolCut        (pset.get<double>              ("ContVolCut"))
  {
    produces< std::vector<cnn::RegCNNResult> >(fResultLabel);
  }

cnn::RegCNNEvaluator::~RegCNNEvaluator

(

)

Definition at line 113 of file RegCNNEvaluator_module.cc.

  {
    //======================================================================
    // Clean up any memory allocated by your module
    //======================================================================
  }

Member Function Documentation

void cnn::RegCNNEvaluator::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 121 of file RegCNNEvaluator_module.cc.

  {  
  }

void cnn::RegCNNEvaluator::endJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 126 of file RegCNNEvaluator_module.cc.

  {
  }

void cnn::RegCNNEvaluator::getCM ( const RegPixelMap &  pm, std::vector< float > &  cm_list  )

private

Definition at line 131 of file RegCNNEvaluator_module.cc.

  {
    //std::cout << pm.fBound.fFirstWire[0]+pm.fNWire/2 << std::endl;
    //std::cout << pm.fBound.fFirstTDC[0]+pm.fNTdc*pm.fNTRes/2 << std::endl;
    for (int ii = 0; ii < 3; ii++){
        float mean_wire = pm.fBound.fFirstWire[ii]+pm.fNWire*pm.fNWRes/2;
        float mean_tdc  = pm.fBound.fFirstTDC[ii]+pm.fNTdc*pm.fNTRes/2;
        cm_list[2*ii] = mean_tdc;
        cm_list[2*ii+1] = mean_wire;
    }
  }

bool cnn::RegCNNEvaluator::insideContVol ( const double  posX, const double  posY, const double  posZ  )

private

Definition at line 253 of file RegCNNEvaluator_module.cc.

                                                                                             {
      double vtx[3] = {posX, posY, posZ};
      bool inside = false;

      geo::TPCID idtpc = fGeom->FindTPCAtPosition(vtx);

      if (fGeom->HasTPC(idtpc)) {
          const geo::TPCGeo& tpcgeo = fGeom->GetElement(idtpc);
          double minx = tpcgeo.MinX(); double maxx = tpcgeo.MaxX();
          double miny = tpcgeo.MinY(); double maxy = tpcgeo.MaxY();
          double minz = tpcgeo.MinZ(); double maxz = tpcgeo.MaxZ();

          for (size_t c = 0; c < fGeom->Ncryostats(); c++) {
              const geo::CryostatGeo& cryostat = fGeom->Cryostat(c);
              for (size_t t = 0; t < cryostat.NTPC(); t++) {
                  const geo::TPCGeo& tpcg = cryostat.TPC(t);
                  if (tpcg.MinX() < minx) minx = tpcg.MinX();
                  if (tpcg.MaxX() > maxx) maxx = tpcg.MaxX();
                  if (tpcg.MinY() < miny) miny = tpcg.MinY();
                  if (tpcg.MaxY() > maxy) maxy = tpcg.MaxY();
                  if (tpcg.MinZ() < minz) minz = tpcg.MinZ();
                  if (tpcg.MaxZ() > maxz) maxz = tpcg.MaxZ();
              }
          }

          //x
          double dista = fabs(minx - posX);
          double distb = fabs(posX - maxx);
          if ((posX > minx) && (posX < maxx) &&
                  (dista > fContVolCut) && (distb > fContVolCut)) inside = true;
          //y
          dista = fabs(maxy - posY);
          distb = fabs(posY - miny);
          if (inside && (posY > miny) && (posY < maxy) &&
                  (dista > fContVolCut) && (distb > fContVolCut)) inside = true;
          else inside = false;
          //z
          dista = fabs(maxz - posZ);
          distb = fabs(posZ - minz);
          if (inside && (posZ > minz) && (posZ < maxz) &&
                  (dista > fContVolCut) && (distb > fContVolCut)) inside = true;
          else inside = false;
      }

      return inside;
  }

void cnn::RegCNNEvaluator::PrepareEvent ( const art::Event &  event )

private

Definition at line 210 of file RegCNNEvaluator_module.cc.

                                                        {
      // Hits
      auto hitListHandle = evt.getValidHandle<std::vector<recob::Hit>>(fHitsModuleLabel);

      // Tracks
      std::vector<art::Ptr<recob::Track> > tracklist;
      auto trackListHandle = evt.getHandle< std::vector<recob::Track> >(fTrackModuleLabel);
      if (trackListHandle)
          art::fill_ptr_vector(tracklist, trackListHandle);

      // Associations
      art::FindManyP<recob::Hit> fmth(trackListHandle, evt, fTrackModuleLabel);
      art::FindManyP<recob::SpacePoint> fmhs(hitListHandle, evt, fTrackModuleLabel);

      int ntracks = tracklist.size();

      double fMaxTrackLength = -1.0;
      int iLongestTrack = -1;
      // loop over tracks to find the longest track
      for (int i = 0; i < ntracks; ++i){
          if(tracklist[i]->Length() > fMaxTrackLength){
              fMaxTrackLength = tracklist[i]->Length();
              iLongestTrack = i;
          }
      }

      fLongestTrackContained = true;
      if (iLongestTrack >= 0 && iLongestTrack <= ntracks-1) {
          if (fmth.isValid()) {
              std::vector< art::Ptr<recob::Hit> > vhit = fmth.at(iLongestTrack);
              for (size_t h = 0; h < vhit.size(); ++h) {
                  if (vhit[h]->WireID().Plane == 2) {
                      std::vector< art::Ptr<recob::SpacePoint> > spts = fmhs.at(vhit[h].key());
                      if (spts.size()) {
                          if (!insideContVol(spts[0]->XYZ()[0], spts[0]->XYZ()[1], spts[0]->XYZ()[2]))
                              fLongestTrackContained = false;
                      }
                  }
              }
          }
      } // End of search longestTrack
  }

void cnn::RegCNNEvaluator::produce ( art::Event &  evt )

virtual

Define containers for the things we're going to produce

Load in the pixel maps

Load 3D pixel map for direction reco.

Make sure we have a valid name for the CNN type

Implements art::EDProducer.

Definition at line 144 of file RegCNNEvaluator_module.cc.

  {

    this->PrepareEvent(evt);

    /// Define containers for the things we're going to produce
    std::unique_ptr< std::vector<RegCNNResult> >
                                  resultCol(new std::vector<RegCNNResult>);

    /// Load in the pixel maps
    std::vector< art::Ptr< cnn::RegPixelMap > > pixelmaplist;
    art::InputTag itag1(fPixelMapInput, fPixelMapInput);
    auto pixelmapListHandle = evt.getHandle< std::vector< cnn::RegPixelMap > >(itag1);
    if (pixelmapListHandle){
      art::fill_ptr_vector(pixelmaplist, pixelmapListHandle);
    }

    /// Load 3D pixel map for direction reco.
    std::vector< art::Ptr< cnn::RegPixelMap3D > > pixelmap3Dlist;
    art::InputTag itag2(fPixelMapInput, fPixelMapInput);
    auto pixelmap3DListHandle = evt.getHandle< std::vector< cnn::RegPixelMap3D > >(itag2);
    if (pixelmap3DListHandle) {
        art::fill_ptr_vector(pixelmap3Dlist, pixelmap3DListHandle);
    }

    /// Make sure we have a valid name for the CNN type
    if(fCNNType == "TF" || fCNNType == "Tensorflow" || fCNNType == "TensorFlow"){
        // If we have a pixel map then use the TF interface to give us a prediction
        if(pixelmaplist.size() > 0){
            std::vector<float> networkOutput;
            if (fTarget == "nueenergy"){
                networkOutput = fTFHandler.Predict(*pixelmaplist[0]);
                //std::cout << "-->" << networkOutput[0] << std::endl;
            }
            else if (fTarget == "nuevertex"){
                std::vector<float> center_of_mass(6,0);
                getCM(*pixelmaplist[0], center_of_mass);
                std::cout << "cm: " << center_of_mass[0] << " " << center_of_mass[1] << " " << center_of_mass[2] << std::endl;
                networkOutput = fTFHandler.Predict(*pixelmaplist[0], center_of_mass);
                std::cout << "cnn nuevertex : "<<networkOutput[0] << " " << networkOutput[1] << " " << networkOutput[2] << std::endl;
            }
            else if (fTarget == "nuevertex_on_img"){
                auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
                auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clockData);
                networkOutput = fRegCNNVtxHandler.GetVertex(clockData, detProp, evt, *pixelmaplist[0]);
            } 
            else if (fTarget == "numuenergy") {
                networkOutput = fRegCNNNumuHandler.Predict(*pixelmaplist[0], fLongestTrackContained);
            }
            else {
                std::cout << "Wrong Target with 2D 3-view pixel maps" << std::endl;
                abort();
            }

            // cnn::Result can now take a vector of floats and works out the number of outputs
            resultCol->emplace_back(networkOutput);
        }
    } else {
        mf::LogError("RegCNNEvaluator::produce") << "CNN Type not in the allowed list: Tensorflow, Torch" << std::endl;
        mf::LogError("RegCNNEvaluator::produce") << "Exiting without processing events" << std::endl;
        return;
    } // end fCNNType

    evt.put(std::move(resultCol), fResultLabel);
  }

Member Data Documentation

std::string cnn::RegCNNEvaluator::fCNNType

private

Definition at line 77 of file RegCNNEvaluator_module.cc.

double cnn::RegCNNEvaluator::fContVolCut

private

Definition at line 87 of file RegCNNEvaluator_module.cc.

art::ServiceHandle<geo::Geometry> cnn::RegCNNEvaluator::fGeom

private

Definition at line 72 of file RegCNNEvaluator_module.cc.

std::string cnn::RegCNNEvaluator::fHitsModuleLabel

private

Definition at line 84 of file RegCNNEvaluator_module.cc.

bool cnn::RegCNNEvaluator::fLongestTrackContained

private

Definition at line 90 of file RegCNNEvaluator_module.cc.

std::string cnn::RegCNNEvaluator::fPixelMapInput

private

Definition at line 75 of file RegCNNEvaluator_module.cc.

cnn::RegCNNNumuHandler cnn::RegCNNEvaluator::fRegCNNNumuHandler

private

Definition at line 82 of file RegCNNEvaluator_module.cc.

cnn::RegCNNVtxHandler cnn::RegCNNEvaluator::fRegCNNVtxHandler

private

Definition at line 81 of file RegCNNEvaluator_module.cc.

std::string cnn::RegCNNEvaluator::fResultLabel

private

Definition at line 76 of file RegCNNEvaluator_module.cc.

std::string cnn::RegCNNEvaluator::fTarget

private

Definition at line 78 of file RegCNNEvaluator_module.cc.

cnn::TFRegNetHandler cnn::RegCNNEvaluator::fTFHandler

private

Definition at line 80 of file RegCNNEvaluator_module.cc.

std::string cnn::RegCNNEvaluator::fTrackModuleLabel

private

Definition at line 85 of file RegCNNEvaluator_module.cc.

---

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

• dunereco/dunereco/RegCNN/art/RegCNNEvaluator_module.cc