Data handler that replaces time-ordered strip-chart trees with TProfiles. More...

#include <QwTrendHandler.h>

Inheritance diagram for QwTrendHandler:

Collaboration diagram for QwTrendHandler:

Public Member Functions
	QwTrendHandler (const TString &name)
	Constructor with name.

	QwTrendHandler (const QwTrendHandler &source)
	Copy constructor.

	~QwTrendHandler () override
	Virtual destructor.

Int_t	LoadChannelMap (const std::string &mapfile) override
	Load the list of channels to trend (and binning) from the map file.

Int_t	ConnectChannels (QwSubsystemArrayParity &event) override
	Connect to channels from the per-MPS (event) subsystem array.

void	ProcessData () override
	Read the current value of each connected channel.

void	ConstructHistograms (TDirectory *folder, TString &prefix) override
	Book one TProfile strip chart per connected channel.

void	FillHistograms () override
	Fill each strip chart at the current time-ordering index.

Public Member Functions inherited from VQwDataHandler
	VQwDataHandler (const TString &name)

	VQwDataHandler (const VQwDataHandler &source)

virtual void	ParseConfigFile (QwParameterFile &file)

void	SetPointer (QwHelicityPattern *ptr)

void	SetPointer (QwSubsystemArrayParity *ptr)

virtual Int_t	ConnectChannels (QwSubsystemArrayParity &, QwSubsystemArrayParity &asym, QwSubsystemArrayParity &diff)

Int_t	ConnectChannels (QwHelicityPattern &helicitypattern)

virtual void	UpdateBurstCounter (Short_t burstcounter)

virtual void	FinishDataHandler ()

	~VQwDataHandler () override

TString	GetName ()

virtual void	ClearEventData ()

void	InitRunningSum ()

void	AccumulateRunningSum ()

virtual void	AccumulateRunningSum (VQwDataHandler &value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF)

void	CalculateRunningAverage ()

void	PrintValue () const

void	WritePromptSummary (QwPromptSummary *ps, TString type)

virtual void	ConstructTreeBranches (QwRootFile *treerootfile, const std::string &treeprefix="", const std::string &branchprefix="")

virtual void	FillTreeBranches (QwRootFile *treerootfile)

virtual void	ConstructNTupleFields (QwRootFile *treerootfile, const std::string &treeprefix="", const std::string &branchprefix="")
	RNTuple methods.

virtual void	FillNTupleFields (QwRootFile *treerootfile)

void	FillTreeVector (QwRootTreeBranchVector &values) const

void	ConstructBranchAndVector (TTree *tree, TString &prefix, QwRootTreeBranchVector &values)

void	SetRunLabel (TString x)

Int_t	LoadChannelMap ()

Bool_t	PublishInternalValues () const override
	Publish all variables of the subsystem.

Bool_t	PublishByRequest (TString device_name) override
	Try to publish an internal variable matching the submitted name.

Public Member Functions inherited from MQwPublishable_child< QwDataHandlerArray, VQwDataHandler >
	MQwPublishable_child ()
	Default constructor Initializes the child object and sets up self-reference for publishing.

	MQwPublishable_child (const MQwPublishable_child &source)
	Copy constructor.

virtual	~MQwPublishable_child ()
	Virtual destructor.

void	SetParent (QwDataHandlerArray *parent)
	Set the parent container for this child object.

QwDataHandlerArray *	GetParent () const
	Get the parent container for this child object.

Public Member Functions inherited from MQwCloneable< VQwDataHandler, QwTrendHandler >
	~MQwCloneable () override
	Virtual destructor.

VQwDataHandler *	Clone () const override
	Concrete clone method.

const VQwFactory< VQwDataHandler > *	Factory () const override
	Factory getter.

Public Member Functions inherited from VQwCloneable< VQwDataHandler >
virtual	~VQwCloneable ()
	Virtual destructor.

std::string	GetClassName () const
	Get demangled name of this class.

Protected Member Functions
	QwTrendHandler ()
	Default constructor (protected for factory/child access)

Protected Member Functions inherited from VQwDataHandler
	VQwDataHandler ()

