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, detinfo::DetectorPropertiesData const &detProp, 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, detinfo::DetectorPropertiesData const &detProp, 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 695 of file RawDataDrawer.cxx.

    : digit_cache(new details::RawDigitCacheDataClass)
    , fStartTick(0)
    , fTicks(2048)
    , fCacheID(new details::CacheID_t)
    , fDrawingRange(new details::CellGridClass)
  {
    art::ServiceHandle<geo::Geometry const> geo;

    art::ServiceHandle<evd::RawDrawingOptions const> 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 721 of file RawDataDrawer.cxx.

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

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

  {

    // Check if we're supposed to draw raw hits at all
    art::ServiceHandle<evd::RawDrawingOptions const> rawopt;
    if (rawopt->fDrawRawDataOrCalibWires == 1) return;

    art::ServiceHandle<geo::Geometry const> geo;

    geo::PlaneID const pid(rawopt->CurrentTPC(), plane);

    for (const auto& rawDataLabel : rawopt->fRawDataLabels) {
      details::CacheID_t NewCacheID(evt, rawDataLabel, pid);
      GetRawDigits(evt, NewCacheID);

      lariov::ChannelStatusProvider const& channelStatus =
        art::ServiceHandle<lariov::ChannelStatusService const>()->GetProvider();

      //get pedestal conditions
      const lariov::DetPedestalProvider& pedestalRetrievalAlg =
        art::ServiceHandle<lariov::DetPedestalService const>()->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
    }     //end loop over labels
  }

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

Definition at line 1554 of file RawDataDrawer.cxx.

  {

    // Check if we're supposed to draw raw hits at all
    art::ServiceHandle<evd::RawDrawingOptions const> rawopt;
    if (rawopt->fDrawRawDataOrCalibWires == 1) return;

    // make sure we have the raw digits cached
    geo::PlaneID const pid(rawopt->CurrentTPC(), plane);

    // loop over labels
    for (const auto& rawDataLabel : rawopt->fRawDataLabels) {
      details::CacheID_t NewCacheID(evt, rawDataLabel, pid);
      GetRawDigits(evt, NewCacheID);

      if (digit_cache->empty()) return;

      geo::WireID const wireid(pid, wire);

      // find the channel
      art::ServiceHandle<geo::Geometry const> 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 const>()->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 const>()->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... actually no, this can happen if the RawDigits are per TPC (or something)
                   //                mf::LogWarning("RawDataDrawer") << __func__
                   //                << ": can't find raw digit for channel #" << channel
                   //                << " (" << std::string(wireid) << ")";
        continue;
      }

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

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

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

private

Reads raw::RawDigits; also triggers Reset()

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

  {
    MF_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 1447 of file RawDataDrawer.cxx.

  {
    art::ServiceHandle<geo::Geometry const> 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 1728 of file RawDataDrawer.cxx.

  {

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

  {
    // 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 const> 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 1159 of file RawDataDrawer.cxx.

  {
    //
    // All the information is now collected in BoxInfo.
    // Make boxes out of it.
    //
    evd::RawDrawingOptions const& rawopt = *art::ServiceHandle<evd::RawDrawingOptions const>();

    MF_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 const> cst;

    geo::GeometryCore const& geom = *art::ServiceHandle<geo::Geometry const>();
    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);
      /*
             MF_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)

    MF_LOG_DEBUG("RawDataDrawer") << "Sent " << nDrawnBoxes << "/" << BoxInfo.size()
                                  << " boxes to be rendered";
  } // RawDataDrawer::QueueDrawingBoxes()

void evd::RawDataDrawer::RawDigit2D	(	art::Event const &	evt,
		detinfo::DetectorPropertiesData const &	detProp,
		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 1333 of file RawDataDrawer.cxx.

  {
    art::ServiceHandle<evd::RawDrawingOptions const> 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;

    art::ServiceHandle<geo::Geometry const> geom;

    // Need to loop over the labels, but we don't want to zap existing cached RawDigits that are valid
    // So... do the painful search to make sure the RawDigits we recover at those we are searching for.
    bool theDroidIAmLookingFor = false;

    // Loop over labels
    for (const auto& rawDataLabel : rawopt->fRawDataLabels) {
      // 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, rawDataLabel, pid);
      GetRawDigits(evt, NewCacheID);

      // Painful check to see if these RawDigits contain the droids we are looking for
      for (const auto& rawDigit : digit_cache->Digits()) {
        std::vector<geo::WireID> WireIDs = geom->ChannelToWire(rawDigit.Channel());

        for (geo::WireID const& wireID : WireIDs) {
          if (wireID.planeID() != pid) continue; // not us!
          theDroidIAmLookingFor = true;
          break;
        } // for wires

        if (theDroidIAmLookingFor) break;
      }

      if (theDroidIAmLookingFor) break;
    }

    if (!theDroidIAmLookingFor) return;

    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
      MF_LOG_DEBUG("RawDataDrawer") << __func__ << "() setting up one-pass drawing";
      operation.reset(new BoxDrawer(detProp, pid, this, view));

      if (!hasRoI) { // we don't have any RoI; since it's cheap, let's get it
        MF_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) {
        MF_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 {
        MF_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
      MF_LOG_DEBUG("RawDataDrawer") << __func__ << "() setting up drawing";
      BoxDrawer drawer(detProp, 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 1737 of file RawDataDrawer.cxx.

  {

    MF_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, detinfo::DetectorPropertiesData const &  detProp, evdb::View2D *  view, unsigned int  plane  )

private

Definition at line 1238 of file RawDataDrawer.cxx.

  {

    // Check if we're supposed to draw raw hits at all
    art::ServiceHandle<evd::RawDrawingOptions const> rawopt;
    if (rawopt->fDrawRawDataOrCalibWires == 1) return;

    geo::PlaneID const pid(rawopt->CurrentTPC(), plane);
    BoxDrawer drawer(detProp, 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 964 of file RawDataDrawer.cxx.

  {
    geo::PlaneID const& pid = operation->PlaneID();
    art::ServiceHandle<evd::RawDrawingOptions const> rawopt;

    if (digit_cache->empty()) return true;

    MF_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 const>()->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 1309 of file RawDataDrawer.cxx.

  {
    art::ServiceHandle<evd::RawDrawingOptions const> rawopt;
    geo::PlaneID const pid(rawopt->CurrentTPC(), plane);

    // if we have no region of interest, prepare to extract it
    bool const bExtractRoI = !hasRegionOfInterest(plane);
    MF_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 730 of file RawDataDrawer.cxx.

  {
    MF_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 {
      MF_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 756 of file RawDataDrawer.cxx.

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

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

inlineprivate

Definition at line 205 of file RawDataDrawer.h.

    {
      SetDrawingLimitsFromRoI(pid.Plane);
    }

double evd::RawDataDrawer::StartTick ( ) const

inline

Definition at line 77 of file RawDataDrawer.h.

    {
      return fStartTick;
    }

double evd::RawDataDrawer::TotalClockTicks ( ) const

inline

Definition at line 82 of file RawDataDrawer.h.

    {
      return fTicks;
    }

Friends And Related Function Documentation

friend class BoxDrawer

friend

Definition at line 130 of file RawDataDrawer.h.

friend class RoIextractorClass

friend

Definition at line 140 of file RawDataDrawer.h.

Member Data Documentation

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

private

Cache of raw digits.

Definition at line 144 of file RawDataDrawer.h.

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

staticprivate

Empty collection, used in return value of invalid digits.

Definition at line 211 of file RawDataDrawer.h.

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

private

information about the last processed plane

Definition at line 170 of file RawDataDrawer.h.

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

private

Sum of Charge Converted using Birks' formula.

Definition at line 166 of file RawDataDrawer.h.

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

private

information about the viewport

Definition at line 173 of file RawDataDrawer.h.

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

private

Sum of Raw Charge.

Definition at line 165 of file RawDataDrawer.h.

double evd::RawDataDrawer::fStartTick

private

low tick

Definition at line 157 of file RawDataDrawer.h.

double evd::RawDataDrawer::fTicks

private

number of ticks of the clock

Definition at line 158 of file RawDataDrawer.h.

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

private

highest time in interesting region for each plane

Definition at line 163 of file RawDataDrawer.h.

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

private

lowest time in interesting region for each plane

Definition at line 162 of file RawDataDrawer.h.

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

private

highest wire in interesting region for each plane

Definition at line 161 of file RawDataDrawer.h.

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

private

lowest wire in interesting region for each plane

Definition at line 160 of file RawDataDrawer.h.

PadResolution_t evd::RawDataDrawer::PadResolution

private

stored pad resolution

Definition at line 168 of file RawDataDrawer.h.

---

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

• lareventdisplay/lareventdisplay/EventDisplay/RawDataDrawer.h
• lareventdisplay/lareventdisplay/EventDisplay/RawDataDrawer.cxx