Concrete hardware channel for VQWK ADC modules (6x32-bit words) More...

#include <QwVQWK_Channel.h>

Inheritance diagram for QwVQWK_Channel:

Collaboration diagram for QwVQWK_Channel:

Public Member Functions
	QwVQWK_Channel ()

	QwVQWK_Channel (TString name, TString datatosave="raw")

	QwVQWK_Channel (const QwVQWK_Channel &value)

	QwVQWK_Channel (const QwVQWK_Channel &value, VQwDataElement::EDataToSave datatosave)

	~QwVQWK_Channel () override

void	CopyFrom (const QwVQWK_Channel &value)

VQwHardwareChannel *	Clone (VQwDataElement::EDataToSave datatosave) const override

void	InitializeChannel (TString name, TString datatosave) override
	Initialize the fields in this object.

void	InitializeChannel (TString subsystem, TString instrumenttype, TString name, TString datatosave) override
	Initialize the fields in this object.

void	LoadChannelParameters (QwParameterFile &paramfile) override

void	SetDefaultSampleSize (size_t num_samples_map)

void	ClearEventData () override
	Clear the event data in this element.

void	RandomizeEventData (int helicity=0.0, double time=0.0) override
	Internally generate random event data.

void	ForceMapfileSampleSize ()

void	SmearByResolution (double resolution) override

void	SetHardwareSum (Double_t hwsum, UInt_t sequencenumber=0)

void	SetEventData (Double_t *block, UInt_t sequencenumber=0)

void	SetRawEventData () override

void	EncodeEventData (std::vector< UInt_t > &buffer) override
	Encode the event data into a CODA buffer.

Int_t	ProcessEvBuffer (UInt_t *buffer, UInt_t num_words_left, UInt_t index=0) override
	Decode the event data from a CODA buffer.

void	ProcessEvent () override
	Process the event data according to pedestal and calibration factor.

QwVQWK_Channel &	operator= (const QwVQWK_Channel &value)

void	AssignScaledValue (const QwVQWK_Channel &value, Double_t scale)

void	AssignValueFrom (const VQwDataElement *valueptr) override

void	AddValueFrom (const VQwHardwareChannel *valueptr) override

void	SubtractValueFrom (const VQwHardwareChannel *valueptr) override

void	MultiplyBy (const VQwHardwareChannel *valueptr) override

void	DivideBy (const VQwHardwareChannel *valueptr) override

void	ArcTan (const QwVQWK_Channel &value)

QwVQWK_Channel &	operator+= (const QwVQWK_Channel &value)

QwVQWK_Channel &	operator-= (const QwVQWK_Channel &value)

QwVQWK_Channel &	operator*= (const QwVQWK_Channel &value)

VQwHardwareChannel &	operator+= (const VQwHardwareChannel &input) override

VQwHardwareChannel &	operator-= (const VQwHardwareChannel &input) override

VQwHardwareChannel &	operator*= (const VQwHardwareChannel &input) override

VQwHardwareChannel &	operator/= (const VQwHardwareChannel &input) override

const QwVQWK_Channel	operator+ (const QwVQWK_Channel &value) const

const QwVQWK_Channel	operator- (const QwVQWK_Channel &value) const

const QwVQWK_Channel	operator* (const QwVQWK_Channel &value) const

void	Sum (const QwVQWK_Channel &value1, const QwVQWK_Channel &value2)

void	Difference (const QwVQWK_Channel &value1, const QwVQWK_Channel &value2)

void	Ratio (const QwVQWK_Channel &numer, const QwVQWK_Channel &denom)

void	Product (const QwVQWK_Channel &value1, const QwVQWK_Channel &value2)

void	DivideBy (const QwVQWK_Channel &denom)

void	AddChannelOffset (Double_t Offset)

void	Scale (Double_t Offset) override

void	AccumulateRunningSum (const QwVQWK_Channel &value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF)

void	AccumulateRunningSum (const VQwHardwareChannel *value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF) override

void	DeaccumulateRunningSum (const QwVQWK_Channel &value, Int_t ErrorMask=0xFFFFFFF)

void	CalculateRunningAverage () override

Bool_t	MatchSequenceNumber (size_t seqnum)

Bool_t	MatchNumberOfSamples (size_t numsamp)

Bool_t	ApplySingleEventCuts (Double_t LL, Double_t UL)

Bool_t	ApplySingleEventCuts () override

void	PrintErrorCounters () const override
	report number of events failed due to HW and event cut failure

void	SetVQWKSaturationLimt (Double_t sat_volts=8.5)

Double_t	GetVQWKSaturationLimt ()

Int_t	ApplyHWChecks () override

void	IncrementErrorCounters () override

void	ConstructHistograms (TDirectory *folder, TString &prefix) override
	Construct the histograms for this data element.

void	FillHistograms () override
	Fill the histograms for this data element.

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

void	ConstructBranch (TTree *tree, TString &prefix) override

void	FillTreeVector (QwRootTreeBranchVector &values) const override

Int_t	GetRawValue (size_t element) const override

Double_t	GetValue (size_t element) const override

Double_t	GetValueM2 (size_t element) const override

Double_t	GetValueError (size_t element) const override

Double_t	GetAverageVolts () const

size_t	GetSequenceNumber () const

size_t	GetNumberOfSamples () const

void	SetCalibrationToVolts ()

void	PrintValue () const override
	Print single line of value and error of this data element.

void	PrintInfo () const override
	Print multiple lines of information about this data element.

void	Blind (const QwBlinder *blinder)
	Blind this channel as an asymmetry.

void	Blind (const QwBlinder *blinder, const QwVQWK_Channel &yield)
	Blind this channel as a difference.

void	ScaledAdd (Double_t scale, const VQwHardwareChannel *value) override

virtual void	LoadMockDataParameters (QwParameterFile &paramfile)
	Load the mock data parameters from the current line in the param file.

Int_t	GetRawValue () const

Double_t	GetValue () const

Double_t	GetValueM2 () const

Double_t	GetValueError () const

Double_t	GetValueWidth () const

Double_t	GetValueWidth (size_t element) const

virtual void	DeaccumulateRunningSum (const VQwHardwareChannel *value, Int_t ErrorMask=0xFFFFFFF)

virtual VQwHardwareChannel *	Clone () const

Public Member Functions inherited from VQwHardwareChannel
	VQwHardwareChannel ()

	VQwHardwareChannel (const VQwHardwareChannel &value)

	VQwHardwareChannel (const VQwHardwareChannel &value, VQwDataElement::EDataToSave datatosave)

	~VQwHardwareChannel () override

void	CopyFrom (const VQwHardwareChannel &value)

void	ProcessOptions ()

size_t	GetNumberOfDataWords ()
	Get the number of data words in this data element.

size_t	GetNumberOfSubelements ()
	Get the number of subelements in this data element.

Int_t	GetRawValue () const

Double_t	GetValue () const

Double_t	GetValueM2 () const

Double_t	GetValueError () const

Double_t	GetValueWidth () const

Double_t	GetValueWidth (size_t element) const

void	ClearEventData () override
	Clear the event data in this element.

void	InitializeChannel (TString name)
	Initialize the fields in this object.

void	SetEventCutMode (Int_t bcuts)

virtual Bool_t	CheckForBurpFail (const VQwHardwareChannel *event)

void	SetSingleEventCuts (Double_t min, Double_t max)
	Set the upper and lower limits (fULimit and fLLimit) for this channel.

void	SetSingleEventCuts (UInt_t errorflag, Double_t min, Double_t max, Double_t stability=-1.0, Double_t BurpLevel=-1.0)
	Inherited from VQwDataElement to set the upper and lower limits (fULimit and fLLimit), stability % and the error flag on this channel.

Double_t	GetEventCutUpperLimit () const

Double_t	GetEventCutLowerLimit () const

Double_t	GetStabilityLimit () const

UInt_t	UpdateErrorFlag () override
	Update the error flag based on the error flags of internally contained objects Return parameter is the "Eventcut Error Flag".

void	UpdateErrorFlag (const VQwHardwareChannel &elem)

virtual UInt_t	GetErrorCode () const

VQwHardwareChannel &	operator= (const VQwHardwareChannel &value)
	Arithmetic assignment operator: Should only copy event-based data.

void	AssignScaledValue (const VQwHardwareChannel &value, Double_t scale)

virtual void	Ratio (const VQwHardwareChannel numer, const VQwHardwareChannel denom)

void	SetPedestal (Double_t ped)

Double_t	GetPedestal () const

void	SetCalibrationFactor (Double_t factor)

Double_t	GetCalibrationFactor () const

void	AddEntriesToList (std::vector< QwDBInterface > &row_list)

virtual void	AddErrEntriesToList (std::vector< QwErrDBInterface > &)

void	ConstructBranch (TTree *tree, TString &prefix, QwParameterFile &modulelist)

virtual void	CopyParameters (const VQwHardwareChannel *)

void	UpdateErrorFlag (const UInt_t &error)

Public Member Functions inherited from VQwDataElement
	VQwDataElement ()
	Default constructor.

	VQwDataElement (const VQwDataElement &value)
	Copy constructor.

	~VQwDataElement () override
	Virtual destructor.

void	CopyFrom (const VQwDataElement &value)

Bool_t	IsNameEmpty () const
	Is the name of this element empty?

void	SetElementName (const TString &name)
	Set the name of this element.

virtual const TString &	GetElementName () const
	Get the name of this element.

size_t	GetNumberOfDataWords ()
	Get the number of data words in this data element.

UInt_t	GetGoodEventCount () const

VQwDataElement &	operator+= (const VQwDataElement &)
	Addition-assignment operator.

VQwDataElement &	operator-= (const VQwDataElement &)
	Subtraction-assignment operator.

void	Sum (const VQwDataElement &, const VQwDataElement &)
	Sum operator (base class fallback throws runtime error)

void	Difference (const VQwDataElement &, const VQwDataElement &)
	Difference operator (base class fallback throws runtime error)

void	Ratio (const VQwDataElement &, const VQwDataElement &)
	Ratio operator (base class fallback throws runtime error)

void	SetSingleEventCuts (UInt_t, Double_t, Double_t, Double_t)
	set the upper and lower limits (fULimit and fLLimit), stability % and the error flag on this channel

Bool_t	CheckForBurpFail (const VQwDataElement *)

virtual UInt_t	GetEventcutErrorFlag ()
	return the error flag on this channel/device

virtual void	SetNeedsExternalClock (Bool_t)

virtual Bool_t	NeedsExternalClock ()

virtual std::string	GetExternalClockName ()

virtual void	SetExternalClockPtr (const VQwHardwareChannel *)

virtual void	SetExternalClockName (const std::string)

virtual Double_t	GetNormClockValue ()

TString	GetSubsystemName () const
	Return the name of the inheriting subsystem name.

void	SetSubsystemName (TString sysname)
	Set the name of the inheriting subsystem name.

TString	GetModuleType () const
	Return the type of the beam instrument.

void	SetModuleType (TString ModuleType)
	set the type of the beam instrument

Public Member Functions inherited from MQwHistograms
void	ShareHistograms (const MQwHistograms *source)
	Share histogram pointers between objects.

Public Member Functions inherited from MQwMockable
	MQwMockable ()

virtual	~MQwMockable ()

void	SetRandomEventDriftParameters (Double_t amplitude, Double_t phase, Double_t frequency)
	Set a single set of harmonic drift parameters.

void	AddRandomEventDriftParameters (Double_t amplitude, Double_t phase, Double_t frequency)
	Add drift parameters to the internal set.

void	SetRandomEventParameters (Double_t mean, Double_t sigma)
	Set the normal random event parameters.

void	SetRandomEventAsymmetry (Double_t asymmetry)
	Set the helicity asymmetry.

Double_t	GetRandomValue ()

void	UseExternalRandomVariable ()
	Set the flag to use an externally provided random variable.

void	SetExternalRandomVariable (Double_t random_variable)
	Set the externally provided random variable.

void	SetMockDataAsDiff ()

Static Public Member Functions
static Int_t	GetBufferOffset (Int_t moduleindex, Int_t channelindex)

static void	PrintErrorCounterHead ()

static void	PrintErrorCounterTail ()

static void	SetBurpHoldoff (Int_t holdoff)

Static Public Attributes
static const Double_t	kTimePerSample = (2.0/30.0) * Qw::us

Protected Member Functions
QwVQWK_Channel &	operator/= (const QwVQWK_Channel &value)

Protected Member Functions inherited from VQwHardwareChannel
void	SetNumberOfDataWords (const UInt_t &numwords)
	Set the number of data words in this data element.

void	SetNumberOfSubElements (const size_t elements)
	Set the number of data words in this data element.

void	SetDataToSave (TString datatosave)
	Set the flag indicating if raw or derived values are in this data element.

void	SetDataToSave (VQwDataElement::EDataToSave datatosave)
	Set the flag indicating if raw or derived values are in this data element.

void	SetDataToSaveByPrefix (const TString &prefix)
	Set the flag indicating if raw or derived values are in this data element based on prefix.

void	RangeCheck (size_t element) const
	Checks that the requested element is in range, to be used in accesses to subelements similar to std::vector::at().

Protected Member Functions inherited from VQwDataElement
void	SetNumberOfDataWords (const UInt_t &numwords)
	Set the number of data words in this data element.

VQwDataElement &	operator= (const VQwDataElement &value)
	Arithmetic assignment operator: Should only copy event-based data.

void	UpdateErrorFlag (const UInt_t &error)

Protected Member Functions inherited from MQwHistograms
	MQwHistograms ()
	Default constructor.

	MQwHistograms (const MQwHistograms &source)
	Copy constructor.

virtual	~MQwHistograms ()
	Virtual destructor.

MQwHistograms &	operator= (const MQwHistograms &value)

void	Fill_Pointer (TH1_ptr hist_ptr, Double_t value)

void	AddHistogram (TH1 *h)
	Register a histogram.

Private Member Functions
Double_t	GetBlockValue (size_t blocknum) const

Double_t	GetBlockErrorValue (size_t blocknum) const

Double_t	GetHardwareSum () const

Double_t	GetHardwareSumM2 () const

Double_t	GetHardwareSumWidth () const

Double_t	GetHardwareSumError () const

Int_t	GetRawBlockValue (size_t blocknum) const

Int_t	GetRawHardwareSum () const

Int_t	GetRawSoftwareSum () const

Private Attributes
Channel configuration data members
Short_t	fBlocksPerEvent

Event data members—Raw values
Int_t	fBlock_raw [4]
	Array of the sub-block data as read from the module.

Int_t	fHardwareBlockSum_raw
	Module-based sum of the four sub-blocks as read from the module.

Int_t	fSoftwareBlockSum_raw
	Sum of the data in the four sub-blocks raw.

Event data members—Potentially calibrated values
Double_t	fBlock [4]
	Array of the sub-block data.

Double_t	fHardwareBlockSum
	Module-based sum of the four sub-blocks.

Static Private Attributes
static const Bool_t	kDEBUG = kFALSE

static const Int_t	kWordsPerChannel = 6

static const Int_t	kMaxChannels = 8

ADC Calibration
static const Double_t	kVQWK_VoltsPerBit = (20./(1<<18))

Friends
std::ostream &	operator<< (std::ostream &stream, const QwVQWK_Channel &channel)

Calculation of the statistical moments
static const Bool_t	bDEBUG =kFALSE
	debugging display purposes

Double_t	fBlockM2 [4]
	Second moment of the sub-block.

Double_t	fBlockError [4]
	Uncertainty on the sub-block.

Double_t	fHardwareBlockSumM2
	Second moment of the hardware sum.

Double_t	fHardwareBlockSumError
	Uncertainty on the hardware sum.

UInt_t	fSequenceNumber
	Event sequence number for this channel.

UInt_t	fPreviousSequenceNumber
	Previous event sequence number for this channel.

UInt_t	fNumberOfSamples
	Number of samples read through the module.

UInt_t	fNumberOfSamples_map
	Number of samples in the expected to read through the module. This value is set in the QwBeamline map file.

Int_t	fErrorCount_HWSat
	check to see ADC channel is saturated

Int_t	fErrorCount_sample
	for sample size check

Int_t	fErrorCount_SW_HW
	HW_sum==SW_sum check.

Int_t	fErrorCount_Sequence
	sequence number check

Int_t	fErrorCount_SameHW
	check to see ADC returning same HW value

Int_t	fErrorCount_ZeroHW
	check to see ADC returning zero

Int_t	fNumEvtsWithEventCutsRejected
	Counts the Event cut rejected events.

Int_t	fADC_Same_NumEvt
	Keep track of how many events with same ADC value returned.

Int_t	fSequenceNo_Prev
	Keep the sequence number of the last event.

Int_t	fSequenceNo_Counter
	Internal counter to keep track of the sequence number.

Double_t	fPrev_HardwareBlockSum
	Previous Module-based sum of the four sub-blocks.

Double_t	fSaturationABSLimit
	absolute value of the VQWK saturation volt

Bool_t	bHw_sum

Bool_t	bHw_sum_raw

Bool_t	bBlock

Bool_t	bBlock_raw

Bool_t	bNum_samples

Bool_t	bDevice_Error_Code

Bool_t	bSequence_number

Additional Inherited Members
Public Types inherited from VQwDataElement
enum	EDataToSave { kRaw = 0 , kDerived , kMoments }

Protected Attributes inherited from VQwHardwareChannel
UInt_t	fNumberOfDataWords
	Number of raw data words in this data element.

UInt_t	fNumberOfSubElements
	Number of subelements in this data element.

EDataToSave	fDataToSave

size_t	fTreeArrayIndex

size_t	fTreeArrayNumEntries

Double_t	fPedestal

Double_t	fCalibrationFactor

Bool_t	kFoundPedestal

Bool_t	kFoundGain

Int_t	bEVENTCUTMODE

Double_t	fULimit

Double_t	fLLimit

Double_t	fStability

Double_t	fBurpThreshold

Int_t	fBurpCountdown

Protected Attributes inherited from VQwDataElement
TString	fElementName
	Name of this data element.

