Inheritance diagram for vertex::HarrisVertexFinder:

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

template<typename UserConfig , typename KeysToIgnore = void>
using	Table = ProducerBase::Table< UserConfig, KeysToIgnore >

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

virtual	~HarrisVertexFinder ()

void	beginJob ()

void	produce (art::Event &evt)

template<typename PROD , BranchType B = InEvent>
ProductID	getProductID (std::string const &instanceName={}) const

template<typename PROD , BranchType B>
ProductID	getProductID (ModuleDescription const &moduleDescription, std::string const &instanceName) const

bool	modifiesEvent () const

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	consumes (InputTag const &it)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	consumesView (InputTag const &it)

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename T , art::BranchType BT>
art::ProductToken< T >	mayConsume (InputTag const &it)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , art::BranchType BT>
art::ViewToken< T >	mayConsumeView (InputTag const &it)

base_engine_t &	createEngine (seed_t seed)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)

seed_t	get_seed_value (fhicl::ParameterSet const &pset, char const key[]="seed", seed_t const implicit_seed=-1)

Static Public Member Functions
static cet::exempt_ptr< Consumer >	non_module_context ()

Protected Member Functions
CurrentProcessingContext const *	currentContext () const

void	validateConsumedProduct (BranchType const bt, ProductInfo const &pi)

void	prepareForJob (fhicl::ParameterSet const &pset)

void	showMissingConsumes () const

Private Member Functions
double	Gaussian (int x, int y, double sigma)

double	GaussianDerivativeX (int x, int y)

double	GaussianDerivativeY (int x, int y)

void	SaveBMPFile (const char fileName, unsigned char pix, int dx, int dy)

Private Attributes
std::string	fDBScanModuleLabel

int	fTimeBins

int	fMaxCorners

double	fGsigma

int	fWindow

double	fThreshold

int	fSaveVertexMap

TH2F *	fNoVertices

Detailed Description

Definition at line 64 of file HarrisVertexFinder_module.cc.

Member Typedef Documentation

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 34 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::EDProducer::Table = ProducerBase::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 43 of file EDProducer.h.

using art::EDProducer::WorkerType = WorkerT<EDProducer>

inherited

Definition at line 35 of file EDProducer.h.

Constructor & Destructor Documentation

vertex::HarrisVertexFinder::HarrisVertexFinder ( fhicl::ParameterSet const & pset )

explicit

Definition at line 95 of file HarrisVertexFinder_module.cc.

   : fDBScanModuleLabel  (pset.get< std::string >("DBScanModuleLabel"))
   , fTimeBins        (pset.get< int         >("TimeBins")      )
   , fMaxCorners      (pset.get< int         >("MaxCorners")    )
   , fGsigma          (pset.get< double      >("Gsigma")        )
   , fWindow          (pset.get< int         >("Window")        )
   , fThreshold       (pset.get< double      >("Threshold")     )
   , fSaveVertexMap   (pset.get< int         >("SaveVertexMap") )
 {
   produces< std::vector<recob::EndPoint2D> >();
   produces< art::Assns<recob::EndPoint2D, recob::Hit> >();
 }

vertex::HarrisVertexFinder::~HarrisVertexFinder ( )

virtual

Definition at line 109 of file HarrisVertexFinder_module.cc.

110 {

111 }

Member Function Documentation

void vertex::HarrisVertexFinder::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 113 of file HarrisVertexFinder_module.cc.

References fNoVertices, and art::TFileDirectory::make().

                                        {
   // get access to the TFile service
   art::ServiceHandle<art::TFileService> tfs;
 
   fNoVertices= tfs->make<TH2F>("fNoVertices", ";Event No; No of vertices", 100,0, 100, 30, 0, 30);
 
 }

template<typename T , BranchType = InEvent>

ProductToken<T> art::Consumer::consumes ( InputTag const & )

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::consumes ( InputTag const & it )

inherited

Definition at line 147 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::consumesMany ( )

inherited

Definition at line 162 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::Consumer::consumesView ( InputTag const & )

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::consumesView ( InputTag const & it )

inherited

Definition at line 172 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t seed )

inherited

Definition at line 26 of file EngineCreator.cc.

References art::EngineCreator::rng().

