evd::RawDataDrawer Class Reference

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 1324 of file RawDataDrawer.cxx.

References raw::RawDigit::Channel(), geo::GeometryCore::ChannelToWire(), evd::RawDrawingOptions::CurrentTPC(), d, digit_cache, evd::RawDrawingOptions::fDrawRawDataOrCalibWires, evd::RawDrawingOptions::fPedestalOption, evd::RawDrawingOptions::fRawDataLabel, evd::RawDrawingOptions::fSeeBadChannels, raw::RawDigit::GetPedestal(), 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);
      // recover the pedestal
      float  pedestal = 0;
      if (rawopt->fPedestalOption == 0)
        {
          pedestal = pedestalRetrievalAlg.PedMean(channel);
        }
      else if (rawopt->fPedestalOption == 1)
        {
          pedestal = hit.GetPedestal();
        }
      else if (rawopt->fPedestalOption == 2)
        {
          pedestal = 0;
        }
      else
        {
          mf::LogWarning  ("RawDataDrawer") << " PedestalOption is not understood: " << rawopt->fPedestalOption << ".  Pedestals not subtracted.";
        }

        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 1396 of file RawDataDrawer.cxx.

References evd::RawDrawingOptions::CurrentTPC(), evd::details::RawDigitInfo_t::Data(), digit_cache, evd::details::RawDigitInfo_t::DigitPtr(), evd::details::RawDigitCacheDataClass::empty(), evd::RawDrawingOptions::fDrawRawDataOrCalibWires, evd::details::RawDigitCacheDataClass::FindChannel(), evd::RawDrawingOptions::fPedestalOption, evd::RawDrawingOptions::fRawDataLabel, evd::RawDrawingOptions::fSeeBadChannels, raw::RawDigit::GetPedestal(), 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();
    

      // recover the pedestal
      float  pedestal = 0;
      if (rawopt->fPedestalOption == 0)
        {
          pedestal = pedestalRetrievalAlg.PedMean(channel);
        }
      else if (rawopt->fPedestalOption == 1)
        {
          pedestal = pDigit->DigitPtr()->GetPedestal();
        }
      else if (rawopt->fPedestalOption == 2)
        {
          pedestal = 0;
        }
      else
        {
          mf::LogWarning  ("RawDataDrawer") << " PedestalOption is not understood: " << rawopt->fPedestalOption << ".  Pedestals not subtracted.";
        }
    
    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 1316 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 1593 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 1289 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 1569 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 1614 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 1010 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 1195 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 1577 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 1098 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::fPedestalOption, evd::RawDrawingOptions::fRawDataLabel, evd::RawDrawingOptions::fSeeBadChannels, fStartTick, fTicks, raw::RawDigit::GetPedestal(), 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  pedestal = 0;
      if (rawopt->fPedestalOption == 0)
        {
          pedestal = pedestalRetrievalAlg.PedMean(channel);
        }
      else if (rawopt->fPedestalOption == 1)
        {
          pedestal = hit.GetPedestal();
        }
      else if (rawopt->fPedestalOption == 2)
        {
          pedestal = 0;
        }
      else
        {
          mf::LogWarning  ("RawDataDrawer") << " PedestalOption is not understood: " << rawopt->fPedestalOption << ".  Pedestals not subtracted.";
        }

      // 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;
          //std::cout << "adc, pedestal: " << adc << " " << pedestal << std::endl;
          
          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 1172 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()

void evd::RawDataDrawer::SetDrawingLimitsFromRoI ( geo::PlaneID const  pid )

inlineprivate

Definition at line 211 of file RawDataDrawer.h.

References geo::PlaneID::Plane.

      { SetDrawingLimitsFromRoI(pid.Plane); }

double evd::RawDataDrawer::StartTick ( ) const

inline

Definition at line 84 of file RawDataDrawer.h.

Referenced by evd::TQPad::BookHistogram(), and evd::TWireProjPad::TWireProjPad().

{ return fStartTick; }

double evd::RawDataDrawer::TotalClockTicks ( ) const

inline

Definition at line 85 of file RawDataDrawer.h.