UInt_t	fNumberOfDataWords
	Number of raw data words in this data element.

UInt_t	fGoodEventCount
	Number of good events accumulated in this element.

TString	fSubsystemName

TString	fModuleType

UInt_t	fErrorFlag
	This the standard error code generated for the channel that contains the global/local/stability flags and the Device error code (Unique error code for HW failures)

UInt_t	fErrorConfigFlag
	contains the global/local/stability flags

Protected Attributes inherited from MQwHistograms
std::vector< TH1_ptr >	fHistograms
	Histograms associated with this data element.

bool	fUseExternalRandomVariable
	Flag to use an externally provided normal random variable.

double	fExternalRandomVariable
	Externally provided normal random variable.

bool	fCalcMockDataAsDiff

Double_t	fMockAsymmetry
	Helicity asymmetry.

Double_t	fMockGaussianMean
	Mean of normal distribution.

Double_t	fMockGaussianSigma
	Sigma of normal distribution.

std::vector< Double_t >	fMockDriftAmplitude
	Harmonic drift amplitude.

std::vector< Double_t >	fMockDriftFrequency
	Harmonic drift frequency.

std::vector< Double_t >	fMockDriftPhase
	Harmonic drift phase.

static Int_t	fBurpHoldoff = 10

static boost::mt19937	fRandomnessGenerator
	Internal randomness generator.

static boost::normal_distribution< double >	fNormalDistribution
	Internal normal probability distribution.

static boost::variate_generator< boost::mt19937, boost::normal_distribution< double > >	fNormalRandomVariable
	Internal normal random variable.

Detailed Description

Concrete hardware channel for VQWK ADC modules (6x32-bit words)

Decodes and processes the data for a single VQWK channel, providing access to sub-blocks and hardware sums, statistical moments, single-event cuts, and running statistics. Implements the dual-operator pattern by offering efficient type-specific operators and delegating polymorphic operators from the VQwHardwareChannel interface using dynamic_cast.

Definition at line 48 of file QwVQWK_Channel.h.

Constructor & Destructor Documentation

◆ QwVQWK_Channel() [1/4]

QwVQWK_Channel::QwVQWK_Channel ( )

inline

Definition at line 76 of file QwVQWK_Channel.h.

                  : MQwMockable() {
    InitializeChannel("","");
    SetVQWKSaturationLimt(8.5);//set the default saturation limit
  };

References InitializeChannel(), MQwMockable::MQwMockable(), and SetVQWKSaturationLimt().

Referenced by AccumulateRunningSum(), AccumulateRunningSum(), AddValueFrom(), ArcTan(), AssignScaledValue(), AssignValueFrom(), Blind(), Clone(), CopyFrom(), DeaccumulateRunningSum(), Difference(), DivideBy(), DivideBy(), MultiplyBy(), operator*(), operator*=(), operator*=(), operator+(), operator+=(), operator+=(), operator-(), operator-=(), operator-=(), operator/=(), operator/=(), operator<<, operator=(), Product(), QwVQWK_Channel(), QwVQWK_Channel(), Ratio(), ScaledAdd(), SubtractValueFrom(), and Sum().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QwVQWK_Channel() [2/4]

QwVQWK_Channel::QwVQWK_Channel	(	TString	name,
		TString	datatosave = "raw" )

inline

Definition at line 80 of file QwVQWK_Channel.h.

                                                          : MQwMockable() {
    InitializeChannel(name, datatosave);
    SetVQWKSaturationLimt(8.5);//set the default saturation limit
  };

References InitializeChannel(), MQwMockable::MQwMockable(), and SetVQWKSaturationLimt().

Here is the call graph for this function:

◆ QwVQWK_Channel() [3/4]

QwVQWK_Channel::QwVQWK_Channel ( const QwVQWK_Channel & value )

inline

Definition at line 84 of file QwVQWK_Channel.h.

                                             : 
    VQwHardwareChannel(value), MQwMockable(value),
    fBlocksPerEvent(value.fBlocksPerEvent),
    fNumberOfSamples_map(value.fNumberOfSamples_map),
    fSaturationABSLimit(value.fSaturationABSLimit)
  {
    *this = value;
  };

References fBlocksPerEvent, fNumberOfSamples_map, fSaturationABSLimit, MQwMockable::MQwMockable(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ QwVQWK_Channel() [4/4]

QwVQWK_Channel::QwVQWK_Channel	(	const QwVQWK_Channel &	value,
		VQwDataElement::EDataToSave	datatosave )

inline

Definition at line 92 of file QwVQWK_Channel.h.

                                                                                   :
    VQwHardwareChannel(value,datatosave), MQwMockable(value),
    fBlocksPerEvent(value.fBlocksPerEvent),
    fNumberOfSamples_map(value.fNumberOfSamples_map),
    fSaturationABSLimit(value.fSaturationABSLimit)
  {
    *this = value;
  };

References fBlocksPerEvent, fNumberOfSamples_map, fSaturationABSLimit, MQwMockable::MQwMockable(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ ~QwVQWK_Channel()

QwVQWK_Channel::~QwVQWK_Channel ( )

inlineoverride

Definition at line 100 of file QwVQWK_Channel.h.

100{ };

Member Function Documentation

◆ AccumulateRunningSum() [1/2]

void QwVQWK_Channel::AccumulateRunningSum	(	const QwVQWK_Channel &	value,
		Int_t	count = 0,
		Int_t	ErrorMask = 0xFFFFFFF )

Accumulate event values into the running sum with optional scaling.

Parameters

value	Source channel to accumulate from.
count	Event count scaling (0 means use value.fGoodEventCount).
ErrorMask	Bit mask of error flags to exclude when accumulating.

Moments and uncertainty calculation on the running sums and averages The calculation of the first and second moments of the running sum is not completely straightforward due to numerical instabilities associated with small variances and large average values. The naive computation taking the difference of the square of the average and the average of the squares leads to the subtraction of two very large numbers to get a small number.

Alternative algorithms (including for higher order moments) are supplied in Pebay, Philippe (2008), "Formulas for Robust, One-Pass Parallel Computation of Covariances and Arbitrary-Order Statistical Moments", Technical Report SAND2008-6212, Sandia National Laboratories. http://infoserve.sandia.gov/sand_doc/2008/086212.pdf

In the following formulas the moments \( M^1 \) and \( M^2 \) are defined

\begin{eqnarray} M^1 & = & \frac{1}{n} \sum^n y \\ M^2 & = & \sum^n (y - \mu) \end{eqnarray}

Recurrence relations for the addition of a single event:

\begin{eqnarray} M^1_n & = & M^1_{n-1} + \frac{y - M^1_{n-1}}{n} \\ M^2_n & = & M^2_{n-1} + (y - M^1_{n-1})(y - M^1_n) \end{eqnarray}

For the addition of an already accumulated sum:

\begin{eqnarray} M^1 & = & M^1_1 + n_2 \frac{M^1_2 - M^1_1}{n} \\ M^2 & = & M^2_1 + M^2_2 + n_1 n_2 \frac{(M^1_2 - M^1_1)^2}{n} \end{eqnarray}

In these recursive formulas we start from \( M^1 = y \) and \( M^2 = 0 \).

To calculate the mean and standard deviation we use

\begin{eqnarray} \mu & = & M^1 \\ \sigma^2 & = & \frac{1}{n} M^2 \end{eqnarray}

The standard deviation is a biased estimator, but this is what ROOT uses. Better would be to divide by \( (n-1) \).

We use the formulas provided there for the calculation of the first and second moments (i.e. average and variance).

Definition at line 1569 of file QwVQWK_Channel.cc.

{
  /*
    note:
    The AccumulateRunningSum is called on a dedicated subsystem array object and
    for the standard running avg computations we only need value.fErrorFlag==0
    events to be included in the running avg. So the "berror" conditions is only
    used for the stability check purposes.
 
    The need for this check below came due to fact that when routine
    DeaccumulateRunningSum is called the errorflag is updated with
    the kBeamStabilityError flag (+ configuration flags for global errors) and
    need to make sure we remove this flag and any configuration flags before
    checking the (fErrorFlag != 0) condition
    
    See how the stability check is implemented in the QwEventRing class
 
    Rakitha
  */
 
  if(count==0){
    count = value.fGoodEventCount;
  }
 
  Int_t n1 = fGoodEventCount;
  Int_t n2 = count;
 
  // If there are no good events, check the error flag
  if (n2 == 0 && (value.fErrorFlag == 0)) {
    n2 = 1;
  }
 
  // If a single event is removed from the sum, check all but stability fail flags
  if (n2 == -1) {
    if ((value.fErrorFlag & ErrorMask) == 0) {
      n2 = -1;
    } else {
      n2 = 0;
    }
  }
 
  if (ErrorMask ==  kPreserveError){
    //n = 1;
    if (n2 == 0) {
      n2 = 1;
    }
    if (count == -1) {
      n2 = -1;
    }
  }
 
  // New total number of good events
  Int_t n = n1 + n2;
 
  // Set up variables
  Double_t M11 = fHardwareBlockSum;
  Double_t M12 = value.fHardwareBlockSum;
  Double_t M22 = value.fHardwareBlockSumM2;
 
  //if(this->GetElementName() == "bcm_an_ds3" && ErrorMask == kPreserveError){QwError << "count=" << fGoodEventCount << "  n=" << n << QwLog::endl;    }
  if (n2 == 0) {
    // no good events for addition
    return;
  } else if (n2 == -1) {
    // simple version for removal of single event from the sum
    fGoodEventCount--;
    if (n > 1) {
      fHardwareBlockSum -= (M12 - M11) / n;
      fHardwareBlockSumM2 -= (M12 - M11)
        * (M12 - fHardwareBlockSum); // note: using updated mean
      // and for individual blocks
      for (Int_t i = 0; i < 4; i++) {
        M11 = fBlock[i];
        M12 = value.fBlock[i];
        M22 = value.fBlockM2[i];
        fBlock[i] -= (M12 - M11) / n;
        fBlockM2[i] -= (M12 - M11) * (M12 - fBlock[i]); // note: using updated mean
      }
    } else if (n == 1) {
      fHardwareBlockSum -= (M12 - M11) / n;
      fHardwareBlockSumM2 -= (M12 - M11)
        * (M12 - fHardwareBlockSum); // note: using updated mean
      if (fabs(fHardwareBlockSumM2) < 10.*std::numeric_limits<double>::epsilon())
        fHardwareBlockSumM2 = 0; // rounding
      // and for individual blocks
      for (Int_t i = 0; i < 4; i++) {
        M11 = fBlock[i];
        M12 = value.fBlock[i];
        M22 = value.fBlockM2[i];
        fBlock[i] -= (M12 - M11) / n;
        fBlockM2[i] -= (M12 - M11) * (M12 - fBlock[i]); // note: using updated mean
        if (fabs(fBlockM2[i]) < 10.*std::numeric_limits<double>::epsilon())
          fBlockM2[i] = 0; // rounding
      }
    } else if (n == 0) {
      fHardwareBlockSum -= M12;
      fHardwareBlockSumM2 -= M22;
      if (fabs(fHardwareBlockSum) < 10.*std::numeric_limits<double>::epsilon())
        fHardwareBlockSum = 0; // rounding
      if (fabs(fHardwareBlockSumM2) < 10.*std::numeric_limits<double>::epsilon())
        fHardwareBlockSumM2 = 0; // rounding
      // and for individual blocks
      for (Int_t i = 0; i < 4; i++) {
        M11 = fBlock[i];
        M12 = value.fBlock[i];
        M22 = value.fBlockM2[i];
        fBlock[i] -= M12;
        fBlockM2[i] -= M22;
        if (fabs(fBlock[i]) < 10.*std::numeric_limits<double>::epsilon())
          fBlock[i] = 0; // rounding
        if (fabs(fBlockM2[i]) < 10.*std::numeric_limits<double>::epsilon())
          fBlockM2[i] = 0; // rounding
      }
    } else {
      QwWarning << "Running sum has deaccumulated to negative good events." << QwLog::endl;
    }
  } else if (n2 == 1) {
    // simple version for addition of single event
    fGoodEventCount++;
    fHardwareBlockSum += (M12 - M11) / n;
    fHardwareBlockSumM2 += (M12 - M11)
         * (M12 - fHardwareBlockSum); // note: using updated mean
    // and for individual blocks
    for (Int_t i = 0; i < 4; i++) {
      M11 = fBlock[i];
      M12 = value.fBlock[i];
      M22 = value.fBlockM2[i];
      fBlock[i] += (M12 - M11) / n;
      fBlockM2[i] += (M12 - M11) * (M12 - fBlock[i]); // note: using updated mean
    }
  } else if (n2 > 1) {
    // general version for addition of multi-event sets
    fGoodEventCount += n2;
    fHardwareBlockSum += n2 * (M12 - M11) / n;
    fHardwareBlockSumM2 += M22 + n1 * n2 * (M12 - M11) * (M12 - M11) / n;
    // and for individual blocks
    for (Int_t i = 0; i < 4; i++) {
      M11 = fBlock[i];
      M12 = value.fBlock[i];
      M22 = value.fBlockM2[i];
      fBlock[i] += n2 * (M12 - M11) / n;
      fBlockM2[i] += M22 + n1 * n2 * (M12 - M11) * (M12 - M11) / n;
    }
  }
 
  // Nanny
  if (fHardwareBlockSum != fHardwareBlockSum)
    QwWarning << "Angry Nanny: NaN detected in " << GetElementName() << QwLog::endl;
}

References QwLog::endl(), fBlock, fBlockM2, VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fHardwareBlockSum, fHardwareBlockSumM2, VQwDataElement::GetElementName(), kPreserveError, QwVQWK_Channel(), and QwWarning.

Referenced by AccumulateRunningSum(), and DeaccumulateRunningSum().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AccumulateRunningSum() [2/2]

void QwVQWK_Channel::AccumulateRunningSum	(	const VQwHardwareChannel *	value,
		Int_t	count = 0,
		Int_t	ErrorMask = 0xFFFFFFF )

inlineoverridevirtual

Reimplemented from VQwHardwareChannel.

Definition at line 194 of file QwVQWK_Channel.h.

                                                                                                               {
    const QwVQWK_Channel *tmp_ptr = dynamic_cast<const QwVQWK_Channel*>(value);
    if (tmp_ptr != NULL) {
      AccumulateRunningSum(*tmp_ptr, count, ErrorMask);
    } else {
      throw std::invalid_argument("Standard exception from QwVQWK_Channel::AccumulateRunningSum: incompatible hardware channel type");
    }
  };

References AccumulateRunningSum(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ AddChannelOffset()

void QwVQWK_Channel::AddChannelOffset ( Double_t offset )

This function will add a offset to the hw_sum and add the same offset for blocks.

Definition at line 1490 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()){
    fHardwareBlockSum += offset;
    for (Int_t i=0; i<fBlocksPerEvent; i++) 
      fBlock[i] += offset;
  }
  return;
}

References fBlock, fBlocksPerEvent, fHardwareBlockSum, and VQwDataElement::IsNameEmpty().

Here is the call graph for this function:

◆ AddValueFrom()

void QwVQWK_Channel::AddValueFrom ( const VQwHardwareChannel * valueptr )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1184 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(valueptr);
  if (tmpptr!=NULL){
    *this += *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::AddValueFrom = "
      +valueptr->GetElementName()+" is an incompatible type.";
    throw std::invalid_argument(loc.Data());
  }
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ ApplyHWChecks()

Int_t QwVQWK_Channel::ApplyHWChecks ( )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 64 of file QwVQWK_Channel.cc.

{
  Bool_t fEventIsGood=kTRUE;
  Bool_t bStatus;
  if (bEVENTCUTMODE>0){//Global switch to ON/OFF event cuts set at the event cut file
 
    if (bDEBUG)
      QwWarning<<" QwQWVK_Channel "<<GetElementName()<<"  "<<GetNumberOfSamples()<<QwLog::endl;
 
    // Sample size check
    bStatus = MatchNumberOfSamples(fNumberOfSamples_map);//compare the default sample size with no.of samples read by the module
    if (!bStatus) {
      fErrorFlag |= kErrorFlag_sample;
    }
 
    // Check SW and HW return the same sum
    bStatus = (GetRawHardwareSum() == GetRawSoftwareSum());
    //fEventIsGood = bStatus;
    if (!bStatus) {
      fErrorFlag |= kErrorFlag_SW_HW;
    }
 
 
 
    //check sequence number
    fSequenceNo_Prev++;
    if (fSequenceNo_Counter==0 || GetSequenceNumber()==0){//starting the data run
      fSequenceNo_Prev=GetSequenceNumber();
    }
 
    if (!MatchSequenceNumber(fSequenceNo_Prev)){//we have a sequence number error
      fEventIsGood=kFALSE;
      fErrorFlag|=kErrorFlag_Sequence;
      if (bDEBUG)       QwWarning<<" QwQWVK_Channel "<<GetElementName()<<" Sequence number previous value = "<<fSequenceNo_Prev<<" Current value= "<< GetSequenceNumber()<<QwLog::endl;
    }
 
    fSequenceNo_Counter++;
 
    //Checking for HW_sum is returning same value.
    if (fPrev_HardwareBlockSum != GetRawHardwareSum()){
      //std::cout<<" BCM hardware sum is different  "<<std::endl;
      fPrev_HardwareBlockSum = GetRawHardwareSum();
      fADC_Same_NumEvt=0;
    }else
      fADC_Same_NumEvt++;//hw_sum is same increment the counter
 
    //check for the hw_sum is giving the same value
    if (fADC_Same_NumEvt>0){//we have ADC stuck with same value
      if (bDEBUG) QwWarning<<" BCM hardware sum is same for more than  "<<fADC_Same_NumEvt<<" time consecutively  "<<QwLog::endl;
      fErrorFlag|=kErrorFlag_SameHW;
    }
 
    //check for the hw_sum is zero
    if (GetRawHardwareSum()==0){
      fErrorFlag|=kErrorFlag_ZeroHW;
    }
    if (!fEventIsGood)    
      fSequenceNo_Counter=0;//resetting the counter after ApplyHWChecks() a failure
 
    if ((TMath::Abs(GetRawHardwareSum())*kVQWK_VoltsPerBit/fNumberOfSamples) > GetVQWKSaturationLimt()){
      if (bDEBUG) 
        QwWarning << this->GetElementName()<<" "<<GetRawHardwareSum() << "Saturating VQWK invoked! " <<TMath::Abs(GetRawHardwareSum())*kVQWK_VoltsPerBit/fNumberOfSamples<<" Limit "<<GetVQWKSaturationLimt() << QwLog::endl;
      fErrorFlag|=kErrorFlag_VQWK_Sat; 
    }
 
  }
  else {
    fGoodEventCount = 1;
    fErrorFlag = 0;
  }
 
  return fErrorFlag;
}

References bDEBUG, VQwHardwareChannel::bEVENTCUTMODE, QwLog::endl(), fADC_Same_NumEvt, VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fNumberOfSamples, fNumberOfSamples_map, fPrev_HardwareBlockSum, fSequenceNo_Counter, fSequenceNo_Prev, VQwDataElement::GetElementName(), GetNumberOfSamples(), GetRawHardwareSum(), GetRawSoftwareSum(), GetSequenceNumber(), GetVQWKSaturationLimt(), kErrorFlag_SameHW, kErrorFlag_sample, kErrorFlag_Sequence, kErrorFlag_SW_HW, kErrorFlag_VQWK_Sat, kErrorFlag_ZeroHW, kVQWK_VoltsPerBit, MatchNumberOfSamples(), MatchSequenceNumber(), and QwWarning.

Here is the call graph for this function:

◆ ApplySingleEventCuts() [1/2]

Bool_t QwVQWK_Channel::ApplySingleEventCuts ( )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1875 of file QwVQWK_Channel.cc.

{
  Bool_t status;
 
  if (bEVENTCUTMODE>=2){//Global switch to ON/OFF event cuts set at the event cut file
 
    if (fULimit < fLLimit){
      status=kTRUE;
    } else  if (GetHardwareSum()<=fULimit && GetHardwareSum()>=fLLimit){
      if ((fErrorFlag)==0)
        status=kTRUE;
      else
        status=kFALSE;//If the device HW is failed
    }
    else{
      if (GetHardwareSum()> fULimit)
        fErrorFlag|=kErrorFlag_EventCut_U;
      else
        fErrorFlag|=kErrorFlag_EventCut_L;
      status=kFALSE;
    }
 
    if (bEVENTCUTMODE==3){
      status=kTRUE; //Update the event cut fail flag but pass the event.
    }
 
 
  }
  else{
    status=kTRUE;
    //fErrorFlag=0;//we need to keep the device error codes 
  }
 
  return status;
}

References VQwHardwareChannel::bEVENTCUTMODE, VQwDataElement::fErrorFlag, VQwHardwareChannel::fLLimit, VQwHardwareChannel::fULimit, GetHardwareSum(), kErrorFlag_EventCut_L, and kErrorFlag_EventCut_U.

Here is the call graph for this function:

◆ ApplySingleEventCuts() [2/2]

Bool_t QwVQWK_Channel::ApplySingleEventCuts	(	Double_t	LL,
		Double_t	UL )

Definition at line 1859 of file QwVQWK_Channel.cc.

{
  Bool_t status = kFALSE;
 
  if (UL < LL){
    status=kTRUE;
  } else  if (GetHardwareSum()<=UL && GetHardwareSum()>=LL){
    if ((fErrorFlag & kPreserveError)!=0)
      status=kTRUE;
    else
      status=kFALSE;//If the device HW is failed
  }
  std::cout<<(this->fErrorFlag & kPreserveError)<<std::endl;
  return status;
}

References VQwDataElement::fErrorFlag, GetHardwareSum(), and kPreserveError.

Here is the call graph for this function:

◆ ArcTan()

void QwVQWK_Channel::ArcTan ( const QwVQWK_Channel & value )

Definition at line 1452 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()) {
    this->fHardwareBlockSum = 0.0;
    for (Int_t i=0; i<fBlocksPerEvent; i++) {
      this->fBlock[i] = atan(value.fBlock[i]);
      this->fHardwareBlockSum += this->fBlock[i];
    }
    this->fHardwareBlockSum /= fBlocksPerEvent;
  }
 
  return;
}

