Aid in the rendering of RawData objects. More...

#include "RawDataDrawer.h"

Classes
class	BoxDrawer

struct	BoxInfo_t

class	ManyOperations

class	OperationBaseClass

struct	PadResolution_t

class	RoIextractorClass

Public Member Functions
	RawDataDrawer ()

	~RawDataDrawer ()

void	RawDigit2D (art::Event const &evt, evdb::View2D *view, unsigned int plane, bool bZoomToRoI=false)
	Draws raw digit content in 2D wire plane representation. More...

void	FillQHisto (const art::Event &evt, unsigned int plane, TH1F *histo)

void	FillTQHisto (const art::Event &evt, unsigned int plane, unsigned int wire, TH1F *histo)

double	StartTick () const

double	TotalClockTicks () const

void	ExtractRange (TVirtualPad pPad, std::vector< double > const zoom=nullptr)
	Fills the viewport information from the specified pad. More...

void	SetDrawingLimits (float low_wire, float high_wire, float low_tdc, float high_tdc)
	Fills the viewport borders from the specified extremes. More...

int	GetRegionOfInterest (int plane, int &minw, int &maxw, int &mint, int &maxt)

void	ResetRegionOfInterest ()
	Forgets about the current region of interest. More...

bool	hasRegionOfInterest (geo::PlaneID::PlaneID_t plane) const

void	GetChargeSum (int plane, double &charge, double &convcharge)

Private Member Functions
void	Reset (art::Event const &event)
	Prepares for a new event (if somebody tells it to) More...

void	GetRawDigits (art::Event const &evt)
	Reads raw::RawDigits; also triggers Reset() More...

bool	ProcessChannelWithStatus (lariov::ChannelStatusProvider::Status_t channel_status) const
	Returns whether a channel with the specified status should be processed. More...

void	DrawRawDigit2D (art::Event const &evt, evdb::View2D *view, unsigned int plane)
	Performs the 2D wire plane drawing. More...

void	GetRawDigits (art::Event const &evt, details::CacheID_t const &new_timestamp)
	Makes sure raw::RawDigit's are available for the current settings. More...

bool	RunOperation (art::Event const &evt, OperationBaseClass *operation)

void	QueueDrawingBoxes (evdb::View2D *view, geo::PlaneID const &pid, std::vector< BoxInfo_t > const &BoxInfo)

void	RunDrawOperation (art::Event const &evt, evdb::View2D *view, unsigned int plane)

void	RunRoIextractor (art::Event const &evt, unsigned int plane)

void	SetDrawingLimitsFromRoI (geo::PlaneID::PlaneID_t plane)

void	SetDrawingLimitsFromRoI (geo::PlaneID const pid)

Private Attributes
evd::details::RawDigitCacheDataClass *	digit_cache
	Cache of raw digits. More...

double	fStartTick
	low tick More...

double	fTicks
	number of ticks of the clock More...

std::vector< int >	fWireMin
	lowest wire in interesting region for each plane More...

std::vector< int >	fWireMax
	highest wire in interesting region for each plane More...

std::vector< int >	fTimeMin
	lowest time in interesting region for each plane More...

std::vector< int >	fTimeMax
	highest time in interesting region for each plane More...

std::vector< double >	fRawCharge
	Sum of Raw Charge. More...

std::vector< double >	fConvertedCharge
	Sum of Charge Converted using Birks' formula. More...

PadResolution_t	PadResolution
	stored pad resolution More...

details::CacheID_t *	fCacheID
	information about the last processed plane More...

details::CellGridClass *	fDrawingRange
	information about the viewport More...

Static Private Attributes
static std::vector< raw::RawDigit > const	EmptyRawDigits
	Empty collection, used in return value of invalid digits. More...

Friends
class	BoxDrawer

class	RoIextractorClass

Detailed Description

Aid in the rendering of RawData objects.

Definition at line 40 of file RawDataDrawer.h.

Constructor & Destructor Documentation

evd::RawDataDrawer::RawDataDrawer ( )

Definition at line 568 of file RawDataDrawer.cxx.

References fConvertedCharge, evd::RawDrawingOptions::fCryostat, fRawCharge, evd::RawDrawingOptions::fStartTick, fStartTick, evd::RawDrawingOptions::fTicks, fTicks, fTimeMax, fTimeMin, evd::RawDrawingOptions::fTPC, fWireMax, fWireMin, and geo::GeometryCore::Nplanes().

     : digit_cache(new details::RawDigitCacheDataClass)
     , fStartTick(0),fTicks(2048)
     , fCacheID(new details::CacheID_t)
     , fDrawingRange(new details::CellGridClass)
   { 
     art::ServiceHandle<geo::Geometry> geo;
 
     art::ServiceHandle<evd::RawDrawingOptions> rawopt;
     geo::TPCID tpcid(rawopt->fCryostat, rawopt->fTPC);
     
     fStartTick = rawopt->fStartTick;
     fTicks = rawopt->fTicks;
 
     // set the list of bad channels in this detector
     unsigned int nplanes=geo->Nplanes(tpcid);
     fWireMin.resize(nplanes,-1);   
     fWireMax.resize(nplanes,-1);    
     fTimeMin.resize(nplanes,-1);    
     fTimeMax.resize(nplanes,-1);    
     fRawCharge.resize(nplanes,0);   
     fConvertedCharge.resize(nplanes,0);
   }