virtual Int_t	ConnectChannels (QwSubsystemArrayParity &asym, QwSubsystemArrayParity &diff)

void	SetEventcutErrorFlagPointer (const UInt_t *errorflagptr)

UInt_t	GetEventcutErrorFlag () const

std::pair< EQwHandleType, std::string >	ParseHandledVariable (const std::string &variable)

void	CalcOneOutput (const VQwHardwareChannel dv, VQwHardwareChannel output, std::vector< const VQwHardwareChannel * > &ivs, std::vector< Double_t > &sens)

Protected Member Functions inherited from MQwPublishable_child< QwDataHandlerArray, VQwDataHandler >
Bool_t	RequestExternalValue (const TString &name, VQwHardwareChannel *value) const
	Retrieve the variable name from other subsystem arrays Get the value corresponding to some variable name from a different data array.

const VQwHardwareChannel *	RequestExternalPointer (const TString &name) const
	Retrieve a pointer to an external variable by name Requests a direct pointer to a variable from sibling subsystems via the parent container.

Bool_t	PublishInternalValue (const TString name, const TString desc, const VQwHardwareChannel *element) const
	Publish a variable from this child into the parent container.

Protected Attributes
Int_t	fNbins
	Number of x bins for the strip-chart profiles (bounded storage)

Double_t	fBinWidth

UInt_t	fErrorFlagMask
	Skip filling when (errorflag & mask) != 0 (0 disables the check)

Long64_t	fCounter
	Time-ordering index incremented once per filled event/pattern.

Bool_t	fRolling

std::vector< TH1 * >	fTrend

Protected Attributes inherited from VQwDataHandler
Int_t	fPriority

Short_t	fBurstCounter
	When a datahandler array is processed, handlers with lower priority will be processed before handlers with higher priority.

TString	fName

std::string	fMapFile

std::string	fTreeName

std::string	fTreeComment

std::string	fPrefix

TString	run_label

const UInt_t *	fErrorFlagPtr
	Error flag pointer.

QwSubsystemArrayParity *	fSubsystemArray
	Single event pointer.

QwHelicityPattern *	fHelicityPattern
	Helicity pattern pointer.

std::vector< std::string >	fDependentFull

std::vector< EQwHandleType >	fDependentType

std::vector< std::string >	fDependentName

std::vector< const VQwHardwareChannel * >	fDependentVar

std::vector< Double_t >	fDependentValues

std::vector< VQwHardwareChannel * >	fOutputVar

std::vector< Double_t >	fOutputValues

std::vector< std::vector< TString > >	fPublishList

std::string	ParseSeparator

Bool_t	fKeepRunningSum

Bool_t	fRunningsumFillsTree

VQwDataHandler *	fRunningsum

Additional Inherited Members
Public Types inherited from VQwDataHandler
enum	EQwHandleType { kHandleTypeUnknown =0 , kHandleTypeMps , kHandleTypeAsym , kHandleTypeDiff , kHandleTypeYield }

typedef std::vector< VQwHardwareChannel * >::iterator	Iterator_HdwChan

typedef std::vector< VQwHardwareChannel * >::const_iterator	ConstIterator_HdwChan

Static Public Member Functions inherited from MQwCloneable< VQwDataHandler, QwTrendHandler >
static VQwDataHandler *	Create (const std::string &name)
	Object creation.

static QwTrendHandler *	Cast (QwTrendHandler *type)
	Object dynamic cast.

Detailed Description

Data handler that replaces time-ordered strip-chart trees with TProfiles.

Traditional monitoring plots draw a channel value versus event (or pattern) number by streaming every event into a TTree and later projecting value:CodaEventNumber. That keeps a full, unbinned copy of the data on disk purely so a strip chart can be drawn.

QwTrendHandler instead pre-books one TProfile per configured channel with the time-ordering index (a monotonically increasing counter that mirrors the event/pattern number) on the x-axis and the channel value on the y-axis. Each bin then stores the mean and RMS of the channel over that slice of the run, which is exactly what a strip chart conveys, at a tiny fraction of the storage cost and with no TTree required.