References fBlock, fBlocksPerEvent, fHardwareBlockSum, VQwDataElement::IsNameEmpty(), and QwVQWK_Channel().

Here is the call graph for this function:

◆ AssignScaledValue()

void QwVQWK_Channel::AssignScaledValue	(	const QwVQWK_Channel &	value,
		Double_t	scale )

Definition at line 1152 of file QwVQWK_Channel.cc.

{
  if(this == &value) return;
 
  if (!IsNameEmpty()) {
    for (Int_t i=0; i<fBlocksPerEvent; i++){
      this->fBlock[i]   = value.fBlock[i]   * scale;
      this->fBlockM2[i] = value.fBlockM2[i] * scale * scale;
    }
    this->fHardwareBlockSum   = value.fHardwareBlockSum * scale;
    this->fHardwareBlockSumM2 = value.fHardwareBlockSumM2 * scale * scale;
    this->fHardwareBlockSumError = value.fHardwareBlockSumError;   // Keep this?
    this->fGoodEventCount  = value.fGoodEventCount;
    this->fNumberOfSamples = value.fNumberOfSamples;
    this->fSequenceNumber  = value.fSequenceNumber;
    this->fErrorFlag       = value.fErrorFlag;
  }
}

References fBlock, fBlockM2, fBlocksPerEvent, VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fHardwareBlockSum, fHardwareBlockSumError, fHardwareBlockSumM2, fNumberOfSamples, fSequenceNumber, VQwDataElement::IsNameEmpty(), and QwVQWK_Channel().

Here is the call graph for this function:

◆ AssignValueFrom()

void QwVQWK_Channel::AssignValueFrom ( const VQwDataElement * valueptr )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1172 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(valueptr);
  if (tmpptr!=NULL){
    *this = *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::AssignValueFrom = "
      +valueptr->GetElementName()+" is an incompatible type.";
    throw std::invalid_argument(loc.Data());
  }
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwDataElement::VQwDataElement().

Here is the call graph for this function:

◆ Blind() [1/2]

void QwVQWK_Channel::Blind ( const QwBlinder * blinder )

Blind this channel as an asymmetry.

Blind this channel as an asymmetry

Parameters

blinder Blinder

Definition at line 1792 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()) {
    if (blinder->IsBlinderOkay() && ((fErrorFlag)==0) ){
      for (Int_t i = 0; i < fBlocksPerEvent; i++)
        blinder->BlindValue(fBlock[i]);
      blinder->BlindValue(fHardwareBlockSum);
    } else {
      blinder->ModifyThisErrorCode(fErrorFlag);
      for (Int_t i = 0; i < fBlocksPerEvent; i++)
    fBlock[i] = QwBlinder::kValue_BlinderFail;
      fHardwareBlockSum =  QwBlinder::kValue_BlinderFail;
    }
  }
  return;
}

References QwBlinder::BlindValue(), fBlock, fBlocksPerEvent, VQwDataElement::fErrorFlag, fHardwareBlockSum, QwBlinder::IsBlinderOkay(), VQwDataElement::IsNameEmpty(), QwBlinder::kValue_BlinderFail, and QwBlinder::ModifyThisErrorCode().

Here is the call graph for this function:

◆ Blind() [2/2]

void QwVQWK_Channel::Blind	(	const QwBlinder *	blinder,
		const QwVQWK_Channel &	yield )

Blind this channel as a difference.

Blind this channel as a difference with specified yield

Parameters

blinder	Blinder
yield	Corresponding yield

Definition at line 1814 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()) {
    if (blinder->IsBlinderOkay() && ((fErrorFlag) ==0) ){
      for (Int_t i = 0; i < fBlocksPerEvent; i++)
        blinder->BlindValue(fBlock[i], yield.fBlock[i]);
      blinder->BlindValue(fHardwareBlockSum, yield.fHardwareBlockSum);
    } else {
      blinder->ModifyThisErrorCode(fErrorFlag);//update the HW error code
      for (Int_t i = 0; i < fBlocksPerEvent; i++)
    fBlock[i] = QwBlinder::kValue_BlinderFail * yield.fBlock[i];
      fHardwareBlockSum = QwBlinder::kValue_BlinderFail * yield.fHardwareBlockSum;
    }
  }
  return;
}

References QwBlinder::BlindValue(), fBlock, fBlocksPerEvent, VQwDataElement::fErrorFlag, fHardwareBlockSum, QwBlinder::IsBlinderOkay(), VQwDataElement::IsNameEmpty(), QwBlinder::kValue_BlinderFail, QwBlinder::ModifyThisErrorCode(), and QwVQWK_Channel().

Here is the call graph for this function:

◆ CalculateRunningAverage()

void QwVQWK_Channel::CalculateRunningAverage ( )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1720 of file QwVQWK_Channel.cc.

{
  if (fGoodEventCount <= 0)
    {
      for (Int_t i = 0; i < fBlocksPerEvent; i++) {
        fBlockError[i] = 0.0;
      }
      fHardwareBlockSumError = 0.0;
    }
  else
    {
      // We use a biased estimator by dividing by n.  Use (n - 1) to get the
      // unbiased estimator for the standard deviation.
      //
      // Note we want to calculate the error here, not sigma:
      //    sigma = sqrt(M2 / n);
      //    error = sigma / sqrt (n) = sqrt(M2) / n;
      for (Int_t i = 0; i < fBlocksPerEvent; i++)
        fBlockError[i] = sqrt(fBlockM2[i]) / fGoodEventCount;
      fHardwareBlockSumError = sqrt(fHardwareBlockSumM2) / fGoodEventCount;
 
      // Stability check 83951872
      if ((fStability>0) &&( (fErrorConfigFlag & kStabilityCut) == kStabilityCut)) {
        // check to see the channel has stability cut activated in the event cut file
    if (GetValueWidth() > fStability){
      // if the width is greater than the stability required flag the event
      fErrorFlag = kBeamStabilityError;
    } else
      fErrorFlag = 0;
      }
    }
}

References fBlockError, fBlockM2, fBlocksPerEvent, VQwDataElement::fErrorConfigFlag, VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fHardwareBlockSumError, fHardwareBlockSumM2, VQwHardwareChannel::fStability, GetValueWidth(), kBeamStabilityError, and kStabilityCut.

Here is the call graph for this function:

◆ ClearEventData()

void QwVQWK_Channel::ClearEventData ( )

overridevirtual

Clear the event data in this element.

Reimplemented from VQwDataElement.

Definition at line 249 of file QwVQWK_Channel.cc.

{
  for (Int_t i = 0; i < fBlocksPerEvent; i++) {
    fBlock_raw[i] = 0;
    fBlock[i] = 0.0;
    fBlockM2[i] = 0.0;
    fBlockError[i] = 0.0;
  }
  fHardwareBlockSum_raw = 0;
  fSoftwareBlockSum_raw = 0;
  fHardwareBlockSum   = 0.0;
  fHardwareBlockSumM2 = 0.0;
  fHardwareBlockSumError = 0.0;
  fSequenceNumber   = 0;
  fNumberOfSamples  = 0;
  fGoodEventCount   = 0;
  fErrorFlag=0;
  return;
}

References fBlock, fBlock_raw, fBlockError, fBlockM2, fBlocksPerEvent, VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fHardwareBlockSum, fHardwareBlockSum_raw, fHardwareBlockSumError, fHardwareBlockSumM2, fNumberOfSamples, fSequenceNumber, and fSoftwareBlockSum_raw.

Referenced by InitializeChannel(), QwLinearDiodeArray::ProcessEvent(), and QwQPD::ProcessEvent().

Here is the caller graph for this function:

◆ Clone() [1/2]

virtual VQwHardwareChannel * VQwHardwareChannel::Clone ( ) const

inlinevirtual

Reimplemented from VQwHardwareChannel.

Definition at line 112 of file VQwHardwareChannel.h.

                                           {
    return Clone(this->fDataToSave);
  };

◆ Clone() [2/2]

VQwHardwareChannel * QwVQWK_Channel::Clone ( VQwDataElement::EDataToSave datatosave ) const

inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 112 of file QwVQWK_Channel.h.

                                                                                {
    return new QwVQWK_Channel(*this,datatosave);
  };

References QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ ConstructBranch()

void QwVQWK_Channel::ConstructBranch	(	TTree *	tree,
		TString &	prefix )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 826 of file QwVQWK_Channel.cc.

{
  //  This channel is not used, so skip setting up the tree.
  if (IsNameEmpty()) return;
 
  TString basename = prefix + GetElementName();
  tree->Branch(basename,&fHardwareBlockSum,basename+"/D");
  if (kDEBUG){
    std::cerr << "QwVQWK_Channel::ConstructBranchAndVector: fTreeArrayIndex==" << fTreeArrayIndex
              << "; fTreeArrayNumEntries==" << fTreeArrayNumEntries
              << std::endl;
  }
}

References fHardwareBlockSum, VQwHardwareChannel::fTreeArrayIndex, VQwHardwareChannel::fTreeArrayNumEntries, VQwDataElement::GetElementName(), VQwDataElement::IsNameEmpty(), and kDEBUG.

Here is the call graph for this function:

◆ ConstructBranchAndVector()

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

overridevirtual

Implements VQwHardwareChannel.

Definition at line 742 of file QwVQWK_Channel.cc.

{
  //  This channel is not used, so skip setting up the tree.
  if (IsNameEmpty()) return;
 
  //  Decide what to store based on prefix
  SetDataToSaveByPrefix(prefix);
 
  TString basename = prefix(0, (prefix.First("|") >= 0)? prefix.First("|"): prefix.Length()) + GetElementName();
  fTreeArrayIndex  = values.size();
 
  bHw_sum =     gQwHists.MatchVQWKElementFromList(GetSubsystemName().Data(), GetModuleType().Data(), "hw_sum");
  bHw_sum_raw = gQwHists.MatchVQWKElementFromList(GetSubsystemName().Data(), GetModuleType().Data(), "hw_sum_raw");
  bBlock =     gQwHists.MatchVQWKElementFromList(GetSubsystemName().Data(), GetModuleType().Data(), "block");
  bBlock_raw = gQwHists.MatchVQWKElementFromList(GetSubsystemName().Data(), GetModuleType().Data(), "block_raw");
  bNum_samples = gQwHists.MatchVQWKElementFromList(GetSubsystemName().Data(), GetModuleType().Data(), "num_samples");
  bDevice_Error_Code = gQwHists.MatchVQWKElementFromList(GetSubsystemName().Data(), GetModuleType().Data(), "Device_Error_Code");
  bSequence_number = gQwHists.MatchVQWKElementFromList(GetSubsystemName().Data(), GetModuleType().Data(), "sequence_number");
 
  if (bHw_sum) {
    values.push_back("hw_sum", 'I');
    if (fDataToSave == kMoments) {
      values.push_back("hw_sum_m2", 'D');
      values.push_back("hw_sum_err", 'D');
    }
  }
 
  if (bBlock) {
    values.push_back("block0", 'D');
    values.push_back("block1", 'D');
    values.push_back("block2", 'D');
    values.push_back("block3", 'D');
  }
 
  if (bNum_samples) {
    values.push_back("num_samples", 'I');
  }
 
  if (bDevice_Error_Code) {
    values.push_back("Device_Error_Code", 'i');
  }
 
  if (fDataToSave == kRaw) {
    if (bHw_sum_raw) {
      values.push_back("hw_sum_raw", 'I');
    }
    if (bBlock_raw) {
      values.push_back("block0_raw", 'I');
      values.push_back("block1_raw", 'I');
      values.push_back("block2_raw", 'I');
      values.push_back("block3_raw", 'I');
    }
    if (bSequence_number) {
      values.push_back("sequence_number", 'i');
    }
  }
 
  fTreeArrayNumEntries = values.size() - fTreeArrayIndex;
 
  std::string leaf_list = values.LeafList();
 
  if (gQwHists.MatchDeviceParamsFromList(basename.Data())
    && (bHw_sum || bBlock || bNum_samples || bDevice_Error_Code ||
        bHw_sum_raw || bBlock_raw || bSequence_number)) {
 
    // This is for the RT mode
    if (leaf_list == "hw_sum/D")
      leaf_list = basename+"/D";
 
    if (kDEBUG)
      QwMessage << "base name " << basename << " List " << leaf_list << QwLog::endl;
 
    tree->Branch(basename, &(values[fTreeArrayIndex]), leaf_list.c_str());
  }
 
  if (kDEBUG) {
    std::cerr << "QwVQWK_Channel::ConstructBranchAndVector: fTreeArrayIndex==" << fTreeArrayIndex
              << "; fTreeArrayNumEntries==" << fTreeArrayNumEntries
              << "; values.size()==" << values.size()
              << "; list==" << leaf_list
              << std::endl;
  }
}

References bBlock, bBlock_raw, bDevice_Error_Code, bHw_sum, bHw_sum_raw, bNum_samples, bSequence_number, QwLog::endl(), VQwHardwareChannel::fDataToSave, VQwHardwareChannel::fTreeArrayIndex, VQwHardwareChannel::fTreeArrayNumEntries, VQwDataElement::GetElementName(), VQwDataElement::GetModuleType(), VQwDataElement::GetSubsystemName(), gQwHists, VQwDataElement::IsNameEmpty(), kDEBUG, VQwDataElement::kMoments, VQwDataElement::kRaw, QwRootTreeBranchVector::LeafList(), QwRootTreeBranchVector::push_back(), QwMessage, VQwHardwareChannel::SetDataToSaveByPrefix(), and QwRootTreeBranchVector::size().

Here is the call graph for this function:

◆ ConstructHistograms()

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

overridevirtual

Construct the histograms for this data element.

Implements VQwDataElement.

Definition at line 636 of file QwVQWK_Channel.cc.