evd::RawDataDrawer::~RawDataDrawer ( )

Definition at line 593 of file RawDataDrawer.cxx.

References digit_cache, fCacheID, fDrawingRange, and SetDrawingLimits().

   {
     delete digit_cache;
     delete fDrawingRange;
     delete fCacheID;
   }

Member Function Documentation

void evd::RawDataDrawer::DrawRawDigit2D	(	art::Event const &	evt,
		evdb::View2D *	view,
		unsigned int	plane
	)

private

Performs the 2D wire plane drawing.

void evd::RawDataDrawer::ExtractRange	(	TVirtualPad *	pPad,
		std::vector< double > const *	zoom = `nullptr`
	)

Fills the viewport information from the specified pad.

Definition at line 640 of file RawDataDrawer.cxx.

References fDrawingRange, evd::RawDataDrawer::PadResolution_t::height, PadResolution, evd::details::CellGridClass::SetTDCRange(), evd::details::CellGridClass::SetWireRange(), and evd::RawDataDrawer::PadResolution_t::width.

Referenced by SetDrawingLimitsFromRoI().

   {
     mf::LogDebug log("RawDataDrawer");
     log << "ExtractRange() on pad '" << pPad->GetName() << "'";
     
     TFrame const* pFrame = pPad->GetFrame();
     if (pFrame) {
       // these coordinates are used to find the actual extent of pad in pixels
       double low_wire = pFrame->GetX1(), high_wire = pFrame->GetX2();
       double low_tdc = pFrame->GetY1(), high_tdc = pFrame->GetY2();
       double const wire_pixels = pPad->XtoAbsPixel(high_wire) - pPad->XtoAbsPixel(low_wire);
       double const tdc_pixels = -(pPad->YtoAbsPixel(high_tdc) - pPad->YtoAbsPixel(low_tdc));
       
       PadResolution.width = (unsigned int) wire_pixels;
       PadResolution.height = (unsigned int) tdc_pixels;
       
       log << "\n frame window is "
         << PadResolution.width << "x" << PadResolution.height
         << " pixel big and";
       // those coordinates also are a (unreliable) estimation of the zoom;
       // if we have a better one, let's use it
       // (this does not change the size of the window in terms of pixels)
       if (zoom) {
         log << ", from external source,";
         low_wire = (*zoom)[0];
         high_wire = (*zoom)[1];
         low_tdc = (*zoom)[2];
         high_tdc = (*zoom)[3];
       }
       
       log << " spans wires "
         << low_wire << "-" << high_wire << " and TDC " << low_tdc << "-" << high_tdc;
       
       // TODO support swapping axes here:
       // if (rawopt.fAxisOrientation < 1) { normal ; } else { swapped; }
       
       fDrawingRange->SetWireRange(low_wire, high_wire, (unsigned int) wire_pixels, 1.0);
       fDrawingRange->SetTDCRange(low_tdc, high_tdc, (unsigned int) tdc_pixels, 1.0);
     }
     else {
       // keep the old frame (if any)
       log << "\n  no frame!";
     }
     
   } // RawDataDrawer::ExtractRange()

void evd::RawDataDrawer::FillQHisto	(	const art::Event &	evt,
		unsigned int	plane,
		TH1F *	histo
	)

Definition at line 1307 of file RawDataDrawer.cxx.