Referenced by evgen::CosmicsGen::CosmicsGen(), rndm::NuRandomService::createEngine(), cluster::fuzzyCluster::fuzzyCluster(), cluster::HoughLineFinder::HoughLineFinder(), art::MixFilter< T >::initEngine_(), larg4::LArG4::LArG4(), evgen::LightSource::LightSource(), evgen::NeutronOsc::NeutronOsc(), evgen::NucleonDecay::NucleonDecay(), opdet::OpMCDigi::OpMCDigi(), opdet::OptDetDigitizer::OptDetDigitizer(), phot::PhotonLibraryPropagation::PhotonLibraryPropagation(), detsim::SimDriftElectrons::SimDriftElectrons(), evgen::SingleGen::SingleGen(), evgen::SNNueAr40CCGen::SNNueAr40CCGen(), ToyOneShowerGen::ToyOneShowerGen(), and trkf::Track3DKalman::Track3DKalman().

 {
   return rng()->createEngine(placeholder_schedule_id(), seed);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make
	)

inherited

Definition at line 32 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make,
		label_t const &	engine_label
	)

inherited

Definition at line 40 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make, engine_label);
 }

CurrentProcessingContext const * art::EDProducer::currentContext ( ) const

protectedinherited

Definition at line 120 of file EDProducer.cc.

References art::EDProducer::current_context_.

   {
     return current_context_.get();
   }

double vertex::HarrisVertexFinder::Gaussian	(	int	x,
		int	y,
		double	sigma
	)

private

Definition at line 122 of file HarrisVertexFinder_module.cc.

References fhicl::detail::atom::value().

Referenced by produce().

 {
   double Norm  = 1./std::sqrt(2*TMath::Pi()*pow(sigma,2));
   double value = Norm*exp(-(pow(x,2)+pow(y,2))/(2*pow(sigma,2)));
   return value;
 }

double vertex::HarrisVertexFinder::GaussianDerivativeX	(	int	x,
		int	y
	)

private

Definition at line 130 of file HarrisVertexFinder_module.cc.

References fGsigma, fhicl::detail::atom::value(), and x.

Referenced by produce().

 {
   double Norm  = 1./(std::sqrt(2*TMath::Pi())*pow(fGsigma,3));
   double value = Norm*(-x)*exp(-(pow(x,2)+pow(y,2))/(2*pow(fGsigma,2)));
   return value;
 }

double vertex::HarrisVertexFinder::GaussianDerivativeY	(	int	x,
		int	y
	)

private

Definition at line 138 of file HarrisVertexFinder_module.cc.

References fGsigma, fhicl::detail::atom::value(), and y.

Referenced by produce().

 {
   double Norm  = 1./(std::sqrt(2*TMath::Pi())*pow(fGsigma,3));
   double value = Norm*(-y)*exp(-(pow(x,2)+pow(y,2))/(2*pow(fGsigma,2)));
   return value;
 }

EngineCreator::seed_t EngineCreator::get_seed_value	(	fhicl::ParameterSet const &	pset,
		char const	key[] = `"seed"`,
		seed_t const	implicit_seed = `-1`
	)

inherited

Definition at line 49 of file EngineCreator.cc.

References fhicl::ParameterSet::get().

Referenced by art::MixFilter< T >::initEngine_().

 {
   auto const& explicit_seeds = pset.get<std::vector<int>>(key, {});
   return explicit_seeds.empty() ? implicit_seed : explicit_seeds.front();
 }

template<typename PROD , BranchType B>

ProductID art::EDProducer::getProductID ( std::string const & instanceName = {} ) const

inlineinherited

Definition at line 123 of file EDProducer.h.

References art::EDProducer::moduleDescription_.

   {
     return ProducerBase::getProductID<PROD, B>(moduleDescription_,
                                                instanceName);
   }

template<typename PROD , BranchType B>

ProductID art::ProducerBase::getProductID	(	ModuleDescription const &	moduleDescription,
		std::string const &	instanceName
	)		const

inherited

Definition at line 56 of file ProducerBase.h.

References B, and art::ModuleDescription::moduleLabel().

Referenced by art::ProducerBase::modifiesEvent().

   {
     auto const& pd =
       get_ProductDescription<PROD>(B, md.moduleLabel(), instanceName);
     return pd.productID();
   }

template<typename T , BranchType = InEvent>

ProductToken<T> art::Consumer::mayConsume ( InputTag const & )

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::mayConsume ( InputTag const & it )

inherited

Definition at line 190 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::mayConsumeMany ( )

inherited

Definition at line 205 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::Consumer::mayConsumeView ( InputTag const & )

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::mayConsumeView ( InputTag const & it )