{
  //  If we have defined a subdirectory in the ROOT file, then change into it.
  if (folder != NULL) folder->cd();
 
  if (IsNameEmpty()){
    //  This channel is not used, so skip filling the histograms.
  } else {
    //  Now create the histograms.
    SetDataToSaveByPrefix(prefix);
 
    TString basename = prefix + GetElementName();
 
    if(fDataToSave==kRaw)
      {
        fHistograms.resize(8+2+1, NULL);
        size_t index=0;
        for (Int_t i=0; i<fBlocksPerEvent; i++){
          fHistograms[index]   = gQwHists.Construct1DHist(basename+Form("_block%d_raw",i));
          fHistograms[index+1] = gQwHists.Construct1DHist(basename+Form("_block%d",i));
          index += 2;
        }
        fHistograms[index]   = gQwHists.Construct1DHist(basename+Form("_hw_raw"));
        fHistograms[index+1] = gQwHists.Construct1DHist(basename+Form("_hw"));
        index += 2;
        fHistograms[index]   = gQwHists.Construct1DHist(basename+Form("_sw-hw_raw"));
      }
    else if(fDataToSave==kDerived)
      {
        fHistograms.resize(4+1+1, NULL);
        Int_t index=0;
        for (Int_t i=0; i<fBlocksPerEvent; i++){
          fHistograms[index] = gQwHists.Construct1DHist(basename+Form("_block%d",i));
          index += 1;
        }
        fHistograms[index] = gQwHists.Construct1DHist(basename+Form("_hw"));
        index += 1;
        fHistograms[index] = gQwHists.Construct1DHist(basename+Form("_dev_err"));
        index += 1;
      }
    else
      {
        // this is not recognized
      }
 
  }
}

References fBlocksPerEvent, VQwHardwareChannel::fDataToSave, MQwHistograms::fHistograms, VQwDataElement::GetElementName(), gQwHists, VQwDataElement::IsNameEmpty(), VQwDataElement::kDerived, VQwDataElement::kRaw, and VQwHardwareChannel::SetDataToSaveByPrefix().

Here is the call graph for this function:

◆ CopyFrom()

void QwVQWK_Channel::CopyFrom ( const QwVQWK_Channel & value )

inline

Definition at line 102 of file QwVQWK_Channel.h.

                                            {
    VQwHardwareChannel::CopyFrom(value);
    fBlocksPerEvent = value.fBlocksPerEvent;
    fNumberOfSamples_map = value.fNumberOfSamples_map; 
    fSaturationABSLimit = value.fSaturationABSLimit;
    *this = value;
  };

References VQwHardwareChannel::CopyFrom(), fBlocksPerEvent, fNumberOfSamples_map, fSaturationABSLimit, and QwVQWK_Channel().

Here is the call graph for this function:

◆ DeaccumulateRunningSum() [1/2]

void QwVQWK_Channel::DeaccumulateRunningSum	(	const QwVQWK_Channel &	value,
		Int_t	ErrorMask = 0xFFFFFFF )

inline

Definition at line 203 of file QwVQWK_Channel.h.

                                                                                            {
    AccumulateRunningSum(value, -1, ErrorMask);
  };

References AccumulateRunningSum(), and QwVQWK_Channel().

Here is the call graph for this function:

◆ DeaccumulateRunningSum() [2/2]

virtual void VQwHardwareChannel::DeaccumulateRunningSum	(	const VQwHardwareChannel *	value,
		Int_t	ErrorMask = 0xFFFFFFF )

inlinevirtual

Reimplemented from VQwHardwareChannel.

Definition at line 255 of file VQwHardwareChannel.h.

                                                                                                 {
    AccumulateRunningSum(value, -1, ErrorMask);
  };

◆ Difference()

void QwVQWK_Channel::Difference	(	const QwVQWK_Channel &	value1,
		const QwVQWK_Channel &	value2 )

Definition at line 1372 of file QwVQWK_Channel.cc.

{
  *this  = value1;
  *this -= value2;
}

References QwVQWK_Channel().

Referenced by QwQPD::ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DivideBy() [1/2]

void QwVQWK_Channel::DivideBy ( const QwVQWK_Channel & denom )

Definition at line 1513 of file QwVQWK_Channel.cc.

{
  *this /= denom;
}

References QwVQWK_Channel().

Here is the call graph for this function:

◆ DivideBy() [2/2]

void QwVQWK_Channel::DivideBy ( const VQwHardwareChannel * valueptr )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1220 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(valueptr);
  if (tmpptr!=NULL){
    *this /= *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::DivideBy = "
      +valueptr->GetElementName()+" is an incompatible type.";
    throw std::invalid_argument(loc.Data());
  }
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ EncodeEventData()

void QwVQWK_Channel::EncodeEventData ( std::vector< UInt_t > & buffer )

overridevirtual

Encode the event data into a CODA buffer.

Implements MQwMockable.

Definition at line 442 of file QwVQWK_Channel.cc.

{
  Long_t localbuf[6] = {0};
 
  if (IsNameEmpty()) {
    //  This channel is not used, but is present in the data stream.
    //  Skip over this data.
  } else {
    //    localbuf[4] = 0;
    for (Int_t i = 0; i < 4; i++) {
      localbuf[i] = fBlock_raw[i];
      //        localbuf[4] += localbuf[i]; // fHardwareBlockSum_raw
    }
    // The following causes many rounding errors and skips due to the check
    // that fHardwareBlockSum_raw == fSoftwareBlockSum_raw in IsGoodEvent().
    localbuf[4] = fHardwareBlockSum_raw;
    localbuf[5] = (fNumberOfSamples << 16 & 0xFFFF0000)
                | (fSequenceNumber  << 8  & 0x0000FF00);
 
    for (Int_t i = 0; i < 6; i++){
        buffer.push_back(localbuf[i]);
    }
  }
}

References fBlock_raw, fHardwareBlockSum_raw, fNumberOfSamples, fSequenceNumber, and VQwDataElement::IsNameEmpty().

Here is the call graph for this function:

◆ FillHistograms()

void QwVQWK_Channel::FillHistograms ( )

overridevirtual

Fill the histograms for this data element.

Implements VQwDataElement.

Definition at line 684 of file QwVQWK_Channel.cc.

{
  Int_t index=0;
  
  if (IsNameEmpty())
    {
      //  This channel is not used, so skip creating the histograms.
    } else
      {
        if(fDataToSave==kRaw)
          {
            for (Int_t i=0; i<fBlocksPerEvent; i++)
              {
                if (fHistograms[index] != NULL && (fErrorFlag)==0)
                  fHistograms[index]->Fill(this->GetRawBlockValue(i));
                if (fHistograms[index+1] != NULL && (fErrorFlag)==0)
                  fHistograms[index+1]->Fill(this->GetBlockValue(i));
                index+=2;
              }
            if (fHistograms[index] != NULL && (fErrorFlag)==0)
              fHistograms[index]->Fill(this->GetRawHardwareSum());
            if (fHistograms[index+1] != NULL && (fErrorFlag)==0)
              fHistograms[index+1]->Fill(this->GetHardwareSum());
            index+=2;
            if (fHistograms[index] != NULL && (fErrorFlag)==0)
              fHistograms[index]->Fill(this->GetRawSoftwareSum()-this->GetRawHardwareSum());
          }
        else if(fDataToSave==kDerived)
          {
            for (Int_t i=0; i<fBlocksPerEvent; i++)
              {
                if (fHistograms[index] != NULL && (fErrorFlag)==0)
                  fHistograms[index]->Fill(this->GetBlockValue(i));
                index+=1;
              }
            if (fHistograms[index] != NULL && (fErrorFlag)==0)
              fHistograms[index]->Fill(this->GetHardwareSum());
            index+=1; 
            if (fHistograms[index] != NULL){
              if ( (kErrorFlag_sample &  fErrorFlag)==kErrorFlag_sample)
                fHistograms[index]->Fill(kErrorFlag_sample);
              if ( (kErrorFlag_SW_HW &  fErrorFlag)==kErrorFlag_SW_HW)
                fHistograms[index]->Fill(kErrorFlag_SW_HW);
              if ( (kErrorFlag_Sequence &  fErrorFlag)==kErrorFlag_Sequence)
                fHistograms[index]->Fill(kErrorFlag_Sequence);
              if ( (kErrorFlag_ZeroHW &  fErrorFlag)==kErrorFlag_ZeroHW)
                fHistograms[index]->Fill(kErrorFlag_ZeroHW);
              if ( (kErrorFlag_VQWK_Sat &  fErrorFlag)==kErrorFlag_VQWK_Sat)
                fHistograms[index]->Fill(kErrorFlag_VQWK_Sat);
              if ( (kErrorFlag_SameHW &  fErrorFlag)==kErrorFlag_SameHW)
                fHistograms[index]->Fill(kErrorFlag_SameHW);
            }
            
          }
 
    }
}

References fBlocksPerEvent, VQwHardwareChannel::fDataToSave, VQwDataElement::fErrorFlag, MQwHistograms::fHistograms, GetBlockValue(), GetHardwareSum(), GetRawBlockValue(), GetRawHardwareSum(), GetRawSoftwareSum(), VQwDataElement::IsNameEmpty(), VQwDataElement::kDerived, kErrorFlag_SameHW, kErrorFlag_sample, kErrorFlag_Sequence, kErrorFlag_SW_HW, kErrorFlag_VQWK_Sat, kErrorFlag_ZeroHW, and VQwDataElement::kRaw.

Here is the call graph for this function:

◆ FillTreeVector()

void QwVQWK_Channel::FillTreeVector ( QwRootTreeBranchVector & values ) const

overridevirtual

Implements VQwHardwareChannel.

Definition at line 841 of file QwVQWK_Channel.cc.

{
  if (IsNameEmpty()) {
    //  This channel is not used, so skip filling the tree vector.
  } else if (fTreeArrayNumEntries <= 0) {
    if (bDEBUG) std::cerr << "QwVQWK_Channel::FillTreeVector:  fTreeArrayNumEntries=="
              << fTreeArrayNumEntries << std::endl;
  } else if (values.size() < fTreeArrayIndex+fTreeArrayNumEntries){
    if (bDEBUG) std::cerr << "QwVQWK_Channel::FillTreeVector:  values.size()=="
              << values.size()
              << "; fTreeArrayIndex+fTreeArrayNumEntries=="
              << fTreeArrayIndex+fTreeArrayNumEntries
              << std::endl;
  } else {
 
    UInt_t index = fTreeArrayIndex;
 
    // hw_sum
    if (bHw_sum) {
      //values.SetValue(fTreeArrayIndex, "hw_sum"_h32, this->GetHardwareSum());
      values.SetValue(index++, this->GetHardwareSum());
      if (fDataToSave == kMoments) {
        values.SetValue(index++, this->GetHardwareSumM2());
        values.SetValue(index++, this->GetHardwareSumError());
      }
    }
 
    if (bBlock) {
      for (Int_t i = 0; i < fBlocksPerEvent; i++) {
        // blocki
        values.SetValue(index++, this->GetBlockValue(i));
      }
    }
 
    // num_samples
    if (bNum_samples)
      values.SetValue(index++, (fDataToSave == kMoments)? this->fGoodEventCount: this->fNumberOfSamples);
 
    // Device_Error_Code
    if (bDevice_Error_Code)
      values.SetValue(index++, this->fErrorFlag);
 
    if (fDataToSave == kRaw)
      {
        // hw_sum_raw
        if (bHw_sum_raw)
          values.SetValue(index++, this->GetRawHardwareSum());
 
        if (bBlock_raw) {
          for (Int_t i = 0; i < fBlocksPerEvent; i++) {
            // blocki_raw
            values.SetValue(index++, this->GetRawBlockValue(i));
          }
        }
 
        // sequence_number
        if (bSequence_number)
          values.SetValue(index++, this->fSequenceNumber);
      }
  }
}

References bBlock, bBlock_raw, bDEBUG, bDevice_Error_Code, bHw_sum, bHw_sum_raw, bNum_samples, bSequence_number, fBlocksPerEvent, VQwHardwareChannel::fDataToSave, VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fNumberOfSamples, fSequenceNumber, VQwHardwareChannel::fTreeArrayIndex, VQwHardwareChannel::fTreeArrayNumEntries, GetBlockValue(), GetHardwareSum(), GetHardwareSumError(), GetHardwareSumM2(), GetRawBlockValue(), GetRawHardwareSum(), VQwDataElement::IsNameEmpty(), VQwDataElement::kMoments, VQwDataElement::kRaw, QwRootTreeBranchVector::SetValue(), and QwRootTreeBranchVector::size().

Here is the call graph for this function:

◆ ForceMapfileSampleSize()

void QwVQWK_Channel::ForceMapfileSampleSize ( )

inline

Forces the event "number of samples" variable to be what was expected from the mapfile. NOTE: this should only be used in mock data generation!

Definition at line 137 of file QwVQWK_Channel.h.

137{fNumberOfSamples = fNumberOfSamples_map;};

References fNumberOfSamples, and fNumberOfSamples_map.

◆ GetAverageVolts()

Double_t QwVQWK_Channel::GetAverageVolts ( ) const

Definition at line 597 of file QwVQWK_Channel.cc.

{
  //Double_t avgVolts = (fBlock[0]+fBlock[1]+fBlock[2]+fBlock[3])*kVQWK_VoltsPerBit/fNumberOfSamples;
  Double_t avgVolts = fHardwareBlockSum * kVQWK_VoltsPerBit / fNumberOfSamples;
  //std::cout<<"QwVQWK_Channel::GetAverageVolts() = "<<avgVolts<<std::endl;
  return avgVolts;
 
}

References fHardwareBlockSum, fNumberOfSamples, and kVQWK_VoltsPerBit.

◆ GetBlockErrorValue()

Double_t QwVQWK_Channel::GetBlockErrorValue ( size_t blocknum ) const

inlineprivate

Definition at line 304 of file QwVQWK_Channel.h.

304{ return GetValueError(blocknum+1);};

QwVQWK_Channel::GetValueError

Double_t GetValueError() const

Definition VQwHardwareChannel.h:128

References GetValueError().

Referenced by PrintValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBlockValue()

Double_t QwVQWK_Channel::GetBlockValue ( size_t blocknum ) const

inlineprivate

Definition at line 303 of file QwVQWK_Channel.h.

303{ return GetValue(blocknum+1);};

QwVQWK_Channel::GetValue

Double_t GetValue() const

Definition VQwHardwareChannel.h:126

References GetValue().

Referenced by FillHistograms(), FillTreeVector(), and PrintValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBufferOffset()

Int_t QwVQWK_Channel::GetBufferOffset	(	Int_t	moduleindex,
		Int_t	channelindex )

static

Class: QwVQWK_Channel Base class containing decoding functions for the VQWK_Channel 6 32-bit datawords. The functions in this class will decode a single channel worth of VQWK_Channel data and provide the components through member functions.

Static member function to return the word offset within a data buffer given the module number index and the channel number index.

Parameters

moduleindex	Module index within this buffer; counts from zero
channelindex	Channel index within this module; counts from zero

Returns: The number of words offset to the beginning of this channel's data from the beginning of the VQWK buffer.

Definition at line 43 of file QwVQWK_Channel.cc.

                                                                          {
    Int_t offset = -1;
    if (moduleindex<0 ){
      QwError << "QwVQWK_Channel::GetBufferOffset:  Invalid module index,"
              << moduleindex
              << ".  Must be zero or greater."
              << QwLog::endl;
    } else if (channelindex<0 || channelindex>kMaxChannels){
      QwError << "QwVQWK_Channel::GetBufferOffset:  Invalid channel index,"
              << channelindex
              << ".  Must be in range [0," << kMaxChannels << "]."
              << QwLog::endl;
    } else {
      offset = ( (moduleindex * kMaxChannels) + channelindex )
        * kWordsPerChannel;
    }
    return offset;
  }

References QwLog::endl(), kMaxChannels, kWordsPerChannel, and QwError.

Referenced by QwBeamDetectorID::QwBeamDetectorID(), and QwModChannelID::QwModChannelID().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetHardwareSum()

Double_t QwVQWK_Channel::GetHardwareSum ( ) const

inlineprivate

Definition at line 306 of file QwVQWK_Channel.h.

306{ return GetValue(0);};

References GetValue().

Referenced by ApplySingleEventCuts(), ApplySingleEventCuts(), FillHistograms(), FillTreeVector(), operator<<, and PrintValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetHardwareSumError()

Double_t QwVQWK_Channel::GetHardwareSumError ( ) const

inlineprivate

Definition at line 309 of file QwVQWK_Channel.h.

309{ return GetValueError(0); };

References GetValueError().

Referenced by FillTreeVector(), and PrintValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetHardwareSumM2()

Double_t QwVQWK_Channel::GetHardwareSumM2 ( ) const

inlineprivate

Definition at line 307 of file QwVQWK_Channel.h.

307{ return GetValueM2(0); };

QwVQWK_Channel::GetValueM2

Double_t GetValueM2() const

Definition VQwHardwareChannel.h:127

References GetValueM2().

Referenced by FillTreeVector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetHardwareSumWidth()

Double_t QwVQWK_Channel::GetHardwareSumWidth ( ) const

inlineprivate

Definition at line 308 of file QwVQWK_Channel.h.

308{ return GetValueWidth(0); };

References GetValueWidth().

Referenced by PrintValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetNumberOfSamples()

size_t QwVQWK_Channel::GetNumberOfSamples ( ) const

inline

Definition at line 276 of file QwVQWK_Channel.h.

276{return (fNumberOfSamples);};

References fNumberOfSamples.

Referenced by ApplyHWChecks().

Here is the caller graph for this function:

◆ GetRawBlockValue()

Int_t QwVQWK_Channel::GetRawBlockValue ( size_t blocknum ) const

inlineprivate

Definition at line 312 of file QwVQWK_Channel.h.

312{return GetRawValue(blocknum+1);};

QwVQWK_Channel::GetRawValue

Int_t GetRawValue() const

Definition VQwHardwareChannel.h:125

References GetRawValue().