References raw::RawDigit::Channel(), geo::GeometryCore::ChannelToWire(), evd::RawDrawingOptions::CurrentTPC(), d, digit_cache, evd::RawDrawingOptions::fDrawRawDataOrCalibWires, evd::RawDrawingOptions::fRawDataLabel, evd::RawDrawingOptions::fSeeBadChannels, GetRawDigits(), and ProcessChannelWithStatus().

   {
 
     // Check if we're supposed to draw raw hits at all
     art::ServiceHandle<evd::RawDrawingOptions> rawopt;
     if (rawopt->fDrawRawDataOrCalibWires==1) return;
 
     art::ServiceHandle<geo::Geometry> geo;
     
     geo::PlaneID const pid(rawopt->CurrentTPC(), plane);
     details::CacheID_t NewCacheID(evt, rawopt->fRawDataLabel, pid);
     GetRawDigits(evt, NewCacheID);
       
     lariov::ChannelStatusProvider const& channelStatus
       = art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();
     
     //get pedestal conditions
     const lariov::DetPedestalProvider& pedestalRetrievalAlg = art::ServiceHandle<lariov::DetPedestalService>()->GetPedestalProvider();
 
     for (evd::details::RawDigitInfo_t const& digit_info: *digit_cache) {
       raw::RawDigit const& hit = digit_info.Digit();
       raw::ChannelID_t const channel = hit.Channel();
         
       if (!channelStatus.IsPresent(channel)) continue;
       
       // The following test is meant to be temporary until the "correct" solution is implemented
       if (!ProcessChannelWithStatus(channelStatus.Status(channel))) continue;
       
       // to be explicit: we don't cound bad channels in
       if (!rawopt->fSeeBadChannels && channelStatus.IsBad(channel)) continue;
       
       std::vector<geo::WireID> wireids = geo->ChannelToWire(channel);
       for(auto const& wid : wireids){
         // check that the plane and tpc are the correct ones to draw
         if (wid.planeID() != pid) continue;
 
         raw::RawDigit::ADCvector_t const& uncompressed = digit_info.Data();
         
         float const pedestal = pedestalRetrievalAlg.PedMean(channel);
 
         for(short d: uncompressed)
           histo->Fill(float(d) - pedestal); //pedestals[plane]); //hit.GetPedestal());
         
         // this channel is on the correct plane, don't double count the raw signal
         // if there are more than one wids for the channel
         break;
       }// end loop over wids
     }//end loop over raw hits
     
   }

void evd::RawDataDrawer::FillTQHisto	(	const art::Event &	evt,
		unsigned int	plane,
		unsigned int	wire,
		TH1F *	histo
	)

Definition at line 1361 of file RawDataDrawer.cxx.

References evd::RawDrawingOptions::CurrentTPC(), evd::details::RawDigitInfo_t::Data(), digit_cache, evd::details::RawDigitCacheDataClass::empty(), evd::RawDrawingOptions::fDrawRawDataOrCalibWires, evd::details::RawDigitCacheDataClass::FindChannel(), evd::RawDrawingOptions::fRawDataLabel, evd::RawDrawingOptions::fSeeBadChannels, GetRawDigits(), raw::isValidChannelID(), geo::GeometryCore::PlaneWireToChannel(), and ProcessChannelWithStatus().

Referenced by evd::TQPad::Draw().

   {
 
     // Check if we're supposed to draw raw hits at all
     art::ServiceHandle<evd::RawDrawingOptions> rawopt;
     if (rawopt->fDrawRawDataOrCalibWires==1) return;
     
     // make sure we have the raw digits cached
     geo::PlaneID const pid(rawopt->CurrentTPC(), plane);
     details::CacheID_t NewCacheID(evt, rawopt->fRawDataLabel, pid);
     GetRawDigits(evt, NewCacheID);
 
     if (digit_cache->empty()) return;
 
     geo::WireID const wireid(pid, wire);
     
     // find the channel
     art::ServiceHandle<geo::Geometry> geom;
     raw::ChannelID_t const channel = geom->PlaneWireToChannel(wireid);
     if (!raw::isValidChannelID(channel)) { // no channel, empty histogram
       mf::LogError("RawDataDrawer") << __func__ << ": no channel associated to "
         << std::string(wireid);
       return;
     } // if no channel
     
     // check the channel status; bad channels are still ok.
     lariov::ChannelStatusProvider const& channelStatus
       = art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();
     
     if (!channelStatus.IsPresent(channel)) return;
     
     // The following test is meant to be temporary until the "correct" solution is implemented
     if (!ProcessChannelWithStatus(channelStatus.Status(channel))) return;
     
     
     // we accept to see the content of a bad channel, so this is commented out:
     if (!rawopt->fSeeBadChannels && channelStatus.IsBad(channel)) return;
     
     //get pedestal conditions
     const lariov::DetPedestalProvider& pedestalRetrievalAlg = art::ServiceHandle<lariov::DetPedestalService>()->GetPedestalProvider();
     
     // find the raw digit
     // (iDigit is an iterator to a evd::details::RawDigitInfo_t)
     evd::details::RawDigitInfo_t const* pDigit
       = digit_cache->FindChannel(channel);
     if (!pDigit) { // this is weird...
       mf::LogWarning("RawDataDrawer") << __func__
         << ": can't find raw digit for channel #" << channel
         << " (" << std::string(wireid) << ")";
       return;
     }
     
     raw::RawDigit::ADCvector_t const& uncompressed = pDigit->Data();
     
     float const pedestal = pedestalRetrievalAlg.PedMean(channel);
     
     for(size_t j = 0; j < uncompressed.size(); ++j)
       histo->Fill(float(j), float(uncompressed[j]) - pedestal); //pedestals[plane]); //hit.GetPedestal());
     
   } // RawDataDrawer::FillTQHisto()

void evd::RawDataDrawer::GetChargeSum	(	int	plane,
		double &	charge,
		double &	convcharge
	)

Definition at line 1299 of file RawDataDrawer.cxx.