inherited

Definition at line 215 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

bool art::ProducerBase::modifiesEvent ( ) const

inlineinherited

Definition at line 40 of file ProducerBase.h.

References art::ProducerBase::getProductID().

     {
       return true;
     }

cet::exempt_ptr< art::Consumer > art::Consumer::non_module_context ( )

staticinherited

Definition at line 76 of file Consumer.cc.

 {
   static Consumer invalid{InvalidTag{}};
   return &invalid;
 }

void art::Consumer::prepareForJob ( fhicl::ParameterSet const & pset )

protectedinherited

Definition at line 89 of file Consumer.cc.

References fhicl::ParameterSet::get_if_present().

Referenced by art::EDProducer::doBeginJob(), art::EDFilter::doBeginJob(), and art::EDAnalyzer::doBeginJob().

 {
   if (!moduleContext_)
     return;
 
   pset.get_if_present("errorOnMissingConsumes", requireConsumes_);
   for (auto& consumablesPerBranch : consumables_) {
     cet::sort_all(consumablesPerBranch);
   }
 }

void vertex::HarrisVertexFinder::produce ( art::Event & evt )

virtual

Todo:: this is completely specific to ArgoNeuT!!!!

Implements art::EDProducer.

Definition at line 146 of file HarrisVertexFinder_module.cc.