Referenced by FillHistograms(), and FillTreeVector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRawHardwareSum()

Int_t QwVQWK_Channel::GetRawHardwareSum ( ) const

inlineprivate

Definition at line 313 of file QwVQWK_Channel.h.

313{ return GetRawValue(0);};

References GetRawValue().

Referenced by ApplyHWChecks(), FillHistograms(), and FillTreeVector().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRawSoftwareSum()

Int_t QwVQWK_Channel::GetRawSoftwareSum ( ) const

inlineprivate

Definition at line 314 of file QwVQWK_Channel.h.

314{return fSoftwareBlockSum_raw;};

References fSoftwareBlockSum_raw.

Referenced by ApplyHWChecks(), and FillHistograms().

Here is the caller graph for this function:

◆ GetRawValue() [1/2]

Int_t VQwHardwareChannel::GetRawValue ( ) const

inline

Definition at line 125 of file VQwHardwareChannel.h.

125{return this->GetRawValue(0);};

Referenced by GetRawBlockValue(), and GetRawHardwareSum().

Here is the caller graph for this function:

◆ GetRawValue() [2/2]

Int_t QwVQWK_Channel::GetRawValue ( size_t element ) const

inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 251 of file QwVQWK_Channel.h.

                                                   {
    RangeCheck(element);
    if (element==0) return fHardwareBlockSum_raw;
    return fBlock_raw[element-1];
  }

References fBlock_raw, fHardwareBlockSum_raw, and VQwHardwareChannel::RangeCheck().

Here is the call graph for this function:

◆ GetSequenceNumber()

size_t QwVQWK_Channel::GetSequenceNumber ( ) const

inline

Definition at line 275 of file QwVQWK_Channel.h.

275{return (fSequenceNumber);};

References fSequenceNumber.

Referenced by ApplyHWChecks().

Here is the caller graph for this function:

◆ GetValue() [1/2]

Double_t VQwHardwareChannel::GetValue ( ) const

inline

Definition at line 126 of file VQwHardwareChannel.h.

126{return this->GetValue(0);};

Referenced by GetBlockValue(), and GetHardwareSum().

Here is the caller graph for this function:

◆ GetValue() [2/2]

Double_t QwVQWK_Channel::GetValue ( size_t element ) const

inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 256 of file QwVQWK_Channel.h.

                                                   {
    RangeCheck(element);
    if (element==0) return fHardwareBlockSum;
    return fBlock[element-1];
  }

References fBlock, fHardwareBlockSum, and VQwHardwareChannel::RangeCheck().

Referenced by QwQPD::ProcessEvent(), and QwBlinder::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetValueError() [1/2]

Double_t VQwHardwareChannel::GetValueError ( ) const

inline

Definition at line 128 of file VQwHardwareChannel.h.

128{return this->GetValueError(0);};

Referenced by GetBlockErrorValue(), and GetHardwareSumError().

Here is the caller graph for this function:

◆ GetValueError() [2/2]

Double_t QwVQWK_Channel::GetValueError ( size_t element ) const

inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 266 of file QwVQWK_Channel.h.

                                                        {
    RangeCheck(element);
    if (element==0) return fHardwareBlockSumError;
    return fBlockError[element-1];
  }

References fBlockError, fHardwareBlockSumError, and VQwHardwareChannel::RangeCheck().

Here is the call graph for this function:

◆ GetValueM2() [1/2]

Double_t VQwHardwareChannel::GetValueM2 ( ) const

inline

Definition at line 127 of file VQwHardwareChannel.h.

127{return this->GetValueM2(0);};

Referenced by GetHardwareSumM2().

Here is the caller graph for this function:

◆ GetValueM2() [2/2]

Double_t QwVQWK_Channel::GetValueM2 ( size_t element ) const

inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 261 of file QwVQWK_Channel.h.

                                                     {
    RangeCheck(element);
    if (element==0) return fHardwareBlockSumM2;
    return fBlockM2[element-1];
  }

References fBlockM2, fHardwareBlockSumM2, and VQwHardwareChannel::RangeCheck().

Here is the call graph for this function:

◆ GetValueWidth() [1/2]

Double_t VQwHardwareChannel::GetValueWidth ( ) const

inline

Definition at line 129 of file VQwHardwareChannel.h.

129{return this->GetValueWidth(0);};

Referenced by CalculateRunningAverage(), and GetHardwareSumWidth().

Here is the caller graph for this function:

◆ GetValueWidth() [2/2]

Double_t VQwHardwareChannel::GetValueWidth ( size_t element ) const

inline

Definition at line 134 of file VQwHardwareChannel.h.

                                               {
    RangeCheck(element);
    Double_t width;
    if (fGoodEventCount>0){
      width = (GetValueError(element)*std::sqrt(Double_t(fGoodEventCount))); 
    } else {
      width = 0.0;
    } 
    return width;
  };

◆ GetVQWKSaturationLimt()

Double_t QwVQWK_Channel::GetVQWKSaturationLimt ( )

inline

Definition at line 227 of file QwVQWK_Channel.h.

                                  {//Get the absolute staturation limit in volts.
    return fSaturationABSLimit;
  }

References fSaturationABSLimit.

Referenced by ApplyHWChecks().

Here is the caller graph for this function:

◆ IncrementErrorCounters()

void QwVQWK_Channel::IncrementErrorCounters ( )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 140 of file QwVQWK_Channel.cc.

                                           {
  if ( (kErrorFlag_sample &  fErrorFlag)==kErrorFlag_sample)
    fErrorCount_sample++; //increment the hw error counter
  if ( (kErrorFlag_SW_HW &  fErrorFlag)==kErrorFlag_SW_HW)
    fErrorCount_SW_HW++; //increment the hw error counter
  if ( (kErrorFlag_Sequence &  fErrorFlag)==kErrorFlag_Sequence)
    fErrorCount_Sequence++; //increment the hw error counter
  if ( (kErrorFlag_SameHW &  fErrorFlag)==kErrorFlag_SameHW)
    fErrorCount_SameHW++; //increment the hw error counter
  if ( (kErrorFlag_ZeroHW &  fErrorFlag)==kErrorFlag_ZeroHW)
    fErrorCount_ZeroHW++; //increment the hw error counter
  if ( (kErrorFlag_VQWK_Sat &  fErrorFlag)==kErrorFlag_VQWK_Sat)
    fErrorCount_HWSat++; //increment the hw saturation error counter
  if ( ((kErrorFlag_EventCut_L &  fErrorFlag)==kErrorFlag_EventCut_L) 
       || ((kErrorFlag_EventCut_U &  fErrorFlag)==kErrorFlag_EventCut_U)){
    fNumEvtsWithEventCutsRejected++; //increment the event cut error counter
  }
}

References fErrorCount_HWSat, fErrorCount_SameHW, fErrorCount_sample, fErrorCount_Sequence, fErrorCount_SW_HW, fErrorCount_ZeroHW, VQwDataElement::fErrorFlag, fNumEvtsWithEventCutsRejected, kErrorFlag_EventCut_L, kErrorFlag_EventCut_U, kErrorFlag_SameHW, kErrorFlag_sample, kErrorFlag_Sequence, kErrorFlag_SW_HW, kErrorFlag_VQWK_Sat, and kErrorFlag_ZeroHW.

◆ InitializeChannel() [1/2]

void QwVQWK_Channel::InitializeChannel	(	TString	name,
		TString	datatosave )

overridevirtual

Initialize the fields in this object.

Implements VQwHardwareChannel.

Definition at line 161 of file QwVQWK_Channel.cc.

{
  SetElementName(name);
  SetDataToSave(datatosave);
  SetNumberOfDataWords(6);
  SetNumberOfSubElements(5);
 
  kFoundPedestal = 0;
  kFoundGain = 0;
 
  fPedestal            = 0.0;
  fCalibrationFactor   = 1.0;
 
  fBlocksPerEvent      = 4;
 
  fTreeArrayIndex      = 0;
  fTreeArrayNumEntries = 0;
 
  ClearEventData();
 
  fPreviousSequenceNumber = 0;
  fNumberOfSamples_map    = 0;
  fNumberOfSamples        = 0;
 
  // Use internal random variable by default
  fUseExternalRandomVariable = false;
 
  // Mock drifts
  fMockDriftAmplitude.clear();
  fMockDriftFrequency.clear();
  fMockDriftPhase.clear();
 
  // Mock asymmetries
  fMockAsymmetry     = 0.0;
  fMockGaussianMean  = 0.0;
  fMockGaussianSigma = 0.0;
 
  // Event cuts
  fULimit=-1;
  fLLimit=1;
  fNumEvtsWithEventCutsRejected = 0;
 
  fErrorFlag=0;               //Initialize the error flag
  fErrorConfigFlag=0;         //Initialize the error config. flag
 
  //init error counters//
  fErrorCount_sample     = 0;
  fErrorCount_SW_HW      = 0;
  fErrorCount_Sequence   = 0;
  fErrorCount_SameHW     = 0;
  fErrorCount_ZeroHW     = 0;
  fErrorCount_HWSat      = 0;
 
  fADC_Same_NumEvt       = 0;
  fSequenceNo_Prev       = 0;
  fSequenceNo_Counter    = 0;
  fPrev_HardwareBlockSum = 0.0;
 
  fGoodEventCount        = 0;
 
  bEVENTCUTMODE          = 0;
 
  //std::cout<< "name = "<<name<<" error count same _HW = "<<fErrorCount_SameHW <<std::endl;
  return;
}

Referenced by InitializeChannel(), QwLinearDiodeArray::ProcessEvent(), QwQPD::ProcessEvent(), QwVQWK_Channel(), and QwVQWK_Channel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitializeChannel() [2/2]

void QwVQWK_Channel::InitializeChannel	(	TString	subsystem,
		TString	instrumenttype,
		TString	name,
		TString	datatosave )

overridevirtual

Initialize the fields in this object.

Implements VQwHardwareChannel.

Definition at line 229 of file QwVQWK_Channel.cc.

                                                                                                                 {
  InitializeChannel(name,datatosave);
  SetSubsystemName(subsystem);
  SetModuleType(instrumenttype);
  //PrintInfo();
}

References InitializeChannel(), VQwDataElement::SetModuleType(), and VQwDataElement::SetSubsystemName().

Here is the call graph for this function:

◆ LoadChannelParameters()

void QwVQWK_Channel::LoadChannelParameters ( QwParameterFile & paramfile )

overridevirtual

Reimplemented from VQwDataElement.

Definition at line 236 of file QwVQWK_Channel.cc.

                                                                    {
  UInt_t value = 0;
  if (paramfile.ReturnValue("sample_size",value)){
    SetDefaultSampleSize(value);
  } else {
    QwWarning << "VQWK Channel "
              << GetElementName()
              << " cannot set the default sample size."
              << QwLog::endl;
  }
};

References QwLog::endl(), VQwDataElement::GetElementName(), QwWarning, QwParameterFile::ReturnValue(), and SetDefaultSampleSize().

Here is the call graph for this function:

◆ LoadMockDataParameters()

void MQwMockable::LoadMockDataParameters ( QwParameterFile & paramfile )

virtual

Load the mock data parameters from the current line in the param file.

Reimplemented from VQwDataElement.

Definition at line 60 of file MQwMockable.cc.

                                                                  {
  Bool_t   ldebug=kFALSE;
  Double_t asym=0.0, mean=0.0, sigma=0.0;
  Double_t amplitude=0.0, phase=0.0, frequency=0.0;
 
  //Check to see if this line contains "drift"
  if (paramfile.GetLine().find("drift")!=std::string::npos){
    //  "drift" appears somewhere in the line.  Assume it is the next token and move on...
    paramfile.GetNextToken();  //Throw away this token.  Now the next three should be the drift parameters.
    //read 3 parameters
    amplitude = paramfile.GetTypedNextToken<Double_t>();
    phase     = paramfile.GetTypedNextToken<Double_t>();
    frequency = paramfile.GetTypedNextToken<Double_t>();  //  The frequency we read in should be in Hz.
    this->AddRandomEventDriftParameters(amplitude, phase, frequency*Qw::Hz);
    // std::cout << "In MQwMockable::LoadMockDataParameters: amp = " << amplitude << "\t phase = " << phase << "\t freq = " << frequency << std::endl;
  } 
  else {
    asym  = paramfile.GetTypedNextToken<Double_t>();
    mean  = paramfile.GetTypedNextToken<Double_t>(); 
    sigma = paramfile.GetTypedNextToken<Double_t>();      
    if (ldebug==1) {
      std::cout << "#################### \n";
      std::cout << "asym, mean, sigma \n" << std::endl;
      std::cout << asym                   << " / "
            << mean                   << " / "
            << sigma                  << " / "
                << std::endl;  
    }
    this->SetRandomEventParameters(mean, sigma);
    this->SetRandomEventAsymmetry(asym);
  }
}

◆ MatchNumberOfSamples()

Bool_t QwVQWK_Channel::MatchNumberOfSamples ( size_t numsamp )

Definition at line 1841 of file QwVQWK_Channel.cc.

{
  Bool_t status = kTRUE;
  if (!IsNameEmpty()){
    status = (fNumberOfSamples==numsamp);
    if (! status){
      if (bDEBUG)
        std::cerr << "QwVQWK_Channel::MatchNumberOfSamples:  Channel "
                << GetElementName()
                << " had fNumberOfSamples==" << fNumberOfSamples
                << " and was supposed to have " << numsamp
                << std::endl;
      //      PrintChannel();
    }
  }
  return status;
}

References bDEBUG, fNumberOfSamples, VQwDataElement::GetElementName(), and VQwDataElement::IsNameEmpty().

Referenced by ApplyHWChecks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MatchSequenceNumber()

Bool_t QwVQWK_Channel::MatchSequenceNumber ( size_t seqnum )

Definition at line 1831 of file QwVQWK_Channel.cc.

{
 
  Bool_t status = kTRUE;
  if (!IsNameEmpty()){
    status = (fSequenceNumber==seqnum);
    }
  return status;
}

References fSequenceNumber, and VQwDataElement::IsNameEmpty().

Referenced by ApplyHWChecks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MultiplyBy()

void QwVQWK_Channel::MultiplyBy ( const VQwHardwareChannel * valueptr )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1208 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(valueptr);
  if (tmpptr!=NULL){
    *this *= *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::MultiplyBy = "
      +valueptr->GetElementName()+" is an incompatible type.";
    throw std::invalid_argument(loc.Data());
  }
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ operator*()

const QwVQWK_Channel QwVQWK_Channel::operator* ( const QwVQWK_Channel & value ) const

Definition at line 1284 of file QwVQWK_Channel.cc.

{
  QwVQWK_Channel result = *this;
  result *= value;
  return result;
}

References QwVQWK_Channel().

Here is the call graph for this function:

◆ operator*=() [1/2]

QwVQWK_Channel & QwVQWK_Channel::operator*= ( const QwVQWK_Channel & value )

Definition at line 1291 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()){
    for (Int_t i=0; i<fBlocksPerEvent; i++){
      this->fBlock[i] *= value.fBlock[i];
      this->fBlockM2[i] = 0.0;
    }
    this->fHardwareBlockSum     *= value.fHardwareBlockSum;
    this->fHardwareBlockSumM2    = 0.0;
    this->fNumberOfSamples      *= value.fNumberOfSamples;
    this->fSequenceNumber        = 0;
    this->fErrorFlag            |= (value.fErrorFlag);
  }
 
  return *this;
}

References fBlock, fBlockM2, fBlocksPerEvent, VQwDataElement::fErrorFlag, fHardwareBlockSum, fHardwareBlockSumM2, fNumberOfSamples, fSequenceNumber, VQwDataElement::IsNameEmpty(), and QwVQWK_Channel().

Here is the call graph for this function:

◆ operator*=() [2/2]

VQwHardwareChannel & QwVQWK_Channel::operator*= ( const VQwHardwareChannel & input )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1336 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(&source);
  if (tmpptr!=NULL){
    *this *= *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::operator*= "
        +source.GetElementName()+" "
        +this->GetElementName()+" are not of the same type";
    throw(std::invalid_argument(loc.Data()));
  }
  return *this;
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ operator+()

const QwVQWK_Channel QwVQWK_Channel::operator+ ( const QwVQWK_Channel & value ) const

Definition at line 1234 of file QwVQWK_Channel.cc.

{
  QwVQWK_Channel result = *this;
  result += value;
  return result;
}

References QwVQWK_Channel().

Here is the call graph for this function:

◆ operator+=() [1/2]

QwVQWK_Channel & QwVQWK_Channel::operator+= ( const QwVQWK_Channel & value )

Definition at line 1241 of file QwVQWK_Channel.cc.

{
 
  if (!IsNameEmpty()) {
    for (Int_t i = 0; i < fBlocksPerEvent; i++) {
      this->fBlock[i] += value.fBlock[i];
      this->fBlockM2[i] = 0.0;
    }
    this->fHardwareBlockSum    += value.fHardwareBlockSum;
    this->fHardwareBlockSumM2   = 0.0;
    this->fNumberOfSamples     += value.fNumberOfSamples;
    this->fSequenceNumber       = 0;
    this->fErrorFlag            |= (value.fErrorFlag);
 
  }
 
  return *this;
}

References fBlock, fBlockM2, fBlocksPerEvent, VQwDataElement::fErrorFlag, fHardwareBlockSum, fHardwareBlockSumM2, fNumberOfSamples, fSequenceNumber, VQwDataElement::IsNameEmpty(), and QwVQWK_Channel().

Here is the call graph for this function:

◆ operator+=() [2/2]

VQwHardwareChannel & QwVQWK_Channel::operator+= ( const VQwHardwareChannel & input )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1308 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(&source);
  if (tmpptr!=NULL){
    *this += *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::operator+= "
        +source.GetElementName()+" "
        +this->GetElementName()+" are not of the same type";
    throw(std::invalid_argument(loc.Data()));
  }
  return *this;
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ operator-()

const QwVQWK_Channel QwVQWK_Channel::operator- ( const QwVQWK_Channel & value ) const