The x-axis auto-extends (TH1::kXaxis) so runs of arbitrary length are handled without knowing the event count in advance. Because the profiles are ordinary ROOT histograms written into the histogram file, Panguin renders them with the existing -type prof option with no plotting-side changes.

Definition at line 39 of file QwTrendHandler.h.

Constructor & Destructor Documentation

◆ QwTrendHandler() [1/3]

QwTrendHandler::QwTrendHandler ( const TString & name )

Constructor with name.

Definition at line 22 of file QwTrendHandler.cc.

: VQwDataHandler(name),
  fNbins(200),
  fBinWidth(1.0),
  fErrorFlagMask(0),
  fCounter(0),
  fRolling(kFALSE)
{
  ParseSeparator = ":";
}

References fBinWidth, fCounter, fErrorFlagMask, fNbins, fRolling, VQwDataHandler::ParseSeparator, and VQwDataHandler::VQwDataHandler().

Referenced by QwTrendHandler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QwTrendHandler() [2/3]

QwTrendHandler::QwTrendHandler ( const QwTrendHandler & source )

Copy constructor.

Copy constructor (histograms are rebuilt, not copied)

Definition at line 34 of file QwTrendHandler.cc.

: VQwDataHandler(source),
  fNbins(source.fNbins),
  fBinWidth(source.fBinWidth),
  fErrorFlagMask(source.fErrorFlagMask),
  fCounter(0),
  fRolling(kFALSE)
{
  // The TProfiles are owned by the ROOT output directory and are recreated in
  // ConstructHistograms(); a cloned handler must not share those pointers.
}

References fBinWidth, fCounter, fErrorFlagMask, fNbins, fRolling, QwTrendHandler(), and VQwDataHandler::VQwDataHandler().

Here is the call graph for this function:

◆ ~QwTrendHandler()

QwTrendHandler::~QwTrendHandler ( )

override

Virtual destructor.

Destructor.

Definition at line 47 of file QwTrendHandler.cc.

{
  // The TProfiles are owned by the ROOT output directory (SetDirectory), so
  // they must not be deleted here.
  fTrend.clear();
}

References fTrend.

◆ QwTrendHandler() [3/3]

QwTrendHandler::QwTrendHandler ( )

inlineprotected

Default constructor (protected for factory/child access)

Definition at line 71 of file QwTrendHandler.h.

71{ }

Member Function Documentation

◆ ConnectChannels()

Int_t QwTrendHandler::ConnectChannels ( QwSubsystemArrayParity & event )

overridevirtual

Connect to channels from the per-MPS (event) subsystem array.

Parameters

event Subsystem array providing per-MPS yields/mps channels

Returns: 0 on success

Connect to the requested channels in the per-MPS (event) subsystem array.

Reimplemented from VQwDataHandler.

Definition at line 115 of file QwTrendHandler.cc.

{
  SetEventcutErrorFlagPointer(event.GetEventcutErrorFlagPointer());
 
  for (size_t dv = 0; dv < fDependentName.size(); dv++) {
    // Only yield/mps tokens are meaningful for the per-MPS array
    if (fDependentType.at(dv) == kHandleTypeAsym ||
        fDependentType.at(dv) == kHandleTypeDiff) {
      continue;
    }
    const VQwHardwareChannel* dv_ptr =
        event.RequestExternalPointer(fDependentName.at(dv));
    if (dv_ptr == NULL) {
      QwWarning << "QwTrendHandler::ConnectChannels(event): channel "
                << fDependentName.at(dv) << " was not found." << QwLog::endl;
      continue;
    }
    fDependentVar.push_back(dv_ptr);
  }
  return 0;
}

References QwLog::endl(), VQwDataHandler::fDependentName, VQwDataHandler::fDependentType, VQwDataHandler::fDependentVar, QwSubsystemArrayParity::GetEventcutErrorFlagPointer(), VQwDataHandler::kHandleTypeAsym, VQwDataHandler::kHandleTypeDiff, QwWarning, and VQwDataHandler::SetEventcutErrorFlagPointer().