References fConvertedCharge, and fRawCharge.

   {
     charge=fRawCharge[plane]; 
     convcharge=fConvertedCharge[plane];    
     
   }

void evd::RawDataDrawer::GetRawDigits ( art::Event const & evt )

private

Reads raw::RawDigits; also triggers Reset()

Referenced by FillQHisto(), FillTQHisto(), RawDigit2D(), ResetRegionOfInterest(), and RunOperation().

void evd::RawDataDrawer::GetRawDigits	(	art::Event const &	evt,
		details::CacheID_t const &	new_timestamp
	)

private

Makes sure raw::RawDigit's are available for the current settings.

Parameters

evt	event to read the digits from
ts	a cache ID assessing the new state the cache should move to

The function will ask the data cache for an update (RawDigitCacheDataClass::Update()). The cache will evaluate whether it is already in a state compatible with ts or if cache needs to be invalidated, in which case it will fill with new data. This method also triggers a Reset() if the target state differs from the old one.

Definition at line 1540 of file RawDataDrawer.cxx.

References digit_cache, fCacheID, LOG_DEBUG, ProcessChannelWithStatus(), ResetRegionOfInterest(), and evd::details::RawDigitCacheDataClass::Update().

   {
     LOG_DEBUG("RawDataDrawer") << "GetRawDigits() for " << new_timestamp
       << " (last for: " << *fCacheID << ")";
     
     // update cache
     digit_cache->Update(evt, new_timestamp);
     
     // if time stamp is changing, we want to reconsider which region is
     // interesting
     if (!fCacheID->sameTPC(new_timestamp)) ResetRegionOfInterest();
     
     // all the caches have been properly updated or invalidated;
     // we are now on a new cache state
     *fCacheID = new_timestamp;
     
   } // RawDataDrawer::GetRawDigits()

int evd::RawDataDrawer::GetRegionOfInterest	(	int	plane,
		int &	minw,
		int &	maxw,
		int &	mint,
		int &	maxt
	)

Definition at line 1272 of file RawDataDrawer.cxx.

References fTimeMax, fTimeMin, fWireMax, fWireMin, geo::GeometryCore::Nwires(), and TotalClockTicks().

Referenced by evd::TWireProjPad::ShowFull().

   {
     art::ServiceHandle<geo::Geometry> geo;
  
     if((unsigned int)plane>=fWireMin.size())
       {mf::LogWarning  ("RawDataDrawer") << " Requested plane " << plane <<" is larger than those available " << std::endl;
         return -1;
       }
     
     minw=fWireMin[plane];
     maxw=fWireMax[plane];
     mint=fTimeMin[plane];
     maxt=fTimeMax[plane];
     
     if ((minw == maxw) || (mint == maxt)) return 1;
     
     //make values a bit larger, but make sure they don't go out of bounds 
     minw= (minw-30<0) ? 0 : minw-30;
     mint= (mint-10<0) ? 0 : mint-10;
 
     maxw= (maxw+10>(int)geo->Nwires(plane)) ? geo->Nwires(plane) : maxw+10;
     maxt= (maxt+10>TotalClockTicks()) ? TotalClockTicks() : maxt+10;
     
     return 0;
   }

bool evd::RawDataDrawer::hasRegionOfInterest ( geo::PlaneID::PlaneID_t plane ) const

Returns whether there is currently a valid region of interest for the specified plane

Definition at line 1516 of file RawDataDrawer.cxx.

References fTimeMax, and fWireMax.

Referenced by RawDigit2D(), and RunRoIextractor().

                                                                          {
     
     return (fWireMax[plane] != -1) && (fTimeMax[plane] != -1);
     
   } // RawDataDrawer::hasRegionOfInterest()

bool evd::RawDataDrawer::ProcessChannelWithStatus ( lariov::ChannelStatusProvider::Status_t channel_status ) const

private

Returns whether a channel with the specified status should be processed.

Definition at line 1561 of file RawDataDrawer.cxx.

References evd::RawDrawingOptions::fMaxChannelStatus.

Referenced by FillQHisto(), FillTQHisto(), GetRawDigits(), and RunOperation().

   {
     // if we don't have a valid status, we can't reject the channel
     if (!lariov::ChannelStatusProvider::IsValidStatus(channel_status))
       return true;
     
     // is the status "too bad"?
     art::ServiceHandle<evd::RawDrawingOptions> drawopt;
     if (channel_status > drawopt->fMaxChannelStatus) return false;
     if (channel_status < drawopt->fMinChannelStatus) return false;
     
     // no reason to reject it...
     return true;
   } // RawDataDrawer::ProcessChannel()

void evd::RawDataDrawer::QueueDrawingBoxes	(	evdb::View2D *	view,
		geo::PlaneID const &	pid,
		std::vector< BoxInfo_t > const &	BoxInfo
	)

private

Definition at line 993 of file RawDataDrawer.cxx.