References art::PtrVector< T >::clear(), util::CreateAssn(), geo::GeometryCore::Cryostat(), art::EventID::event(), fDBScanModuleLabel, fGsigma, fMaxCorners, fNoVertices, fSaveVertexMap, fThreshold, fTimeBins, fWindow, Gaussian(), GaussianDerivativeX(), GaussianDerivativeY(), art::DataViewImpl::getByLabel(), art::Event::id(), geo::GeometryCore::IteratePlaneIDs(), max, min, n, geo::PlaneGeo::Nwires(), geo::TPCGeo::Plane(), art::PtrVector< T >::push_back(), art::Event::put(), SaveBMPFile(), art::PtrVector< T >::size(), geo::CryostatGeo::TPC(), geo::GeometryCore::View(), w, x, and y.

 {
 
   art::ServiceHandle<geo::Geometry> geom;
   
   art::Handle< std::vector<recob::Cluster> > clusterListHandle;
   evt.getByLabel(fDBScanModuleLabel, clusterListHandle);
 
   //Point to a collection of vertices to output and the associations with the hits
   std::unique_ptr<std::vector<recob::EndPoint2D> > vtxcol(new std::vector<recob::EndPoint2D>);
   std::unique_ptr< art::Assns<recob::EndPoint2D, recob::Hit> > assn(new art::Assns<recob::EndPoint2D, recob::Hit>);
 
   std::vector< art::Ptr<recob::Hit> > cHits;
   art::PtrVector<recob::Hit> hit;
    
   art::PtrVector<recob::Cluster> clusIn;
   for(unsigned int ii = 0; ii < clusterListHandle->size(); ++ii){
     art::Ptr<recob::Cluster> cluster(clusterListHandle, ii);
     clusIn.push_back(cluster);
   }
 
   art::FindManyP<recob::Hit> fmh(clusterListHandle, evt, fDBScanModuleLabel);
 
   int flag   = 0;
   int n      = 0; //index of window cell. There are 49 cells in the 7X7 Gaussian and Gaussian derivative windows
   unsigned int numberwires = 0;
   double MatrixAAsum = 0.;
   double MatrixBBsum = 0.; 
   double MatrixCCsum = 0.;
   std::vector<double> Cornerness2;
   //gaussian window definitions. The cell weights are calculated here to help the algorithm's speed
   double  w[49] = {0.};
   double wx[49] = {0.};
   double wy[49] = {0.};
   int ctr = 0;
   for(int i = -3; i < 4; ++i){
     for(int j = 3; j > -4; --j){
       w[ctr] = Gaussian(i, j, fGsigma);
       wx[ctr] = GaussianDerivativeX(i,j);
       wy[ctr] = GaussianDerivativeY(i,j);
       ++ctr;
     }
   }
   
   const unsigned int numbertimesamples
     = lar::providerFrom<detinfo::DetectorPropertiesService>()->ReadOutWindowSize();
   
   const float BinsPerTick = fTimeBins / numbertimesamples;
   const float TicksPerBin = numbertimesamples / fTimeBins;
   
   for(auto pid : geom->IteratePlaneIDs()){
     art::PtrVector<recob::Hit> vHits;
     geo::View_t view = geom->View(pid);
     hit.clear();
     cHits.clear();      
     for(size_t ci = 0; ci < clusIn.size(); ++ci) {
       cHits = fmh.at(ci);
       if(cHits.size() > 0)
         for(unsigned int i = 0; i < cHits.size(); ++i) hit.push_back(cHits[i]);
       
     } 
     if(hit.size() == 0) continue;
     
     numberwires       = geom->Cryostat(pid.Cryostat).TPC(pid.TPC).Plane(pid.Plane).Nwires();
     std::vector< std::vector<double> > MatrixAsum(numberwires);
     std::vector< std::vector<double> > MatrixBsum(numberwires);
     std::vector< std::vector<double> > hit_map(numberwires);//the map of hits 
     std::vector< std::vector<int>    > hit_loc(numberwires);//the index of the hit that corresponds to the potential corner
     std::vector< std::vector<double> > Cornerness(numberwires);//the "weight" of a corner
     
     for(unsigned int wi = 0; wi < numberwires; ++wi){
       MatrixAsum[wi].resize(fTimeBins);
       MatrixBsum[wi].resize(fTimeBins);
       hit_map[wi].resize(fTimeBins);
       hit_loc[wi].resize(fTimeBins);
       Cornerness[wi].resize(fTimeBins);
       for(int timebin = 0; timebin < fTimeBins; ++timebin){
         hit_map[wi][timebin] = 0.;
         hit_loc[wi][timebin] = -1;
         Cornerness[wi][timebin] = 0.;
         MatrixAsum[wi][timebin] = 0.;
         MatrixBsum[wi][timebin] = 0.;
       }
     }
     
     for(unsigned int i = 0; i < hit.size(); ++i){
       unsigned int wire = hit[i]->WireID().Wire;
       // pixelization using a Gaussian (3 sigmas around peak)
       const float center = hit[i]->PeakTime(), sigma = hit[i]->RMS();
       const int iFirstBin = int((center - 3*sigma) / TicksPerBin),
         iLastBin = int((center + 3*sigma) / TicksPerBin);
       for (int iBin = iFirstBin; iBin <= iLastBin; ++iBin) {
         const float bin_center = iBin * TicksPerBin;
         hit_map[wire][iBin] += Gaussian(bin_center, center, sigma);
       }
     }
     
     // Gaussian derivative convolution  
     for(unsigned int wire = 1;wire < numberwires-1; ++wire){
       for(int timebin = 1;timebin < fTimeBins-1; ++timebin){
         MatrixAsum[wire][timebin] = 0.;
         MatrixBsum[wire][timebin] = 0.;
         n = 0;
         for(int i = -3; i <= 3; ++i) {
           unsigned int windex = ((int)wire < -i)? 0: wire + i;
           if (windex >= numberwires) windex = numberwires - 1;
           for(int j = -3; j <= 3; ++j) {
             unsigned int tindex = (unsigned int) std::min(std::max(timebin +j, 0), fTimeBins - 1);
             
             MatrixAsum[wire][timebin] += wx[n]*hit_map[windex][tindex];
             MatrixBsum[wire][timebin] += wy[n]*hit_map[windex][tindex];
             ++n;
           }// end loop over j
         }// end loop over i
       }// end loop over time bins
     }// end loop over wires
     
     //calculate the cornerness of each pixel while making sure not to fall off the hit map.
     for(unsigned int wire = 1; wire < numberwires-1; ++wire){
       for(int timebin = 1; timebin < fTimeBins-1; ++timebin){     
         MatrixAAsum = 0.;
         MatrixBBsum = 0.;
         MatrixCCsum = 0.;
         //Gaussian smoothing convolution
         n = 0;
         
         for(int i = -3; i <= 3; i++) {
           unsigned int windex = ((int)wire < -i)? 0: wire + i;
           if (windex >= numberwires) windex = numberwires - 1;
           for(int j = -3; j <= 3; j++) {
             unsigned int tindex = (unsigned int) std::min(std::max(timebin +j, 0), fTimeBins - 1);
             MatrixAAsum += w[n]*pow(MatrixAsum[windex][tindex],2);
             MatrixBBsum += w[n]*pow(MatrixBsum[windex][tindex],2);
             MatrixCCsum += w[n]*MatrixAsum[windex][tindex]*MatrixBsum[windex][tindex]; 
             ++n;
           }// end loop over j
         }// end loop over i
         
         if((MatrixAAsum+MatrixBBsum) > 0)               
           Cornerness[wire][timebin] = (MatrixAAsum*MatrixBBsum-pow(MatrixCCsum,2))/(MatrixAAsum+MatrixBBsum);
         else
           Cornerness[wire][timebin] = 0;
         
         if(Cornerness[wire][timebin]>0){          
           for(unsigned int i = 0;i < hit.size(); ++i){
             unsigned int wire2 = hit[i]->WireID().Wire;
             // make sure the vertex candidate coincides with an actual hit
             // (time within one RMS from the center of the hit)
             const float time = timebin / TicksPerBin;
             if(wire == wire2 && std::abs(hit[i]->TimeDistanceAsRMS(time)) < 1.){
               //this index keeps track of the hit number
               hit_loc[wire][timebin] = i;
               Cornerness2.push_back(Cornerness[wire][timebin]);
               break;
             }           
           }// end loop over hits             
         }// end if cornerness > 0           
       }// end loop over time bins
     }// end loop over wires
     
     std::sort(Cornerness2.rbegin(),Cornerness2.rend());
     
     for(int vertexnum = 0; vertexnum < fMaxCorners; ++vertexnum){
       flag = 0;
       for(unsigned int wire = 0;wire < numberwires && flag == 0; ++wire){
         for(int timebin = 0;timebin < fTimeBins && flag == 0; ++timebin){    
           if(Cornerness2.size() > (unsigned int)vertexnum)
             if(Cornerness[wire][timebin] == Cornerness2[vertexnum] 
                && Cornerness[wire][timebin] > 0. 
                && hit_loc[wire][timebin]>-1){
               ++flag;      
               //thresholding
               if(Cornerness2.size())
                 if(Cornerness[wire][timebin] < (fThreshold*Cornerness2[0]))
                   vertexnum = fMaxCorners;
               
               vHits.push_back(hit[hit_loc[wire][timebin]]);
               // get the total charge from the associated hits
               double totalQ = 0.;
               for(size_t vh = 0; vh < vHits.size(); ++vh) totalQ += vHits[vh]->Integral();
               
               recob::EndPoint2D vertex(hit[hit_loc[wire][timebin]]->PeakTime(),
                                        hit[hit_loc[wire][timebin]]->WireID(),  //for update to EndPoint2D ... WK 4/22/13
                                        Cornerness[wire][timebin],
                                        vtxcol->size(),
                                        view,
                                        totalQ);
               vtxcol->push_back(vertex);
               
               util::CreateAssn(*this, evt, *(vtxcol.get()), vHits, *(assn.get()));
               
               vHits.clear();
               // non-maximal suppression on a square window. The wire coordinate units are 
               // converted to time ticks so that the window is truly square. 
               // Note that there are 1/0.0743=13.46 time samples per 4.0 mm (wire pitch in ArgoNeuT), 
               // assuming a 1.5 mm/us drift velocity for a 500 V/cm E-field 
               
               
               for(unsigned int wireout=wire-(int)((fWindow*BinsPerTick*.0743)+.5);
                   wireout <= wire+(int)((fWindow*BinsPerTick*.0743)+.5) ; wireout++)
                 for(int timebinout=timebin-fWindow;timebinout <= timebin+fWindow; timebinout++)
                   if(std::sqrt(pow(wire-wireout,2)+pow(timebin-timebinout,2))<fWindow)//circular window 
                     Cornerness[wireout][timebinout]=0;    
             }
         }// end loop over time bins     
       }// end loop over wires
     }// end loop over vertices
     Cornerness2.clear();
     hit.clear();
     
     if(pid.Plane == (unsigned int)fSaveVertexMap){ 
       unsigned char *outPix = new unsigned char [fTimeBins*numberwires];
       //finds the maximum cell in the map for image scaling
       int cell, pix=0, maxCell=0;
       for (int y = 0; y < fTimeBins; ++y){
         for (unsigned int x = 0; x < numberwires; ++x){
           cell = (int)(hit_map[x][y]*1000);
           if (cell > maxCell){
             maxCell = cell;
           }
         }
       }
       
       for (unsigned int y = 0; y < (unsigned int)fTimeBins; ++y){
         for (unsigned int x = 0; x < numberwires; ++x){ 
           //scales the pixel weights based on the maximum cell value     
           if(maxCell>0)
             pix = (int)((1500000*hit_map[x][y])/maxCell);
           outPix[y*numberwires + x] = pix;
         }
       }
       SaveBMPFile("harrisvertexmap.bmp", outPix, numberwires, fTimeBins);
       delete [] outPix;
     }   
   }// end loop over planes
 
   mf::LogInfo("HarrisVertexFinder") << "Size of vtxcol= " << vtxcol->size();
   fNoVertices->Fill(evt.id().event(),vtxcol->size());
   
   evt.put(std::move(vtxcol));   
 }