Here is the call graph for this function:

◆ ConstructHistograms()

void QwTrendHandler::ConstructHistograms	(	TDirectory *	folder,
		TString &	prefix )

overridevirtual

Book one TProfile strip chart per connected channel.

Reimplemented from VQwDataHandler.

Definition at line 150 of file QwTrendHandler.cc.

{
  // folder == NULL means we are booking into a live, fixed-size TMapFile, where
  // the x-axis must not auto-extend; draw a rolling strip chart instead.
  fRolling = (folder == NULL);
  fTrend.assign(fDependentVar.size(), NULL);
  for (size_t i = 0; i < fDependentVar.size(); i++) {
    if (fDependentVar.at(i) == NULL) continue;
 
    TString channel = fDependentVar.at(i)->GetElementName();
    TString name  = prefix + fName + "_" + channel;
    TString title = TString("Trend ") + channel
                  + ";event index;" + channel;
 
    // In file mode 'folder' is the target directory (e.g. mul_histo).  In live
    // TMapFile mode QwRootFile passes a NULL folder, so every trend handler
    // books into the single flat mapfile directory.  The same handler is loaded
    // in both the pattern (mul) and burst arrays, which would create two
    // profiles with identical names; the second construction silently replaces
    // the first in the directory and only the survivor is streamed.  Keep the
    // names unique so the first (pattern-scope, per-pattern) profile is not
    // overwritten by the later burst-scope copy.
    if (folder == NULL && gDirectory) {
      TString unique = name;
      int dup = 1;
      while (gDirectory->FindObject(unique) != NULL) {
        unique = name + Form("_%d", ++dup);
      }
      name = unique;
    }
 
    TH1* chart = NULL;
    if (fRolling) {
      // Live TMapFile mode: use a plain TH1D value trace.  TProfile keeps
      // several independent internal arrays (fArray, fSumw2, fBinEntries,
      // fBinSumw2) that TMapFile::Update() does not marshal robustly and which
      // deterministically corrupt the shared-memory region after a few hundred
      // updates.  A TH1D has a single fixed fArray, is filled with
      // SetBinContent (no reallocation), and streams reliably in a TMapFile
      // exactly like the subsystem monitoring histograms.  The chart stays
      // attached to the current directory (the mapfile) so it is re-streamed.
      chart = new TH1D(name, title, fNbins, 0.0, fNbins * fBinWidth);
    } else {
      // File mode: a TProfile gives the mean +/- RMS per bin and can safely
      // auto-extend its x-axis for runs of arbitrary length.
      TProfile* prof =
          new TProfile(name, title, fNbins, 0.0, fNbins * fBinWidth);
      prof->SetCanExtend(TH1::kXaxis);
      prof->SetDirectory(folder);
      chart = prof;
    }
    fTrend.at(i) = chart;
  }
}

References fBinWidth, VQwDataHandler::fDependentVar, VQwDataHandler::fName, fNbins, fRolling, and fTrend.

◆ FillHistograms()

void QwTrendHandler::FillHistograms ( )

overridevirtual

Fill each strip chart at the current time-ordering index.

Reimplemented from VQwDataHandler.

Definition at line 206 of file QwTrendHandler.cc.