References evd::RawDataDrawer::BoxInfo_t::adc, evdb::View2D::AddBox(), color(), evd::RawDrawingOptions::fAxisOrientation, fDrawingRange, evd::RawDrawingOptions::fMinSignal, evd::RawDrawingOptions::fScaleDigitsByCharge, evd::details::CellGridClass::GetCellBox(), evdb::ColorScale::GetColor(), evd::RawDataDrawer::BoxInfo_t::good, LOG_DEBUG, min, evd::ColorDrawingOptions::RawQ(), RunDrawOperation(), and geo::GeometryCore::SignalType().

   {
     //
     // All the information is now collected in BoxInfo.
     // Make boxes out of it.
     //
     evd::RawDrawingOptions const& rawopt
       = *art::ServiceHandle<evd::RawDrawingOptions>();
     
     LOG_DEBUG("RawDataDrawer")
       << "Filling " << BoxInfo.size() << " boxes to be rendered";
     
     // drawing options:
     float const MinSignal = rawopt.fMinSignal;
     bool const bScaleDigitsByCharge = rawopt.fScaleDigitsByCharge;
 
     art::ServiceHandle<evd::ColorDrawingOptions> cst;
     
     geo::GeometryCore const& geom = *art::ServiceHandle<geo::Geometry>();
     geo::SigType_t const sigType = geom.SignalType(pid);
     evdb::ColorScale const& ColorSet = cst->RawQ(sigType);
     size_t const nBoxes = BoxInfo.size();
     unsigned int nDrawnBoxes = 0;
     for (size_t iBox = 0; iBox < nBoxes; ++iBox) {
       BoxInfo_t const& info = BoxInfo[iBox];
       
       // too little signal, don't bother drawing
       if(info.good && (std::abs(info.adc) < MinSignal)) continue;
       
       // skip the bad cells
       if (!info.good) continue;
       
       // box color, proportional to the ADC count
       int const color = ColorSet.GetColor(info.adc);
       
       // scale factor, proportional to ADC count (optional)
       constexpr float q0 = 1000.;
       float const sf = bScaleDigitsByCharge
         ? std::min(std::sqrt((float) info.adc / q0), 1.0F)
         : 1.;
       
       // coordinates of the cell box
       float min_wire, max_wire, min_tick, max_tick;
       std::tie(min_wire, min_tick, max_wire, max_tick)
         = fDrawingRange->GetCellBox(iBox);
     /*
       LOG_TRACE("RawDataDrawer")
         << "Wires ( " << min_wire << " - " << max_wire << " ) ticks ("
         << min_tick << " - " << max_tick << " ) for cell " << iBox;
     */
       if (sf != 1.) { // need to shrink the box
         float const nsf = 1. - sf; // negation of scale factor
         float const half_box_wires = (max_wire - min_wire) / 2.,
           half_box_ticks = (max_tick - min_tick) / 2.;
         
         // shrink the box:
         min_wire += nsf * half_box_wires;
         max_wire -= nsf * half_box_wires;
         min_tick += nsf * half_box_ticks;
         max_tick -= nsf * half_box_ticks;
       } // if scaling
       
       // allocate the box on the view;
       // the order of the coordinates depends on the orientation
       TBox* pBox;
       if (rawopt.fAxisOrientation < 1)
         pBox = &(view->AddBox(min_wire, min_tick, max_wire, max_tick));
       else
         pBox = &(view->AddBox(min_tick, min_wire, max_tick, max_wire));
       
       pBox->SetFillStyle(1001);
       pBox->SetFillColor(color);
       pBox->SetBit(kCannotPick);
       
       ++nDrawnBoxes;
     } // for (iBox)
     
     LOG_DEBUG("RawDataDrawer")
       << "Sent " << nDrawnBoxes << "/" << BoxInfo.size()
       << " boxes to be rendered";
   } // RawDataDrawer::QueueDrawingBoxes()

void evd::RawDataDrawer::RawDigit2D	(	art::Event const &	evt,
		evdb::View2D *	view,
		unsigned int	plane,
		bool	bZoomToRoI = `false`
	)

Draws raw digit content in 2D wire plane representation.

Parameters

evt	source for raw digits
view	target rendered object
plane	number of the plane to be drawn
bZoomToRoI	whether to render only te region of interest

This function performs pre-rendering of the raw digit content into a 2D view of the wire plane as TDC vs. wire number. The material for rendering is created and sent to view object for actual rendering. The pre-rendering result currently depends on information from the current rendering canvas, and in particular on its viewport in the (wire, TDC) space.

If no zoom to the region of interest is required, the region itself is computed (only if not known yet) while the rendering is performed. If the zoom is required instead, rendering is performed in two steps; in the first, run only of no region of interest is known yet, the region is extracted. In the second, that information is used for rendering.

Definition at line 1178 of file RawDataDrawer.cxx.