void vertex::HarrisVertexFinder::SaveBMPFile	(	const char *	fileName,
		unsigned char *	pix,
		int	dx,
		int	dy
	)

private

Definition at line 391 of file HarrisVertexFinder_module.cc.

References DEFINE_ART_MODULE.

Referenced by produce().

 {
   std::ofstream bmpFile(fileName, std::ios::binary);
   bmpFile.write("B", 1);
   bmpFile.write("M", 1);
   int bitsOffset = 54 +256*4; 
   int size = bitsOffset + dx*dy; //header plus 256 entry LUT plus pixels
   bmpFile.write((const char *)&size, 4);
   int reserved = 0;
   bmpFile.write((const char *)&reserved, 4);
   bmpFile.write((const char *)&bitsOffset, 4);
   int bmiSize = 40;
   bmpFile.write((const char *)&bmiSize, 4);
   bmpFile.write((const char *)&dx, 4);
   bmpFile.write((const char *)&dy, 4);
   short planes = 1;
   bmpFile.write((const char *)&planes, 2);
   short bitCount = 8;
   bmpFile.write((const char *)&bitCount, 2);
   int i, temp = 0;
   for (i=0; i<6; i++)
     bmpFile.write((const char *)&temp, 4);  // zero out optional color info
   // write a linear LUT
   char lutEntry[4]; // blue,green,red
   lutEntry[3] = 0;  // reserved part
   for (i=0; i<256; i++)
     {
       lutEntry[0] = lutEntry[1] = lutEntry[2] = i;
       bmpFile.write(lutEntry, sizeof lutEntry);
     }
   // write the actual pixels
   bmpFile.write((const char *)pix, dx*dy);
 }