{
  const bool good =
      !(fErrorFlagMask != 0 && fErrorFlagPtr != NULL &&
        (*fErrorFlagPtr & fErrorFlagMask) != 0);
 
  // In rolling (live mapfile) mode the fixed x-range spans this many event
  // indices; the time index wraps within it so the chart sweeps continuously.
  const Long64_t span =
      (Long64_t)(fNbins * fBinWidth) > 0 ? (Long64_t)(fNbins * fBinWidth) : 1;
  const Double_t xpos = fRolling ? (Double_t)(fCounter % span) : (Double_t) fCounter;
 
  // NOTE: In live TMapFile mode we deliberately do NOT call TProfile::Reset()
  // between sweeps.  Reset() (and Fill's lazy buffer/array management) can
  // change the object's serialized footprint inside the fixed-size mmap and
  // crash TMapFile::Update().  Instead the fixed x-range simply accumulates:
  // each bin holds the running mean over all sweeps, which is stable in shared
  // memory.  (DIAGNOSTIC: reset disabled to isolate the TMapFile::Update crash.)
 
  if (good) {
    for (size_t i = 0; i < fTrend.size(); i++) {
      if (fTrend.at(i) != NULL && i < fDependentValues.size()) {
        if (fRolling) {
          // Live rolling trace: overwrite this event index's bin with the
          // latest value.  SetBinContent never reallocates, so the object's
          // footprint is stable in the fixed-size TMapFile.
          const Int_t bin = fTrend.at(i)->GetXaxis()->FindBin(xpos);
          fTrend.at(i)->SetBinContent(bin, fDependentValues.at(i));
        } else {
          // File mode: accumulate mean +/- RMS in the TProfile.
          static_cast<TProfile*>(fTrend.at(i))->Fill(xpos, fDependentValues.at(i));
        }
      }
    }
  }
  // Advance the time index even for skipped events so the x-axis stays aligned
  // with the true event/pattern ordering.
  fCounter++;
}

References fBinWidth, fCounter, VQwDataHandler::fDependentValues, fErrorFlagMask, VQwDataHandler::fErrorFlagPtr, fNbins, fRolling, and fTrend.

◆ LoadChannelMap()

Int_t QwTrendHandler::LoadChannelMap ( const std::string & mapfile )

overridevirtual

Load the list of channels to trend (and binning) from the map file.

Load the list of channels to trend, plus optional binning.

Map format (one channel token per line):

nbins = 200          # optional, default 200
binwidth = 1         # optional initial event(s) per bin, default 1
mask  = 0x0          # optional error-flag mask, default 0 (fill always)
asym:bcm_an_ds
diff:bpm1c10WSX
yield:sam1

The type prefix (asym/diff/yield/mps) selects which subsystem array supplies the channel; the remainder is the channel name.

Parameters

mapfile Filename of map file

Returns: Zero on success

Reimplemented from VQwDataHandler.

Definition at line 71 of file QwTrendHandler.cc.

{
  QwParameterFile map(mapfile);
 
  // Read optional binning/mask settings (searched over the whole file)
  TString value;
  if (map.FileHasVariablePair("=", "nbins", value)) {
    fNbins = value.Atoi();
  }
  if (map.FileHasVariablePair("=", "binwidth", value)) {
    fBinWidth = value.Atof();
    if (fBinWidth <= 0.0) fBinWidth = 1.0;
  }
  if (map.FileHasVariablePair("=", "mask", value)) {
    fErrorFlagMask = QwParameterFile::GetUInt(value);
  }
 
  // Read the channel list, one token per line (this map has no [sections])
  map.RewindToFileStart();
  while (map.ReadNextLine()) {
    map.TrimComment();
    map.TrimWhitespace();
    if (map.LineIsEmpty()) continue;
    if (map.LineHasSectionHeader()) continue;
    // Skip the key=value settings lines handled above
    if (map.GetLine().find('=') != std::string::npos) continue;
 
    std::string token = map.GetNextToken(" \t,");
    if (token.empty()) continue;
 
    std::pair<EQwHandleType, std::string> type_name = ParseHandledVariable(token);
    fDependentType.push_back(type_name.first);
    fDependentName.push_back(type_name.second);
    fDependentFull.push_back(token);
  }
 
  QwMessage << "QwTrendHandler " << fName << ": trending "
            << fDependentName.size() << " channel(s) into TProfiles ("
            << fNbins << " bins, initial bin width " << fBinWidth
            << " event(s), x auto-extends)." << QwLog::endl;
  return 0;
}