Definition at line 1260 of file QwVQWK_Channel.cc.

{
  QwVQWK_Channel result = *this;
  result -= value;
  return result;
}

References QwVQWK_Channel().

Here is the call graph for this function:

◆ operator-=() [1/2]

QwVQWK_Channel & QwVQWK_Channel::operator-= ( const QwVQWK_Channel & value )

Definition at line 1267 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()){
    for (Int_t i=0; i<fBlocksPerEvent; i++){
      this->fBlock[i] -= value.fBlock[i];
      this->fBlockM2[i] = 0.0;
    }
    this->fHardwareBlockSum    -= value.fHardwareBlockSum;
    this->fHardwareBlockSumM2   = 0.0;
    this->fNumberOfSamples     += value.fNumberOfSamples;
    this->fSequenceNumber       = 0;
    this->fErrorFlag           |= (value.fErrorFlag);
  }
 
  return *this;
}

References fBlock, fBlockM2, fBlocksPerEvent, VQwDataElement::fErrorFlag, fHardwareBlockSum, fHardwareBlockSumM2, fNumberOfSamples, fSequenceNumber, VQwDataElement::IsNameEmpty(), and QwVQWK_Channel().

Here is the call graph for this function:

◆ operator-=() [2/2]

VQwHardwareChannel & QwVQWK_Channel::operator-= ( const VQwHardwareChannel & input )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1322 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(&source);
  if (tmpptr!=NULL){
    *this -= *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::operator-= "
        +source.GetElementName()+" "
        +this->GetElementName()+" are not of the same type";
    throw(std::invalid_argument(loc.Data()));
  }
  return *this;
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ operator/=() [1/2]

QwVQWK_Channel & QwVQWK_Channel::operator/= ( const QwVQWK_Channel & value )

protected

Definition at line 1392 of file QwVQWK_Channel.cc.

{
  //  In this function, leave the "raw" variables untouched.
  //  
  Double_t ratio;
  Double_t variance;
  if (!IsNameEmpty()) {
    // The variances are calculated using the following formula:
    //   Var[ratio] = ratio^2 (Var[numer] / numer^2 + Var[denom] / denom^2)
    //
    // This requires that both the numerator and denominator are non-zero!
    //
    for (Int_t i = 0; i < 4; i++) {
      if (this->fBlock[i] != 0.0 && denom.fBlock[i] != 0.0){
        ratio    = (this->fBlock[i]) / (denom.fBlock[i]);
        variance =  ratio * ratio *
           (this->fBlockM2[i] / this->fBlock[i] / this->fBlock[i]
          + denom.fBlockM2[i] / denom.fBlock[i] / denom.fBlock[i]);
        fBlock[i]   = ratio;
        fBlockM2[i] = variance;
      } else if (this->fBlock[i] == 0.0) {
        this->fBlock[i]   = 0.0;
        this->fBlockM2[i] = 0.0;
      } else {
        QwVerbose << "Attempting to divide by zero block in " 
                  << GetElementName() << QwLog::endl;
        fBlock[i]   = 0.0;
        fBlockM2[i] = 0.0;
      }
    }
    if (this->fHardwareBlockSum != 0.0 && denom.fHardwareBlockSum != 0.0){
      ratio    =  (this->fHardwareBlockSum) / (denom.fHardwareBlockSum);
      variance =  ratio * ratio *
        (this->fHardwareBlockSumM2 / this->fHardwareBlockSum / this->fHardwareBlockSum
         + denom.fHardwareBlockSumM2 / denom.fHardwareBlockSum / denom.fHardwareBlockSum);
      fHardwareBlockSum   = ratio;
      fHardwareBlockSumM2 = variance;
    } else if (this->fHardwareBlockSum == 0.0) {
      fHardwareBlockSum   = 0.0;
      fHardwareBlockSumM2 = 0.0;
    } else {
      QwVerbose << "Attempting to divide by zero sum in " 
                << GetElementName() << QwLog::endl;
      fHardwareBlockSumM2 = 0.0;
    }
    // Remaining variables
    //  Don't change fNumberOfSamples, fSequenceNumber, fGoodEventCount,
    //  'OR' the HW error codes in the fErrorFlag values together.
    fErrorFlag |= (denom.fErrorFlag);//mix only the hardware error codes
  }
 
  // Nanny
  if (fHardwareBlockSum != fHardwareBlockSum)
    QwWarning << "Angry Nanny: NaN detected in " << GetElementName() << QwLog::endl;
 
  return *this;
}

References QwLog::endl(), fBlock, fBlockM2, VQwDataElement::fErrorFlag, fHardwareBlockSum, fHardwareBlockSumM2, VQwDataElement::GetElementName(), VQwDataElement::IsNameEmpty(), QwVerbose, QwVQWK_Channel(), and QwWarning.

Here is the call graph for this function:

◆ operator/=() [2/2]

VQwHardwareChannel & QwVQWK_Channel::operator/= ( const VQwHardwareChannel & input )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1350 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(&source);
  if (tmpptr!=NULL){
    *this /= *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::operator/= "
        +source.GetElementName()+" "
        +this->GetElementName()+" are not of the same type";
    throw(std::invalid_argument(loc.Data()));
  }
  return *this;
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ operator=()

QwVQWK_Channel & QwVQWK_Channel::operator= ( const QwVQWK_Channel & value )

Definition at line 1125 of file QwVQWK_Channel.cc.

{
  if(this ==&value) return *this;
 
  if (!IsNameEmpty()) {
    VQwHardwareChannel::operator=(value);
    for (Int_t i=0; i<fBlocksPerEvent; i++){
      this->fBlock[i]     = value.fBlock[i];
      this->fBlockM2[i]   = value.fBlockM2[i];
    }
    this->fHardwareBlockSum = value.fHardwareBlockSum;
    this->fHardwareBlockSumM2 = value.fHardwareBlockSumM2;
    this->fHardwareBlockSumError = value.fHardwareBlockSumError;
    this->fNumberOfSamples = value.fNumberOfSamples;
    this->fSequenceNumber  = value.fSequenceNumber;
   
    if (this->fDataToSave == kRaw){
      for (Int_t i=0; i<fBlocksPerEvent; i++){
       this->fBlock_raw[i] = value.fBlock_raw[i];
      }
      this->fHardwareBlockSum_raw = value.fHardwareBlockSum_raw;
      this->fSoftwareBlockSum_raw = value.fSoftwareBlockSum_raw;
    }
  }
  return *this;
}

References fBlock, fBlock_raw, fBlockM2, fBlocksPerEvent, VQwHardwareChannel::fDataToSave, fHardwareBlockSum, fHardwareBlockSum_raw, fHardwareBlockSumError, fHardwareBlockSumM2, fNumberOfSamples, fSequenceNumber, fSoftwareBlockSum_raw, VQwDataElement::IsNameEmpty(), VQwDataElement::kRaw, VQwHardwareChannel::operator=(), and QwVQWK_Channel().

Here is the call graph for this function:

◆ PrintErrorCounterHead()

void QwVQWK_Channel::PrintErrorCounterHead ( )

static

Definition at line 1911 of file QwVQWK_Channel.cc.

{
  TString message;
  message  = Form("%30s","Device name");
  message += Form("%9s", "HW Sat");
  message += Form("%9s", "Sample");
  message += Form("%9s", "SW_HW");
  message += Form("%9s", "Sequence");
  message += Form("%9s", "SameHW");
  message += Form("%9s", "ZeroHW");
  message += Form("%9s", "EventCut");
  QwMessage << "---------------------------------------------------------------------------------------------" << QwLog::endl;
  QwMessage << message << QwLog::endl; 
  QwMessage << "---------------------------------------------------------------------------------------------" << QwLog::endl;
  return;
}

References QwLog::endl(), and QwMessage.

Referenced by QwBeamLine::PrintErrorCounters(), and QwBeamMod::PrintErrorCounters().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintErrorCounters()

void QwVQWK_Channel::PrintErrorCounters ( ) const

overridevirtual

report number of events failed due to HW and event cut failure

Reimplemented from VQwDataElement.

Definition at line 1934 of file QwVQWK_Channel.cc.

{
  TString message;
  if (fErrorCount_sample || fErrorCount_SW_HW || fErrorCount_Sequence || fErrorCount_SameHW || fErrorCount_ZeroHW || fErrorCount_HWSat || fNumEvtsWithEventCutsRejected) {
    message  = Form("%30s", GetElementName().Data());
    message += Form("%9d", fErrorCount_HWSat);
    message += Form("%9d", fErrorCount_sample);
    message += Form("%9d", fErrorCount_SW_HW);
    message += Form("%9d", fErrorCount_Sequence);
    message += Form("%9d", fErrorCount_SameHW);
    message += Form("%9d", fErrorCount_ZeroHW);
    message += Form("%9d", fNumEvtsWithEventCutsRejected);
    
    if((fDataToSave == kRaw) && (!kFoundPedestal||!kFoundGain)){
      message += " >>>>> No Pedestal or Gain in map file";
    }
 
    QwMessage << message << QwLog::endl;
  }
  return;
}

References QwLog::endl(), VQwHardwareChannel::fDataToSave, fErrorCount_HWSat, fErrorCount_SameHW, fErrorCount_sample, fErrorCount_Sequence, fErrorCount_SW_HW, fErrorCount_ZeroHW, fNumEvtsWithEventCutsRejected, VQwDataElement::GetElementName(), VQwHardwareChannel::kFoundGain, VQwHardwareChannel::kFoundPedestal, VQwDataElement::kRaw, and QwMessage.

Here is the call graph for this function:

◆ PrintErrorCounterTail()

void QwVQWK_Channel::PrintErrorCounterTail ( )

static

Definition at line 1928 of file QwVQWK_Channel.cc.

{
  QwMessage << "---------------------------------------------------------------------------------------------" << QwLog::endl;
  return;
}

References QwLog::endl(), and QwMessage.

Referenced by QwBeamLine::PrintErrorCounters(), and QwBeamMod::PrintErrorCounters().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintInfo()

void QwVQWK_Channel::PrintInfo ( ) const

overridevirtual

Print multiple lines of information about this data element.

Reimplemented from VQwDataElement.

Definition at line 606 of file QwVQWK_Channel.cc.

{
  std::cout<<"***************************************"<<"\n";
  std::cout<<"Subsystem "<<GetSubsystemName()<<"\n"<<"\n";
  std::cout<<"Beam Instrument Type: "<<GetModuleType()<<"\n"<<"\n";
  std::cout<<"QwVQWK channel: "<<GetElementName()<<"\n"<<"\n";
  std::cout<<"fPedestal= "<< fPedestal<<"\n";
  std::cout<<"fCalibrationFactor= "<<fCalibrationFactor<<"\n";
  std::cout<<"fBlocksPerEvent= "<<fBlocksPerEvent<<"\n"<<"\n";
  std::cout<<"fSequenceNumber= "<<fSequenceNumber<<"\n";
  std::cout<<"fNumberOfSamples= "<<fNumberOfSamples<<"\n";
  std::cout<<"fBlock_raw ";
 
  for (Int_t i = 0; i < fBlocksPerEvent; i++)
    std::cout << " : " << fBlock_raw[i];
  std::cout<<"\n";
  std::cout<<"fHardwareBlockSum_raw= "<<fHardwareBlockSum_raw<<"\n";
  std::cout<<"fSoftwareBlockSum_raw= "<<fSoftwareBlockSum_raw<<"\n";
  std::cout<<"fBlock ";
  for (Int_t i = 0; i < fBlocksPerEvent; i++)
    std::cout << " : " <<std::setprecision(8) << fBlock[i];
  std::cout << std::endl;
 
  std::cout << "fHardwareBlockSum = "<<std::setprecision(8) <<fHardwareBlockSum << std::endl;
  std::cout << "fHardwareBlockSumM2 = "<<fHardwareBlockSumM2 << std::endl;
  std::cout << "fHardwareBlockSumError = "<<fHardwareBlockSumError << std::endl;
 
  return;
}

References fBlock, fBlock_raw, fBlocksPerEvent, VQwHardwareChannel::fCalibrationFactor, fHardwareBlockSum, fHardwareBlockSum_raw, fHardwareBlockSumError, fHardwareBlockSumM2, fNumberOfSamples, VQwHardwareChannel::fPedestal, fSequenceNumber, fSoftwareBlockSum_raw, VQwDataElement::GetElementName(), VQwDataElement::GetModuleType(), and VQwDataElement::GetSubsystemName().

Here is the call graph for this function:

◆ PrintValue()

void QwVQWK_Channel::PrintValue ( ) const

overridevirtual

Print single line of value and error of this data element.

Reimplemented from VQwDataElement.

Definition at line 1754 of file QwVQWK_Channel.cc.

{
  QwMessage << std::setprecision(8)
            << std::setw(18) << std::left << GetSubsystemName()    << " "
            << std::setw(18) << std::left << GetModuleType()       << " "
            << std::setw(18) << std::left << GetElementName()      << " "
            << std::setw(12) << std::left << GetHardwareSum()      << " +/- "
            << std::setw(12) << std::left << GetHardwareSumError() << " sig "
            << std::setw(12) << std::left << GetHardwareSumWidth() << " "
            << std::setw(10) << std::left << GetGoodEventCount()   << " "
            << std::setw(12) << std::left << GetBlockValue(0)      << " +/- "
            << std::setw(12) << std::left << GetBlockErrorValue(0) << " "
            << std::setw(12) << std::left << GetBlockValue(1)      << " +/- "
            << std::setw(12) << std::left << GetBlockErrorValue(1) << " "
            << std::setw(12) << std::left << GetBlockValue(2)      << " +/- "
            << std::setw(12) << std::left << GetBlockErrorValue(2) << " "
            << std::setw(12) << std::left << GetBlockValue(3)      << " +/- "
            << std::setw(12) << std::left << GetBlockErrorValue(3) << " "
            << std::setw(12) << std::left << fGoodEventCount       << " "
            << QwLog::endl;
  /*
    //for Debudding
            << std::setw(12) << std::left << fErrorFlag << " err "
            << std::setw(12) << std::left << fErrorConfigFlag << " c-err "
 
  */
}

References QwLog::endl(), VQwDataElement::fGoodEventCount, GetBlockErrorValue(), GetBlockValue(), VQwDataElement::GetElementName(), VQwDataElement::GetGoodEventCount(), GetHardwareSum(), GetHardwareSumError(), GetHardwareSumWidth(), VQwDataElement::GetModuleType(), VQwDataElement::GetSubsystemName(), and QwMessage.

Here is the call graph for this function:

◆ ProcessEvBuffer()

Int_t QwVQWK_Channel::ProcessEvBuffer	(	UInt_t *	buffer,
		UInt_t	num_words_left,
		UInt_t	index = 0 )

overridevirtual

Decode the event data from a CODA buffer.

Process raw event buffer data for a VQWK ADC channel.

Parameters

buffer	Pointer to raw data buffer from DAQ system.
num_words_left	Number of words remaining in the buffer.
index	Channel index within the ADC module (0-7).

Returns: Number of words consumed from the buffer.

This is a critical data processing function that decodes the 6-word VQWK ADC data format used throughout the Qweak/MOLLER analysis framework:

VQWK Data Format (6 words per channel):

Words 0-3: Individual block sums for 4 integration periods
Word 4: Hardware-calculated sum of all 4 blocks
Word 5: Combined sequence number (bits 8-15) and sample count (bits 16-31)

Data Processing Steps:

Validates sufficient buffer space (6 words minimum)
Copies raw data to local buffer with sign conversion (UInt_t -> Int_t)
Extracts individual block sums and hardware sum
Decodes sequence number for event ordering verification
Extracts sample count for integration time normalization
Calculates software block sum for hardware validation

Channel State Handling:

Empty channel names are skipped but consume buffer space
Insufficient buffer words trigger error messages
Raw data is stored for subsequent ProcessEvent() calibration

Error Detection:

Hardware vs software sum comparison (done in ProcessEvent())
Sequence number continuity checking
Sample count validation for proper integration

Buffer Management:

Always consumes exactly kWordsPerChannel (6) words when successful
Returns 0 on buffer underrun to indicate processing failure
Thread-safe local buffer prevents data corruption

Note: This function only processes raw data extraction. Calibration, pedestal subtraction, and physics calculations are performed in ProcessEvent().

Warning: Buffer underrun conditions will print error messages but may not halt processing, potentially causing downstream data corruption.

Implements VQwDataElement.

Definition at line 513 of file QwVQWK_Channel.cc.

{
  UInt_t words_read = 0;
  UInt_t localbuf[kWordsPerChannel] = {0};
  // The conversion from UInt_t to Double_t discards the sign, so we need an intermediate
  // static_cast from UInt_t to Int_t.
  Int_t localbuf_signed[kWordsPerChannel] = {0};
 
  if (IsNameEmpty()){
    //  This channel is not used, but is present in the data stream.
    //  Skip over this data.
    words_read = fNumberOfDataWords;
  } else if (num_words_left >= fNumberOfDataWords)
    {
      for (Int_t i=0; i<kWordsPerChannel; i++){
        localbuf[i] = buffer[i];
        localbuf_signed[i] = static_cast<Int_t>(localbuf[i]);
      }
 
      fSoftwareBlockSum_raw = 0;
      for (Int_t i=0; i<fBlocksPerEvent; i++){
        fBlock_raw[i] = localbuf_signed[i];
        fSoftwareBlockSum_raw += fBlock_raw[i];
      }
      fHardwareBlockSum_raw = localbuf_signed[4];
 
      /*  Permanent change in the structure of the 6th word of the ADC readout.
       *  The upper 16 bits are the number of samples, and the upper 8 of the
       *  lower 16 are the sequence number.  This matches the structure of
       *  the ADC readout in block read mode, and now also in register read mode.
       *  P.King, 2007sep04.
       */
      fSequenceNumber   = (localbuf[5]>>8)  & 0xFF;
      fNumberOfSamples  = (localbuf[5]>>16) & 0xFFFF;
 
      words_read = fNumberOfDataWords;
 
    } else
      {
        std::cerr << "QwVQWK_Channel::ProcessEvBuffer: Not enough words!"
                  << std::endl;
      }
  return words_read;
}