void art::Consumer::showMissingConsumes ( ) const

protectedinherited

Definition at line 125 of file Consumer.cc.

Referenced by art::EDProducer::doEndJob(), art::EDFilter::doEndJob(), art::EDAnalyzer::doEndJob(), and art::RootOutput::endJob().

 {
   if (!moduleContext_)
     return;
 
   // If none of the branches have missing consumes statements, exit early.
   if (std::all_of(cbegin(missingConsumes_),
                   cend(missingConsumes_),
                   [](auto const& perBranch) { return perBranch.empty(); }))
     return;
 
   constexpr cet::HorizontalRule rule{60};
   mf::LogPrint log{"MTdiagnostics"};
   log << '\n'
       << rule('=') << '\n'
       << "The following consumes (or mayConsume) statements are missing from\n"
       << module_context(moduleDescription_) << '\n'
       << rule('-') << '\n';
 
   cet::for_all_with_index(
     missingConsumes_, [&log](std::size_t const i, auto const& perBranch) {
       for (auto const& pi : perBranch) {
         log << "  "
             << assemble_consumes_statement(static_cast<BranchType>(i), pi)
             << '\n';
       }
     });
   log << rule('=');
 }

void art::Consumer::validateConsumedProduct	(	BranchType const	bt,
		ProductInfo const &	pi
	)

protectedinherited

Definition at line 101 of file Consumer.cc.

References art::errors::ProductRegistrationFailure.

 {
   // Early exits if consumes tracking has been disabled or if the
   // consumed product is an allowed consumable.
   if (!moduleContext_)
     return;
 
   if (cet::binary_search_all(consumables_[bt], pi))
     return;
 
   if (requireConsumes_) {
     throw Exception(errors::ProductRegistrationFailure,
                     "Consumer: an error occurred during validation of a "
                     "retrieved product\n\n")
       << "The following consumes (or mayConsume) statement is missing from\n"
       << module_context(moduleDescription_) << ":\n\n"
       << "  " << assemble_consumes_statement(bt, pi) << "\n\n";
   }
 
   missingConsumes_[bt].insert(pi);
 }