References evd::RawDataDrawer::ManyOperations::AddOperation(), BoxDrawer, evd::RawDrawingOptions::CurrentTPC(), evd::RawDrawingOptions::fDrawRawDataOrCalibWires, evd::RawDrawingOptions::fRawDataLabel, fTimeMax, fTimeMin, fWireMax, fWireMin, GetRawDigits(), hasRegionOfInterest(), LOG_DEBUG, RoIextractorClass, RunOperation(), SetDrawingLimitsFromRoI(), and art::errors::Unknown.

   {
     
     art::ServiceHandle<evd::RawDrawingOptions> rawopt;
     geo::PlaneID const pid(rawopt->CurrentTPC(), plane);
     
     bool const bDraw = (rawopt->fDrawRawDataOrCalibWires != 1);
     // if we don't need to draw, don't bother doing anything;
     // if the region of interest is required, RunRoIextractor() should be called
     // (ok, now it's private, but it could be exposed)
     if (!bDraw) return;
     
     // make sure we reset what needs to be reset
     // before the operations are initialized;
     // we call for reading raw digits; they will be cached, so it's not a waste
     details::CacheID_t NewCacheID(evt, rawopt->fRawDataLabel, pid);
     GetRawDigits(evt, NewCacheID);
     
     bool const hasRoI = hasRegionOfInterest(plane);
     
     // - if we don't have a RoI yet, we want to get it while we draw
     //   * if we are zooming into it now, we have to extract it first, then draw
     //   * if we are not zooming, we can do both at the same time
     // - if we have a RoI, we don't want to extract it again
     if (!bZoomToRoI) { // we are not required to zoom to the RoI
       
       std::unique_ptr<OperationBaseClass> operation;
       
       // we will do the drawing in one pass
       LOG_DEBUG("RawDataDrawer")
         << __func__ << "() setting up one-pass drawing";
       operation.reset(new BoxDrawer(pid, this, view));
       
       if (!hasRoI) { // we don't have any RoI; since it's cheap, let's get it
         LOG_DEBUG("RawDataDrawer") << __func__ << "() adding RoI extraction";
         
         // swap cards: operation becomes a multiple operation:
         // - prepare the two operations (one is there already, somehow)
         std::unique_ptr<OperationBaseClass> drawer(std::move(operation));
         std::unique_ptr<OperationBaseClass> extractor
           (new RoIextractorClass(pid, this));
         // - create a new composite operation and give it the sub-ops
         operation.reset(new ManyOperations(pid, this));
         ManyOperations* pManyOps
           = static_cast<ManyOperations*>(operation.get());
         pManyOps->AddOperation(std::move(drawer));
         pManyOps->AddOperation(std::move(extractor));
       }
       
       if (!RunOperation(evt, operation.get())) {
         throw art::Exception(art::errors::Unknown)
           << "RawDataDrawer::RunDrawOperation(): "
           "somewhere something went somehow wrong";
       }
     }
     else { // we are zooming to RoI
       // first, we want the RoI extracted; the extractor will update this object
       if (!hasRoI) {
         LOG_DEBUG("RawDataDrawer") << __func__
           << "() setting up RoI extraction for " << pid;
         RoIextractorClass extractor(pid, this);
         if (!RunOperation(evt, &extractor)) {
           throw art::Exception(art::errors::Unknown)
             << "RawDataDrawer::RunDrawOperation():"
             " something went somehow wrong while extracting RoI";
         }
       }
       else {
         LOG_DEBUG("RawDataDrawer") << __func__
           << "() using existing RoI for " << pid
           << ": wires ( " << fWireMin[plane] << " - " << fWireMax[plane]
           << " ), ticks ( " << fTimeMin[plane] << " - " << fTimeMax[plane]
           << " )";
       }
       
       // adopt the drawing limits information from the wire/time limits
       SetDrawingLimitsFromRoI(pid);
       
       // then we draw
       LOG_DEBUG("RawDataDrawer") << __func__ << "() setting up drawing";
       BoxDrawer drawer(pid, this, view);
       if (!RunOperation(evt, &drawer)) {
         throw art::Exception(art::errors::Unknown)
           << "RawDataDrawer::RunDrawOperation():"
           " something went somehow wrong while drawing";
       }
     }
   } // RawDataDrawer::RawDigit2D()

void evd::RawDataDrawer::Reset ( art::Event const & event )

private

Prepares for a new event (if somebody tells it to)

void evd::RawDataDrawer::ResetRegionOfInterest ( )

Forgets about the current region of interest.

Definition at line 1524 of file RawDataDrawer.cxx.

References trkf::fill(), fTimeMax, fTimeMin, fWireMax, fWireMin, GetRawDigits(), and LOG_DEBUG.