References fBlock_raw, fBlocksPerEvent, fHardwareBlockSum_raw, VQwHardwareChannel::fNumberOfDataWords, fNumberOfSamples, fSequenceNumber, fSoftwareBlockSum_raw, VQwDataElement::IsNameEmpty(), and kWordsPerChannel.

Here is the call graph for this function:

◆ ProcessEvent()

void QwVQWK_Channel::ProcessEvent ( )

overridevirtual

Process the event data according to pedestal and calibration factor.

Implements VQwHardwareChannel.

Definition at line 560 of file QwVQWK_Channel.cc.

{
  if (fNumberOfSamples == 0 && fHardwareBlockSum_raw == 0) {
    //  There isn't valid data for this channel.  Just flag it and
    //  move on.
    for (Int_t i = 0; i < fBlocksPerEvent; i++) {
      fBlock[i] = 0.0;
      fBlockM2[i] = 0.0;
    }
    fHardwareBlockSum = 0.0;
    fHardwareBlockSumM2 = 0.0;
    fErrorFlag |= kErrorFlag_sample;
  } else if (fNumberOfSamples == 0) {
    //  This is probably a more serious problem.
    QwWarning << "QwVQWK_Channel::ProcessEvent:  Channel "
              << this->GetElementName().Data()
              << " has fNumberOfSamples==0 but has valid data in the hardware sum.  "
              << "Flag this as an error."
              << QwLog::endl;
    for (Int_t i = 0; i < fBlocksPerEvent; i++) {
      fBlock[i] = 0.0;
      fBlockM2[i] = 0.0;
    }
    fHardwareBlockSum = 0.0;
    fHardwareBlockSumM2 = 0.0;
    fErrorFlag|=kErrorFlag_sample;
  } else {
    for (Int_t i = 0; i < fBlocksPerEvent; i++) {
      fBlock[i] = fCalibrationFactor * ( (1.0 * fBlock_raw[i] * fBlocksPerEvent / fNumberOfSamples) - fPedestal );
      fBlockM2[i] = 0.0; // second moment is zero for single events
    }
    fHardwareBlockSum = fCalibrationFactor * ( (1.0 * fHardwareBlockSum_raw / fNumberOfSamples) - fPedestal );
    fHardwareBlockSumM2 = 0.0; // second moment is zero for single events
  }
  return;
}

References QwLog::endl(), fBlock, fBlock_raw, fBlockM2, fBlocksPerEvent, VQwHardwareChannel::fCalibrationFactor, VQwDataElement::fErrorFlag, fHardwareBlockSum, fHardwareBlockSum_raw, fHardwareBlockSumM2, fNumberOfSamples, VQwHardwareChannel::fPedestal, VQwDataElement::GetElementName(), kErrorFlag_sample, and QwWarning.

Here is the call graph for this function:

◆ Product()

void QwVQWK_Channel::Product	(	const QwVQWK_Channel &	value1,
		const QwVQWK_Channel &	value2 )

Definition at line 1467 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()){
    for (Int_t i = 0; i < fBlocksPerEvent; i++) {
      this->fBlock[i] = (value1.fBlock[i]) * (value2.fBlock[i]);
      // For a single event the second moment is still zero
      this->fBlockM2[i] = 0.0;
    }
 
    // For a single event the second moment is still zero
    this->fHardwareBlockSumM2 = 0.0;
 
    this->fHardwareBlockSum = value1.fHardwareBlockSum * value2.fHardwareBlockSum;
    this->fNumberOfSamples = value1.fNumberOfSamples;
    this->fSequenceNumber  = 0;
    this->fErrorFlag       = (value1.fErrorFlag|value2.fErrorFlag);
  }
  return;
}

References fBlock, fBlockM2, fBlocksPerEvent, VQwDataElement::fErrorFlag, fHardwareBlockSum, fHardwareBlockSumM2, fNumberOfSamples, fSequenceNumber, VQwDataElement::IsNameEmpty(), and QwVQWK_Channel().

Referenced by QwLinearDiodeArray::ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RandomizeEventData()

void QwVQWK_Channel::RandomizeEventData	(	int	helicity = 0.0,
		double	time = 0.0 )

overridevirtual

Internally generate random event data.

Implements MQwMockable.

Definition at line 269 of file QwVQWK_Channel.cc.

{
  //std::cout << "In channel: " << GetElementName() << std::endl;
  // The blocks are assumed to be independent measurements
  // Double_t* block = new Double_t[fBlocksPerEvent];
  //  Double_t sqrt_fBlocksPerEvent = 0.0;
  // sqrt_fBlocksPerEvent = sqrt(fBlocksPerEvent);
 
  // Calculate drift (if time is not specified, it stays constant at zero)
  //Double_t drift = 0.0;
  //for (UInt_t i = 0; i < fMockDriftFrequency.size(); i++) {
  //  drift += fMockDriftAmplitude[i] * sin(2.0 * Qw::pi * fMockDriftFrequency[i] * time + fMockDriftPhase[i]);
  //}
 
  // updated to calculate the drift for each block individually
  Double_t drift = 0.0;
  for (Int_t i = 0; i < fBlocksPerEvent; i++){
    drift = 0.0;
    if (i >= 1){
      time += (fNumberOfSamples_map/4.0)*kTimePerSample;
    }
    for (UInt_t i = 0; i < fMockDriftFrequency.size(); i++) {
      drift += fMockDriftAmplitude[i] * sin(2.0 * Qw::pi * fMockDriftFrequency[i] * time + fMockDriftPhase[i]);
      //std::cout << "Drift: " << drift << std::endl;
    }
  }
 
  // Calculate signal
  fHardwareBlockSum = 0.0;
  fHardwareBlockSumM2 = 0.0; // second moment is zero for single events
 
  for (Int_t i = 0; i < fBlocksPerEvent; i++) {
    double tmpvar = GetRandomValue();
    //std::cout << "tmpvar: " << tmpvar << std::endl;
    //std::cout << "->fMockSigma: " << fMockGaussianSigma << std::endl;
 
    fBlock[i] = fMockGaussianMean + drift;
    //std::cout << "(Start of loop)  " << this->GetElementName() << "-> "<< "fBlock[" << i << "]: " << fBlock[i] << ", Drift: " << drift <<", Mean: " << fMockGaussianMean<<  std::endl;
    if (fCalcMockDataAsDiff) {
      fBlock[i] += helicity*fMockAsymmetry;
    } else {
      fBlock[i] *= 1.0 + helicity*fMockAsymmetry;
    }
    fBlock[i] += fMockGaussianSigma*tmpvar*sqrt(fBlocksPerEvent);
    //std::cout << "(End of loop)    " << this->GetElementName() << "-> "<< "fBlock[" << i << "]: " << fBlock[i] << ", Drift: " << drift <<", Mean: " << fMockGaussianMean<<  std::endl;
 
    
/*    
    fBlock[i] = //GetRandomValue();
     fMockGaussianMean * (1 + helicity * fMockAsymmetry) 
      + fMockGaussianSigma*sqrt(fBlocksPerEvent) * tmpvar
      + drift; */
 
    fBlockM2[i] = 0.0; // second moment is zero for single events
    fHardwareBlockSum += fBlock[i];
 
/*        std::cout << "In RandomizeEventData: " << tmpvar << " " << fMockGaussianMean << " "<<  (1 + helicity * fMockAsymmetry) << " "
                  << fMockGaussianSigma << " " << fMockGaussianSigma*tmpvar << " "
                  << drift << " " << block[i] << std::endl; */
  }
  fHardwareBlockSum /= fBlocksPerEvent;
  fSequenceNumber = 0;
  fNumberOfSamples = fNumberOfSamples_map;
  //  SetEventData(block);
  //  delete block;
  return;
}

References fBlock, fBlockM2, fBlocksPerEvent, MQwMockable::fCalcMockDataAsDiff, fHardwareBlockSum, fHardwareBlockSumM2, MQwMockable::fMockAsymmetry, MQwMockable::fMockDriftAmplitude, MQwMockable::fMockDriftFrequency, MQwMockable::fMockDriftPhase, MQwMockable::fMockGaussianMean, MQwMockable::fMockGaussianSigma, fNumberOfSamples, fNumberOfSamples_map, fSequenceNumber, MQwMockable::GetRandomValue(), kTimePerSample, and Qw::pi.

Here is the call graph for this function:

◆ Ratio()

void QwVQWK_Channel::Ratio	(	const QwVQWK_Channel &	numer,
		const QwVQWK_Channel &	denom )

Definition at line 1378 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()) {
    *this  = numer;
    *this /= denom;
 
    // Remaining variables
    fNumberOfSamples      = denom.fNumberOfSamples;
    fSequenceNumber       = 0;
    fGoodEventCount       = denom.fGoodEventCount;
    fErrorFlag            = (numer.fErrorFlag|denom.fErrorFlag);
  }
}

References VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fNumberOfSamples, fSequenceNumber, VQwDataElement::IsNameEmpty(), and QwVQWK_Channel().

Referenced by QwLinearDiodeArray::ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scale()

void QwVQWK_Channel::Scale ( Double_t Offset )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1500 of file QwVQWK_Channel.cc.

{
  if (!IsNameEmpty()){
      for (Int_t i = 0; i < fBlocksPerEvent; i++) {
        fBlock[i] *= scale;
        fBlockM2[i] *= scale * scale;
      }
      fHardwareBlockSum *= scale;
      fHardwareBlockSumM2 *= scale * scale;
    }
}

References fBlock, fBlockM2, fBlocksPerEvent, fHardwareBlockSum, fHardwareBlockSumM2, and VQwDataElement::IsNameEmpty().

Referenced by QwLinearDiodeArray::ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ScaledAdd()

void QwVQWK_Channel::ScaledAdd	(	Double_t	scale,
		const VQwHardwareChannel *	value )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1956 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* input = dynamic_cast<const QwVQWK_Channel*>(value);
  
  // follows same steps as += but w/ scaling factor
  if(input!=NULL && !IsNameEmpty()){
    //     QwWarning << "Adding " << input->GetElementName()
    //               << " to " << GetElementName()
    //               << " with scale factor " << scale
    //               << QwLog::endl;
    //     PrintValue();
    //     input->PrintValue();
    for(Int_t i = 0; i < fBlocksPerEvent; i++){
      this -> fBlock[i] += scale * input->fBlock[i];
      this -> fBlockM2[i] = 0.0;
    }
    this -> fHardwareBlockSum += scale * input->fHardwareBlockSum;
    this -> fHardwareBlockSumM2 = 0.0;
    this -> fNumberOfSamples += input->fNumberOfSamples;
    this -> fSequenceNumber  =  0;
    this -> fErrorFlag       |= (input->fErrorFlag);   
  } else if (input == NULL && value != NULL) {
    TString loc="Standard exception from QwVQWK_Channel::ScaledAdd "
        +value->GetElementName()+" "
        +this->GetElementName()+" are not of the same type";
    throw(std::invalid_argument(loc.Data()));
  }
}

References fBlock, fBlockM2, fBlocksPerEvent, VQwDataElement::fErrorFlag, fHardwareBlockSum, fHardwareBlockSumM2, fNumberOfSamples, fSequenceNumber, VQwDataElement::GetElementName(), VQwDataElement::IsNameEmpty(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ SetCalibrationToVolts()

void QwVQWK_Channel::SetCalibrationToVolts ( )

inline

Definition at line 278 of file QwVQWK_Channel.h.

278{SetCalibrationFactor(kVQWK_VoltsPerBit);};

VQwHardwareChannel::SetCalibrationFactor

void SetCalibrationFactor(Double_t factor)

Definition VQwHardwareChannel.h:241

References kVQWK_VoltsPerBit, and VQwHardwareChannel::SetCalibrationFactor().

Here is the call graph for this function:

◆ SetDefaultSampleSize()

void QwVQWK_Channel::SetDefaultSampleSize ( size_t num_samples_map )

inline

Definition at line 125 of file QwVQWK_Channel.h.

                                                    {
    // This will be checked against the no.of samples read by the module
    fNumberOfSamples_map = num_samples_map;
  };

References fNumberOfSamples_map.

Referenced by LoadChannelParameters().

Here is the caller graph for this function:

◆ SetEventData()

void QwVQWK_Channel::SetEventData	(	Double_t *	block,
		UInt_t	sequencenumber = 0 )

Definition at line 373 of file QwVQWK_Channel.cc.

{
  fHardwareBlockSum = 0.0;
  fHardwareBlockSumM2 = 0.0; // second moment is zero for single events
  for (Int_t i = 0; i < fBlocksPerEvent; i++) {
    fBlock[i] = block[i];
    fBlockM2[i] = 0.0; // second moment is zero for single events
    fHardwareBlockSum += block[i];
  }
  fHardwareBlockSum /= fBlocksPerEvent;
 
  fSequenceNumber = sequencenumber;
  fNumberOfSamples = fNumberOfSamples_map;
 
//  Double_t thispedestal = 0.0;
//  thispedestal = fPedestal * fNumberOfSamples;
 
  SetRawEventData();
  return;
}

References fBlock, fBlockM2, fBlocksPerEvent, fHardwareBlockSum, fHardwareBlockSumM2, fNumberOfSamples, fNumberOfSamples_map, fSequenceNumber, and SetRawEventData().

Referenced by SetHardwareSum().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHardwareSum()

void QwVQWK_Channel::SetHardwareSum	(	Double_t	hwsum,
		UInt_t	sequencenumber = 0 )

TODO: SetHardwareSum should be removed, and SetEventData should be made protected.

Definition at line 357 of file QwVQWK_Channel.cc.

{
  Double_t* block = new Double_t[fBlocksPerEvent];
  for (Int_t i = 0; i < fBlocksPerEvent; i++){
    block[i] = hwsum / fBlocksPerEvent;
  }
  SetEventData(block);
  delete[] block;
  return;
}

References fBlocksPerEvent, and SetEventData().

Here is the call graph for this function:

◆ SetRawEventData()

void QwVQWK_Channel::SetRawEventData ( )

overridevirtual

Implements MQwMockable.

Definition at line 394 of file QwVQWK_Channel.cc.

                                    {
  fNumberOfSamples = fNumberOfSamples_map;
  fHardwareBlockSum_raw = 0;
//  Double_t hwsum_test = 0.0;
//  std::cout <<  "*******In QwVQWK_Channel::SetRawEventData for channel:\t" << this->GetElementName() << std::endl;
  for (Int_t i = 0; i < fBlocksPerEvent; i++) 
    {
     //  The raw data is decoded ino calibrated values with the following (in ProcessEvent()):
     //      fBlock[i] = fCalibrationFactor * ( (1.0 * fBlock_raw[i] * fBlocksPerEvent / fNumberOfSamples) - fPedestal );
     //  We should invert that function here:
/*     if (fBlock[i]<-10.0 || fBlock[i]>+10.0)
        QwError << "In QwVQWK_Channel::SetRawEventData for channel:\t" << this->GetElementName() << ", Block " << i << " is out of range (-10 V,+10V):" << fBlock[i] << QwLog::endl;
*/
     fBlock_raw[i] = Int_t((fBlock[i] / fCalibrationFactor + fPedestal) * fNumberOfSamples / (fBlocksPerEvent * 1.0));
     fHardwareBlockSum_raw += fBlock_raw[i];
     //hwsum_test +=fBlock[i] /(fBlocksPerEvent * 1.0);
 
     
  //   fBlock[i] = fCalibrationFactor * ((1.0 * fBlock_raw[i] * fBlocksPerEvent / fNumberOfSamples) - fPedestal);
  //   fHardwareBlockSum += fBlock[i];
 
  /*    std::cout << "\t fBlock[i] = "                                        << std::setprecision(6) << fBlock[i]                                                                                 << "\n"
               << "\t fCalibrationFactor = "                               << fCalibrationFactor                                                                        << "\n"
               << "\t fPedestal = "                                        << fPedestal                                                                                 << "\n"
               << "\t fNumberOfSamples = "                                 << fNumberOfSamples                                                                          << "\n"
               << "\t fBlocksPerEvent = "                                  << fBlocksPerEvent                                                                           << "\n"
               << "\t fBlock[i] / fCalibrationFactor + fPedestal = "       << fBlock[i] / fCalibrationFactor + fPedestal                                                << "\n"
               << "\t That * fNumberOfSamples / (fBlocksPerEvent * 1) = "  << (fBlock[i] / fCalibrationFactor + fPedestal) * fNumberOfSamples / (fBlocksPerEvent * 1.0) << "\n"
               << "\t fBlock_raw[i] = "                                    << fBlock_raw[i]                                                                             << "\n"
               << "\t fHardwareBlockSum_raw = "                            << fHardwareBlockSum_raw                                                                     << "\n"
               << std::endl;
   */   
    }
 
/*  std::cout << "fBlock[0] = " << std::setprecision(16) << fBlock[0] << std::endl
            << "fBlockraw[0] after calib: " << fCalibrationFactor * ((1.0 * fBlock_raw[0] * fBlocksPerEvent / fNumberOfSamples) - fPedestal) << std::endl;
 
  std::cout << "fHardwareBlockSum = " << std::setprecision(8) << fHardwareBlockSum << std::endl;
  std::cout << "hwsum_test = " << std::setprecision(8) << hwsum_test << std::endl;
  std::cout << "fHardwareBlockSum_raw = " << std::setprecision(8) << fHardwareBlockSum_raw << std::endl;
  std::cout << "fHardwareBlockSum_Raw after calibration = " << fCalibrationFactor * ((1.0 * fHardwareBlockSum_raw / fNumberOfSamples) - fPedestal) << std::endl;
*/
 
  fSoftwareBlockSum_raw = fHardwareBlockSum_raw;
 
  return;
}

References fBlock, fBlock_raw, fBlocksPerEvent, VQwHardwareChannel::fCalibrationFactor, fHardwareBlockSum_raw, fNumberOfSamples, fNumberOfSamples_map, VQwHardwareChannel::fPedestal, and fSoftwareBlockSum_raw.

Referenced by SetEventData().

Here is the caller graph for this function:

◆ SetVQWKSaturationLimt()

void QwVQWK_Channel::SetVQWKSaturationLimt ( Double_t sat_volts = 8.5 )

inline

Definition at line 223 of file QwVQWK_Channel.h.

                                                    {//Set the absolute staturation limit in volts.
    fSaturationABSLimit=sat_volts;
  }

References fSaturationABSLimit.

Referenced by QwVQWK_Channel(), and QwVQWK_Channel().

Here is the caller graph for this function:

◆ SmearByResolution()

void QwVQWK_Channel::SmearByResolution ( double resolution )

overridevirtual

Implements MQwMockable.

Definition at line 337 of file QwVQWK_Channel.cc.

                                                       {
 
  fHardwareBlockSum   = 0.0;
  fHardwareBlockSumM2 = 0.0; // second moment is zero for single events
  for (Int_t i = 0; i < fBlocksPerEvent; i++) {
    // std::cout << i << " " << fBlock[i] << "->";
    //std::cout << "resolution = " << resolution << "\t for channel \t" << GetElementName() << std::endl;
    fBlock[i] += resolution*sqrt(fBlocksPerEvent) * GetRandomValue();
    // std::cout << fBlock[i] << ": ";
    fBlockM2[i] = 0.0; // second moment is zero for single events
    fHardwareBlockSum += fBlock[i];
  }
  // std::cout << std::endl;
  fHardwareBlockSum /= fBlocksPerEvent;
 
  fNumberOfSamples = fNumberOfSamples_map;
  // SetRawEventData();
  return;
}

References fBlock, fBlockM2, fBlocksPerEvent, fHardwareBlockSum, fHardwareBlockSumM2, fNumberOfSamples, fNumberOfSamples_map, and MQwMockable::GetRandomValue().

Here is the call graph for this function:

◆ SubtractValueFrom()

void QwVQWK_Channel::SubtractValueFrom ( const VQwHardwareChannel * valueptr )

overridevirtual

Implements VQwHardwareChannel.

Definition at line 1196 of file QwVQWK_Channel.cc.

{
  const QwVQWK_Channel* tmpptr;
  tmpptr = dynamic_cast<const QwVQWK_Channel*>(valueptr);
  if (tmpptr!=NULL){
    *this -= *tmpptr;
  } else {
    TString loc="Standard exception from QwVQWK_Channel::SubtractValueFrom = "
      +valueptr->GetElementName()+" is an incompatible type.";
    throw std::invalid_argument(loc.Data());
  }
}

References VQwDataElement::GetElementName(), QwVQWK_Channel(), and VQwHardwareChannel::VQwHardwareChannel().

Here is the call graph for this function:

◆ Sum()

void QwVQWK_Channel::Sum	(	const QwVQWK_Channel &	value1,
		const QwVQWK_Channel &	value2 )

Definition at line 1366 of file QwVQWK_Channel.cc.

{
  *this  = value1;
  *this += value2;
}

References QwVQWK_Channel().

Referenced by QwQPD::ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	stream,
		const QwVQWK_Channel &	channel )