Referenced by evd::TQPad::BookHistogram(), GetRegionOfInterest(), and evd::TWireProjPad::TWireProjPad().

{ return fTicks; }

Friends And Related Function Documentation

friend class BoxDrawer

friend

Definition at line 134 of file RawDataDrawer.h.

Referenced by RawDigit2D().

friend class RoIextractorClass

friend

Definition at line 144 of file RawDataDrawer.h.

Referenced by RawDigit2D().

Member Data Documentation

evd::details::RawDigitCacheDataClass* evd::RawDataDrawer::digit_cache

private

Cache of raw digits.

Definition at line 148 of file RawDataDrawer.h.

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

std::vector< raw::RawDigit > const evd::RawDataDrawer::EmptyRawDigits

staticprivate

Empty collection, used in return value of invalid digits.

Definition at line 215 of file RawDataDrawer.h.

details::CacheID_t* evd::RawDataDrawer::fCacheID

private

information about the last processed plane

Definition at line 175 of file RawDataDrawer.h.

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

std::vector<double> evd::RawDataDrawer::fConvertedCharge

private

Sum of Charge Converted using Birks' formula.

Definition at line 171 of file RawDataDrawer.h.

Referenced by GetChargeSum(), and RawDataDrawer().

details::CellGridClass* evd::RawDataDrawer::fDrawingRange

private

information about the viewport

Definition at line 178 of file RawDataDrawer.h.

Referenced by ExtractRange(), QueueDrawingBoxes(), SetDrawingLimits(), and ~RawDataDrawer().

std::vector<double> evd::RawDataDrawer::fRawCharge

private

Sum of Raw Charge.

Definition at line 170 of file RawDataDrawer.h.

Referenced by GetChargeSum(), and RawDataDrawer().

double evd::RawDataDrawer::fStartTick

private

low tick

Definition at line 162 of file RawDataDrawer.h.

Referenced by RawDataDrawer(), and RunOperation().

double evd::RawDataDrawer::fTicks

private

number of ticks of the clock

Definition at line 163 of file RawDataDrawer.h.

Referenced by RawDataDrawer(), and RunOperation().

std::vector<int> evd::RawDataDrawer::fTimeMax

private

highest time in interesting region for each plane

Definition at line 168 of file RawDataDrawer.h.

Referenced by GetRegionOfInterest(), hasRegionOfInterest(), RawDataDrawer(), RawDigit2D(), ResetRegionOfInterest(), and SetDrawingLimitsFromRoI().

std::vector<int> evd::RawDataDrawer::fTimeMin

private

lowest time in interesting region for each plane

Definition at line 167 of file RawDataDrawer.h.

Referenced by GetRegionOfInterest(), RawDataDrawer(), RawDigit2D(), ResetRegionOfInterest(), and SetDrawingLimitsFromRoI().

std::vector<int> evd::RawDataDrawer::fWireMax

private

highest wire in interesting region for each plane

Definition at line 166 of file RawDataDrawer.h.

Referenced by GetRegionOfInterest(), hasRegionOfInterest(), RawDataDrawer(), RawDigit2D(), ResetRegionOfInterest(), and SetDrawingLimitsFromRoI().

std::vector<int> evd::RawDataDrawer::fWireMin

private

lowest wire in interesting region for each plane

Definition at line 165 of file RawDataDrawer.h.

Referenced by GetRegionOfInterest(), RawDataDrawer(), RawDigit2D(), ResetRegionOfInterest(), and SetDrawingLimitsFromRoI().

PadResolution_t evd::RawDataDrawer::PadResolution

private

stored pad resolution

Definition at line 173 of file RawDataDrawer.h.

Referenced by ExtractRange(), and SetDrawingLimits().

---

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

• /cvmfs/larsoft.opensciencegrid.org/products/lareventdisplay/v07_02_02/source/lareventdisplay/EventDisplay/RawDataDrawer.h
• /cvmfs/larsoft.opensciencegrid.org/products/lareventdisplay/v07_02_02/source/lareventdisplay/EventDisplay/RawDataDrawer.cxx