Referenced by GetRawDigits().

                                             {
     
     LOG_DEBUG("RawDataDrawer") << "RawDataDrawer[" << ((void*) this)
       << "]: resetting the region of interest";
     
     std::fill(fWireMin.begin(), fWireMin.end(), -1);
     std::fill(fWireMax.begin(), fWireMax.end(), -1);
     std::fill(fTimeMin.begin(), fTimeMin.end(), -1);
     std::fill(fTimeMax.begin(), fTimeMax.end(), -1);
     
   } // RawDataDrawer::ResetRegionOfInterest()

void evd::RawDataDrawer::RunDrawOperation	(	art::Event const &	evt,
		evdb::View2D *	view,
		unsigned int	plane
	)

private

Definition at line 1081 of file RawDataDrawer.cxx.

References evd::RawDrawingOptions::CurrentTPC(), evd::RawDrawingOptions::fDrawRawDataOrCalibWires, RunOperation(), and art::errors::Unknown.

Referenced by QueueDrawingBoxes().

   {
     
     // Check if we're supposed to draw raw hits at all
     art::ServiceHandle<evd::RawDrawingOptions> rawopt;
     if (rawopt->fDrawRawDataOrCalibWires == 1) return;
     
     geo::PlaneID const pid(rawopt->CurrentTPC(), plane);
     BoxDrawer drawer(pid, this, view);
     if (!RunOperation(evt, &drawer)) {
       throw art::Exception(art::errors::Unknown)
         << "RawDataDrawer::RunDrawOperation(): "
         "somewhere something went somehow wrong";
     }
     
   } // RawDataDrawer::RunDrawOperation()

bool evd::RawDataDrawer::RunOperation	(	art::Event const &	evt,
		OperationBaseClass *	operation
	)

private

Definition at line 811 of file RawDataDrawer.cxx.

References raw::RawDigit::Channel(), geo::GeometryCore::ChannelToWire(), digit_cache, evd::details::RawDigitCacheDataClass::empty(), evd::RawDataDrawer::OperationBaseClass::Finish(), evd::RawDrawingOptions::fRawDataLabel, evd::RawDrawingOptions::fSeeBadChannels, fStartTick, fTicks, GetRawDigits(), evd::RawDataDrawer::OperationBaseClass::Initialize(), LOG_DEBUG, min, evd::RawDataDrawer::OperationBaseClass::Name(), evd::RawDataDrawer::OperationBaseClass::Operate(), evd::RawDataDrawer::OperationBaseClass::PlaneID(), ProcessChannelWithStatus(), evd::RawDataDrawer::OperationBaseClass::ProcessTick(), and evd::RawDataDrawer::OperationBaseClass::ProcessWire().

Referenced by evd::RawDataDrawer::ManyOperations::AddOperation(), RawDigit2D(), RunDrawOperation(), and RunRoIextractor().

   {
     geo::PlaneID const& pid = operation->PlaneID();
     
     art::ServiceHandle<evd::RawDrawingOptions> rawopt;
     details::CacheID_t NewCacheID(evt, rawopt->fRawDataLabel, pid);
     GetRawDigits(evt, NewCacheID);
     
     if(digit_cache->empty()) return true;
     
     LOG_DEBUG("RawDataDrawer") << "RawDataDrawer::RunOperation() running "
       << operation->Name();
     
     // if we have an initialization failure, return false immediately;
     // but it's way better if the failure throws an exception
     if (!operation->Initialize()) return false;
     
     lariov::ChannelStatusProvider const& channelStatus
       = art::ServiceHandle<lariov::ChannelStatusService>()->GetProvider();
     
     //get pedestal conditions
     const lariov::DetPedestalProvider& pedestalRetrievalAlg = *(lar::providerFrom<lariov::DetPedestalService>());
     
     geo::GeometryCore const& geom = *(lar::providerFrom<geo::Geometry>());
     
     // loop over all the channels/raw digits
     for (evd::details::RawDigitInfo_t const& digit_info: *digit_cache) {
       raw::RawDigit const& hit = digit_info.Digit();
       raw::ChannelID_t const channel = hit.Channel();
       
       // skip the bad channels
       if (!channelStatus.IsPresent(channel)) continue;
       // The following test is meant to be temporary until the "correct" solution is implemented
       if (!ProcessChannelWithStatus(channelStatus.Status(channel))) continue;
       
       // we have a list of all channels, but we are drawing only on one plane;
       // most of the channels will not contribute to this plane,
       // and before we start querying databases, unpacking data etc.
       // we want to know it's for something
       
       std::vector<geo::WireID> WireIDs = geom.ChannelToWire(channel);
       
       bool bDrawChannel = false;
       for (geo::WireID const& wireID: WireIDs){
         if (wireID.planeID() != pid) continue; // not us!
         bDrawChannel = true;
         break;
       } // for wires
       if (!bDrawChannel) continue;
       
       // collect bad channels
       bool const bGood = rawopt->fSeeBadChannels || !channelStatus.IsBad(channel);
       
       // nothing else to be done if the channel is not good:
       // cells are marked bad by default and if any good channel falls in any of
       // them, they become good
       if (!bGood) continue;
       
       // at this point we know we have to process this channel
       raw::RawDigit::ADCvector_t const& uncompressed = digit_info.Data();
       
       // recover the pedestal
       float const pedestal = pedestalRetrievalAlg.PedMean(channel);
       
       // loop over all the wires that are covered by this channel;
       // without knowing better, we have to draw into all of them
       for (geo::WireID const& wireID: WireIDs){
         // check that the plane and tpc are the correct ones to draw
         if (wireID.planeID() != pid) continue; // not us!
         
         // do we have anything to do with this wire?
         if (!operation->ProcessWire(wireID)) continue;
         
         // get an iterator over the adc values
         // accumulate all the data of this wire in our "cells"
         size_t const max_tick = std::min({
           uncompressed.size(),
           size_t(fStartTick + fTicks)
           });
         
         for (size_t iTick = fStartTick; iTick < max_tick; ++iTick) {
           
           // do we have anything to do with this wire?
           if (!operation->ProcessTick(iTick)) continue;
           
           float const adc = uncompressed[iTick] - pedestal;
           
           if (!operation->Operate(wireID, iTick, adc)) return false;
           
         } // if good
       } // for wires
     } // for channels
     
     return operation->Finish();
   } // ChannelLooper()