friend

Definition at line 1782 of file QwVQWK_Channel.cc.

{
  stream << channel.GetHardwareSum();
  return stream;
}

References GetHardwareSum(), and QwVQWK_Channel().

Field Documentation

◆ bBlock

Bool_t QwVQWK_Channel::bBlock

private

Definition at line 397 of file QwVQWK_Channel.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

◆ bBlock_raw

Bool_t QwVQWK_Channel::bBlock_raw

private

Definition at line 398 of file QwVQWK_Channel.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

◆ bDEBUG

const Bool_t QwVQWK_Channel::bDEBUG =kFALSE

staticprivate

debugging display purposes

For VQWK data element trimming uses

Definition at line 392 of file QwVQWK_Channel.h.

Referenced by ApplyHWChecks(), FillTreeVector(), and MatchNumberOfSamples().

◆ bDevice_Error_Code

Bool_t QwVQWK_Channel::bDevice_Error_Code

private

Definition at line 400 of file QwVQWK_Channel.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

◆ bHw_sum

Bool_t QwVQWK_Channel::bHw_sum

private

Definition at line 395 of file QwVQWK_Channel.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

◆ bHw_sum_raw

Bool_t QwVQWK_Channel::bHw_sum_raw

private

Definition at line 396 of file QwVQWK_Channel.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

◆ bNum_samples

Bool_t QwVQWK_Channel::bNum_samples

private

Definition at line 399 of file QwVQWK_Channel.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

◆ bSequence_number

Bool_t QwVQWK_Channel::bSequence_number

private

Definition at line 401 of file QwVQWK_Channel.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

◆ fADC_Same_NumEvt

Int_t QwVQWK_Channel::fADC_Same_NumEvt

private

Keep track of how many events with same ADC value returned.

Definition at line 382 of file QwVQWK_Channel.h.

Referenced by ApplyHWChecks(), and InitializeChannel().

◆ fBlock

Double_t QwVQWK_Channel::fBlock[4]

private

Array of the sub-block data.

Definition at line 345 of file QwVQWK_Channel.h.

Referenced by AccumulateRunningSum(), AddChannelOffset(), ArcTan(), AssignScaledValue(), Blind(), Blind(), ClearEventData(), GetValue(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), PrintInfo(), ProcessEvent(), Product(), RandomizeEventData(), Scale(), ScaledAdd(), SetEventData(), SetRawEventData(), and SmearByResolution().

◆ fBlock_raw

Int_t QwVQWK_Channel::fBlock_raw[4]

private

Array of the sub-block data as read from the module.

Definition at line 339 of file QwVQWK_Channel.h.

Referenced by ClearEventData(), EncodeEventData(), GetRawValue(), operator=(), PrintInfo(), ProcessEvBuffer(), ProcessEvent(), and SetRawEventData().

◆ fBlockError

Double_t QwVQWK_Channel::fBlockError[4]

private

Uncertainty on the sub-block.

Definition at line 354 of file QwVQWK_Channel.h.

Referenced by CalculateRunningAverage(), ClearEventData(), and GetValueError().

◆ fBlockM2

Double_t QwVQWK_Channel::fBlockM2[4]

private

Second moment of the sub-block.

Definition at line 353 of file QwVQWK_Channel.h.

Referenced by AccumulateRunningSum(), AssignScaledValue(), CalculateRunningAverage(), ClearEventData(), GetValueM2(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), ProcessEvent(), Product(), RandomizeEventData(), Scale(), ScaledAdd(), SetEventData(), and SmearByResolution().

◆ fBlocksPerEvent

Short_t QwVQWK_Channel::fBlocksPerEvent

private

◆ fErrorCount_HWSat

Int_t QwVQWK_Channel::fErrorCount_HWSat

private

check to see ADC channel is saturated

Definition at line 368 of file QwVQWK_Channel.h.

Referenced by IncrementErrorCounters(), InitializeChannel(), and PrintErrorCounters().

◆ fErrorCount_SameHW

Int_t QwVQWK_Channel::fErrorCount_SameHW

private

check to see ADC returning same HW value

Definition at line 372 of file QwVQWK_Channel.h.

Referenced by IncrementErrorCounters(), InitializeChannel(), and PrintErrorCounters().

◆ fErrorCount_sample

Int_t QwVQWK_Channel::fErrorCount_sample

private

for sample size check

Definition at line 369 of file QwVQWK_Channel.h.

Referenced by IncrementErrorCounters(), InitializeChannel(), and PrintErrorCounters().

◆ fErrorCount_Sequence

Int_t QwVQWK_Channel::fErrorCount_Sequence

private

sequence number check

Definition at line 371 of file QwVQWK_Channel.h.

Referenced by IncrementErrorCounters(), InitializeChannel(), and PrintErrorCounters().

◆ fErrorCount_SW_HW

Int_t QwVQWK_Channel::fErrorCount_SW_HW

private

HW_sum==SW_sum check.

Definition at line 370 of file QwVQWK_Channel.h.

Referenced by IncrementErrorCounters(), InitializeChannel(), and PrintErrorCounters().

◆ fErrorCount_ZeroHW

Int_t QwVQWK_Channel::fErrorCount_ZeroHW

private

check to see ADC returning zero

Definition at line 373 of file QwVQWK_Channel.h.

Referenced by IncrementErrorCounters(), InitializeChannel(), and PrintErrorCounters().

◆ fHardwareBlockSum

Double_t QwVQWK_Channel::fHardwareBlockSum

private

Module-based sum of the four sub-blocks.

Definition at line 346 of file QwVQWK_Channel.h.

Referenced by AccumulateRunningSum(), AddChannelOffset(), ArcTan(), AssignScaledValue(), Blind(), Blind(), ClearEventData(), ConstructBranch(), GetAverageVolts(), GetValue(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), PrintInfo(), ProcessEvent(), Product(), RandomizeEventData(), Scale(), ScaledAdd(), SetEventData(), and SmearByResolution().

◆ fHardwareBlockSum_raw

Int_t QwVQWK_Channel::fHardwareBlockSum_raw

private

Module-based sum of the four sub-blocks as read from the module.

Definition at line 340 of file QwVQWK_Channel.h.

Referenced by ClearEventData(), EncodeEventData(), GetRawValue(), operator=(), PrintInfo(), ProcessEvBuffer(), ProcessEvent(), and SetRawEventData().

◆ fHardwareBlockSumError

Double_t QwVQWK_Channel::fHardwareBlockSumError

private

Uncertainty on the hardware sum.

Definition at line 357 of file QwVQWK_Channel.h.

Referenced by AssignScaledValue(), CalculateRunningAverage(), ClearEventData(), GetValueError(), operator=(), and PrintInfo().

◆ fHardwareBlockSumM2

Double_t QwVQWK_Channel::fHardwareBlockSumM2

private

Second moment of the hardware sum.

Definition at line 356 of file QwVQWK_Channel.h.

Referenced by AccumulateRunningSum(), AssignScaledValue(), CalculateRunningAverage(), ClearEventData(), GetValueM2(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), PrintInfo(), ProcessEvent(), Product(), RandomizeEventData(), Scale(), ScaledAdd(), SetEventData(), and SmearByResolution().

◆ fNumberOfSamples

UInt_t QwVQWK_Channel::fNumberOfSamples

private

Number of samples read through the module.

Definition at line 363 of file QwVQWK_Channel.h.

Referenced by ApplyHWChecks(), AssignScaledValue(), ClearEventData(), EncodeEventData(), FillTreeVector(), ForceMapfileSampleSize(), GetAverageVolts(), GetNumberOfSamples(), InitializeChannel(), MatchNumberOfSamples(), operator*=(), operator+=(), operator-=(), operator=(), PrintInfo(), ProcessEvBuffer(), ProcessEvent(), Product(), RandomizeEventData(), Ratio(), ScaledAdd(), SetEventData(), SetRawEventData(), and SmearByResolution().

◆ fNumberOfSamples_map

UInt_t QwVQWK_Channel::fNumberOfSamples_map

private

Number of samples in the expected to read through the module. This value is set in the QwBeamline map file.

Definition at line 364 of file QwVQWK_Channel.h.

Referenced by ApplyHWChecks(), CopyFrom(), ForceMapfileSampleSize(), InitializeChannel(), QwVQWK_Channel(), QwVQWK_Channel(), RandomizeEventData(), SetDefaultSampleSize(), SetEventData(), SetRawEventData(), and SmearByResolution().

◆ fNumEvtsWithEventCutsRejected

Int_t QwVQWK_Channel::fNumEvtsWithEventCutsRejected

private

Counts the Event cut rejected events.

Definition at line 375 of file QwVQWK_Channel.h.

Referenced by IncrementErrorCounters(), InitializeChannel(), and PrintErrorCounters().

◆ fPrev_HardwareBlockSum

Double_t QwVQWK_Channel::fPrev_HardwareBlockSum

private

Previous Module-based sum of the four sub-blocks.

Definition at line 385 of file QwVQWK_Channel.h.

Referenced by ApplyHWChecks(), and InitializeChannel().

◆ fPreviousSequenceNumber

UInt_t QwVQWK_Channel::fPreviousSequenceNumber

private

Previous event sequence number for this channel.

Definition at line 362 of file QwVQWK_Channel.h.

Referenced by InitializeChannel().

◆ fSaturationABSLimit

Double_t QwVQWK_Channel::fSaturationABSLimit

private

absolute value of the VQWK saturation volt

Definition at line 389 of file QwVQWK_Channel.h.

Referenced by CopyFrom(), GetVQWKSaturationLimt(), QwVQWK_Channel(), QwVQWK_Channel(), and SetVQWKSaturationLimt().

◆ fSequenceNo_Counter

Int_t QwVQWK_Channel::fSequenceNo_Counter

private

Internal counter to keep track of the sequence number.

Definition at line 384 of file QwVQWK_Channel.h.

Referenced by ApplyHWChecks(), and InitializeChannel().

◆ fSequenceNo_Prev

Int_t QwVQWK_Channel::fSequenceNo_Prev

private

Keep the sequence number of the last event.

Definition at line 383 of file QwVQWK_Channel.h.

Referenced by ApplyHWChecks(), and InitializeChannel().

◆ fSequenceNumber

UInt_t QwVQWK_Channel::fSequenceNumber

private

Event sequence number for this channel.

Definition at line 361 of file QwVQWK_Channel.h.

Referenced by AssignScaledValue(), ClearEventData(), EncodeEventData(), FillTreeVector(), GetSequenceNumber(), MatchSequenceNumber(), operator*=(), operator+=(), operator-=(), operator=(), PrintInfo(), ProcessEvBuffer(), Product(), RandomizeEventData(), Ratio(), ScaledAdd(), and SetEventData().

◆ fSoftwareBlockSum_raw

Int_t QwVQWK_Channel::fSoftwareBlockSum_raw

private

Sum of the data in the four sub-blocks raw.

Definition at line 341 of file QwVQWK_Channel.h.

Referenced by ClearEventData(), GetRawSoftwareSum(), operator=(), PrintInfo(), ProcessEvBuffer(), and SetRawEventData().

◆ kDEBUG

const Bool_t QwVQWK_Channel::kDEBUG = kFALSE

staticprivate

Definition at line 317 of file QwVQWK_Channel.h.

Referenced by ConstructBranch(), and ConstructBranchAndVector().

◆ kMaxChannels

const Int_t QwVQWK_Channel::kMaxChannels = 8

staticprivate

Definition at line 319 of file QwVQWK_Channel.h.

Referenced by GetBufferOffset().

◆ kTimePerSample

const Double_t QwVQWK_Channel::kTimePerSample = (2.0/30.0) * Qw::us

static

Definition at line 62 of file QwVQWK_Channel.h.

Referenced by RandomizeEventData().

◆ kVQWK_VoltsPerBit

const Double_t QwVQWK_Channel::kVQWK_VoltsPerBit = (20./(1<<18))

staticprivate

Conversion factor to translate the average bit count in an ADC channel into average voltage. The base factor is roughly 76 uV per count, and zero counts corresponds to zero voltage. Store as the exact value for 20 V range, 18 bit ADC.

Definition at line 323 of file QwVQWK_Channel.h.

Referenced by ApplyHWChecks(), GetAverageVolts(), and SetCalibrationToVolts().

◆ kWordsPerChannel

const Int_t QwVQWK_Channel::kWordsPerChannel = 6

staticprivate

Definition at line 318 of file QwVQWK_Channel.h.

Referenced by GetBufferOffset(), and ProcessEvBuffer().

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Calculation of the statistical moments

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ QwVQWK_Channel() [1/4]

◆ QwVQWK_Channel() [2/4]

◆ QwVQWK_Channel() [3/4]

◆ QwVQWK_Channel() [4/4]

◆ ~QwVQWK_Channel()

Member Function Documentation

◆ AccumulateRunningSum() [1/2]

◆ AccumulateRunningSum() [2/2]

◆ AddChannelOffset()

◆ AddValueFrom()

◆ ApplyHWChecks()

◆ ApplySingleEventCuts() [1/2]

◆ ApplySingleEventCuts() [2/2]

◆ ArcTan()

◆ AssignScaledValue()

◆ AssignValueFrom()

◆ Blind() [1/2]

◆ Blind() [2/2]

◆ CalculateRunningAverage()

◆ ClearEventData()

◆ Clone() [1/2]

◆ Clone() [2/2]

◆ ConstructBranch()

◆ ConstructBranchAndVector()

◆ ConstructHistograms()

◆ CopyFrom()

◆ DeaccumulateRunningSum() [1/2]

◆ DeaccumulateRunningSum() [2/2]

◆ Difference()

◆ DivideBy() [1/2]

◆ DivideBy() [2/2]

◆ EncodeEventData()

◆ FillHistograms()

◆ FillTreeVector()

◆ ForceMapfileSampleSize()

◆ GetAverageVolts()

◆ GetBlockErrorValue()

◆ GetBlockValue()

◆ GetBufferOffset()

◆ GetHardwareSum()

◆ GetHardwareSumError()

◆ GetHardwareSumM2()

◆ GetHardwareSumWidth()

◆ GetNumberOfSamples()

◆ GetRawBlockValue()

◆ GetRawHardwareSum()

◆ GetRawSoftwareSum()

◆ GetRawValue() [1/2]

◆ GetRawValue() [2/2]

◆ GetSequenceNumber()

◆ GetValue() [1/2]

◆ GetValue() [2/2]

◆ GetValueError() [1/2]

◆ GetValueError() [2/2]

◆ GetValueM2() [1/2]

◆ GetValueM2() [2/2]

◆ GetValueWidth() [1/2]

◆ GetValueWidth() [2/2]

◆ GetVQWKSaturationLimt()

◆ IncrementErrorCounters()

◆ InitializeChannel() [1/2]

◆ InitializeChannel() [2/2]

◆ LoadChannelParameters()

◆ LoadMockDataParameters()

◆ MatchNumberOfSamples()

◆ MatchSequenceNumber()

◆ MultiplyBy()

◆ operator*()