References QwLog::endl(), fBinWidth, VQwDataHandler::fDependentFull, VQwDataHandler::fDependentName, VQwDataHandler::fDependentType, fErrorFlagMask, QwParameterFile::FileHasVariablePair(), VQwDataHandler::fName, fNbins, QwParameterFile::GetLine(), QwParameterFile::GetNextToken(), QwParameterFile::GetUInt(), QwParameterFile::LineHasSectionHeader(), QwParameterFile::LineIsEmpty(), VQwDataHandler::ParseHandledVariable(), QwMessage, QwParameterFile::ReadNextLine(), QwParameterFile::RewindToFileStart(), QwParameterFile::TrimComment(), and QwParameterFile::TrimWhitespace().

Here is the call graph for this function:

◆ ProcessData()

void QwTrendHandler::ProcessData ( )

overridevirtual

Read the current value of each connected channel.

Reimplemented from VQwDataHandler.

Definition at line 138 of file QwTrendHandler.cc.

{
  if (fDependentValues.size() != fDependentVar.size()) {
    fDependentValues.resize(fDependentVar.size(), 0.0);
  }
  for (size_t i = 0; i < fDependentVar.size(); i++) {
    fDependentValues.at(i) =
        (fDependentVar.at(i) != NULL) ? fDependentVar.at(i)->GetValue() : 0.0;
  }
}

References VQwDataHandler::fDependentValues, and VQwDataHandler::fDependentVar.

Field Documentation

◆ fBinWidth

Double_t QwTrendHandler::fBinWidth

protected

Initial event/pattern indices per bin; the axis auto-extends (doubling the bin width) once the run grows past fNbins*fBinWidth events

Definition at line 77 of file QwTrendHandler.h.

Referenced by ConstructHistograms(), FillHistograms(), LoadChannelMap(), QwTrendHandler(), and QwTrendHandler().

◆ fCounter

Long64_t QwTrendHandler::fCounter

protected

Time-ordering index incremented once per filled event/pattern.

Definition at line 81 of file QwTrendHandler.h.

Referenced by FillHistograms(), QwTrendHandler(), and QwTrendHandler().

◆ fErrorFlagMask

UInt_t QwTrendHandler::fErrorFlagMask

protected

Skip filling when (errorflag & mask) != 0 (0 disables the check)

Definition at line 79 of file QwTrendHandler.h.

Referenced by FillHistograms(), LoadChannelMap(), QwTrendHandler(), and QwTrendHandler().

◆ fNbins

Int_t QwTrendHandler::fNbins

protected

Number of x bins for the strip-chart profiles (bounded storage)

Definition at line 74 of file QwTrendHandler.h.

Referenced by ConstructHistograms(), FillHistograms(), LoadChannelMap(), QwTrendHandler(), and QwTrendHandler().

◆ fRolling

Bool_t QwTrendHandler::fRolling

protected

True when booked into a fixed-size live TMapFile (ConstructHistograms was called with folder == NULL). In that mode the strip chart is a rolling window drawn with a plain TH1D value trace (SetBinContent): the time index wraps back to the left edge and each new event overwrites its bin. TProfile's several internal arrays (fArray/fSumw2/fBinEntries/fBinSumw2) are not marshalled robustly by TMapFile::Update() and crash the live monitor, so TProfiles are used only for the (auto-extending) file output.

Definition at line 90 of file QwTrendHandler.h.

Referenced by ConstructHistograms(), FillHistograms(), QwTrendHandler(), and QwTrendHandler().

◆ fTrend

std::vector<TH1*> QwTrendHandler::fTrend

protected

One strip chart per connected channel (owned by the ROOT output directory). Held as the TH1 base so file mode can use a TProfile (mean +/- RMS) while live TMapFile mode uses a robust TH1D value trace.

Definition at line 95 of file QwTrendHandler.h.

Referenced by ConstructHistograms(), FillHistograms(), and ~QwTrendHandler().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ QwTrendHandler() [1/3]

◆ QwTrendHandler() [2/3]

◆ ~QwTrendHandler()

◆ QwTrendHandler() [3/3]

Member Function Documentation

◆ ConnectChannels()

◆ ConstructHistograms()

◆ FillHistograms()

◆ LoadChannelMap()

◆ ProcessData()

Field Documentation

◆ fBinWidth

◆ fCounter

◆ fErrorFlagMask

◆ fNbins

◆ fRolling

◆ fTrend