void evd::RawDataDrawer::RunRoIextractor	(	art::Event const &	evt,
		unsigned int	plane
	)

private

Definition at line 1155 of file RawDataDrawer.cxx.

References evd::RawDrawingOptions::CurrentTPC(), hasRegionOfInterest(), LOG_TRACE, and RunOperation().

   {
     art::ServiceHandle<evd::RawDrawingOptions> rawopt;
     geo::PlaneID const pid(rawopt->CurrentTPC(), plane);
     
     // if we have no region of interest, prepare to extract it
     bool const bExtractRoI = !hasRegionOfInterest(plane);
     LOG_TRACE("RawDataDrawer") << "Region of interest for " << pid
       << (bExtractRoI? " extracted": " not extracted") << " on this draw";
     
     if (!bExtractRoI) return;
     
     RoIextractorClass Extractor(pid, this);
     if (!RunOperation(evt, &Extractor)) {
       throw std::runtime_error
         ("RawDataDrawer::RunRoIextractor(): somewhere something went somehow wrong");
     }
     
   } // RawDataDrawer::RunRoIextractor()

void evd::RawDataDrawer::SetDrawingLimits	(	float	low_wire,
		float	high_wire,
		float	low_tdc,
		float	high_tdc
	)

Fills the viewport borders from the specified extremes.

Definition at line 603 of file RawDataDrawer.cxx.

References fDrawingRange, evd::RawDataDrawer::PadResolution_t::height, LOG_DEBUG, PadResolution, SetDrawingLimitsFromRoI(), evd::details::CellGridClass::SetMinTDCCellSize(), evd::details::CellGridClass::SetMinWireCellSize(), evd::details::CellGridClass::SetTDCRange(), evd::details::CellGridClass::SetWireRange(), and evd::RawDataDrawer::PadResolution_t::width.

Referenced by SetDrawingLimitsFromRoI(), and ~RawDataDrawer().

   {
     LOG_DEBUG("RawDataDrawer") << __func__
       << "() setting drawing range as wires ( "
       << low_wire << " - " << high_wire
       << " ), ticks ( " << low_tdc << " - " << high_tdc << " )";
     
     // we need to set the minimum cell size to 1, otherwise some cell will not
     // cover any wire/tick and they will be always empty
     if (PadResolution) {
       // TODO implement support for swapping axes here
       unsigned int wire_pixels = PadResolution.width;
       unsigned int tdc_pixels = PadResolution.height;
       fDrawingRange->SetWireRange(low_wire, high_wire, wire_pixels, 1.F);
       fDrawingRange->SetTDCRange(low_tdc, high_tdc, tdc_pixels, 1.F);
     }
     else {
       LOG_DEBUG("RawDataDrawer")
         << "Pad size not available -- using existing cell size";
       fDrawingRange->SetWireRange(low_wire, high_wire);
       fDrawingRange->SetMinWireCellSize(1.F);
       fDrawingRange->SetTDCRange(low_tdc, high_tdc);
       fDrawingRange->SetMinTDCCellSize(1.F);
     }
     
   } // RawDataDrawer::SetDrawingLimits()

void evd::RawDataDrawer::SetDrawingLimitsFromRoI ( geo::PlaneID::PlaneID_t plane )

private

Definition at line 632 of file RawDataDrawer.cxx.

References ExtractRange(), fTimeMax, fTimeMin, fWireMax, fWireMin, and SetDrawingLimits().

Referenced by RawDigit2D(), and SetDrawingLimits().

   {
     SetDrawingLimits
       (fWireMin[plane], fWireMax[plane], fTimeMin[plane], fTimeMax[plane]);
   } // RawDataDrawer::SetDrawingLimitsFromRoI()