JAPAn
Just Another Parity Analyzer
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes
VQwScaler_Channel Class Referenceabstract
ADC channels and digitizers

Abstract base class for scaler channels. More...

#include <QwScaler_Channel.h>

+ Inheritance diagram for VQwScaler_Channel:
+ Collaboration diagram for VQwScaler_Channel:

Public Member Functions

 VQwScaler_Channel ()
 
 VQwScaler_Channel (TString name, TString datatosave="raw")
 
 VQwScaler_Channel (const VQwScaler_Channel &source)
 
 VQwScaler_Channel (const VQwScaler_Channel &source, VQwDataElement::EDataToSave datatosave)
 
 ~VQwScaler_Channel () override
 
void CopyFrom (const VQwScaler_Channel &value)
 
void InitializeChannel (TString name, TString datatosave="raw") 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 SetDefaultSampleSize (size_t)
 
void LoadChannelParameters (QwParameterFile &paramfile) override
 
void ClearEventData () override
 Clear the event data in this element.
 
void RandomizeEventData (int helicity=0, double time=0.0) override
 Internally generate random event data.
 
void SetEventData (Double_t value)
 
void SetRawEventData () override
 
void EncodeEventData (std::vector< UInt_t > &buffer) override=0
 Encode the event data into a CODA buffer.
 
Int_t ProcessEvBuffer (UInt_t *buffer, UInt_t num_words_left, UInt_t index=0) override=0
 Process the CODA event buffer for this element.
 
void SmearByResolution (double resolution) override
 
void ProcessEvent () override
 
Int_t GetRawValue (size_t) const override
 
Double_t GetValue (size_t) const override
 
Double_t GetValueM2 (size_t) const override
 
Double_t GetValueError (size_t) const override
 
VQwScaler_Channel & operator= (const VQwScaler_Channel &value)
 
void AssignScaledValue (const VQwScaler_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
 
VQwScaler_Channel & operator+= (const VQwScaler_Channel &value)
 
VQwScaler_Channel & operator-= (const VQwScaler_Channel &value)
 
VQwScaler_Channel & operator*= (const VQwScaler_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
 
void Sum (VQwScaler_Channel &value1, VQwScaler_Channel &value2)
 
void Difference (VQwScaler_Channel &value1, VQwScaler_Channel &value2)
 
void Ratio (const VQwScaler_Channel &numer, const VQwScaler_Channel &denom)
 
void Product (VQwScaler_Channel &numer, VQwScaler_Channel &denom)
 
void AddChannelOffset (Double_t Offset)
 
void Scale (Double_t Offset) override
 
void DivideBy (const VQwScaler_Channel &denom)
 
Int_t ApplyHWChecks () override
 
Bool_t ApplySingleEventCuts () override
 
Bool_t CheckForBurpFail (const VQwDataElement *)
 
void IncrementErrorCounters () override
 
void PrintErrorCounters () const override
 report number of events failed due to HW and event cut failure
 
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=0
 
void FillTreeVector (QwRootTreeBranchVector &values) const override=0
 
void ConstructBranch (TTree *tree, TString &prefix) override
 
void AccumulateRunningSum (const VQwScaler_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 VQwScaler_Channel &value, Int_t ErrorMask)
 
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 CalculateRunningAverage () override
 
Bool_t NeedsExternalClock () override
 
void SetNeedsExternalClock (Bool_t needed) override
 
std::string GetExternalClockName () override
 
void SetExternalClockPtr (const VQwHardwareChannel *clock) override
 
void SetExternalClockName (const std::string name) override
 
virtual Bool_t IsDifferentialScaler ()
 
virtual void SetDifferentialScaler (Bool_t diff)
 
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)
 
- 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 ()
 
virtual VQwHardwareChannel * Clone () const
 
virtual VQwHardwareChannel * Clone (VQwDataElement::EDataToSave datatosave) const =0
 
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 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 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 scalerindex, Int_t wordindex, UInt_t header=1)
 
static void PrintErrorCounterHead ()
 
static void PrintErrorCounterTail ()
 
static void SetBurpHoldoff (Int_t holdoff)
 

Protected Member Functions

VQwScaler_Channel & operator/= (const VQwScaler_Channel &)
 
- 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.
 

Protected Attributes

UInt_t fHeader
 
UInt_t fValue_Raw_Old
 
UInt_t fValue_Raw
 
Double_t fValue
 
Double_t fValueM2
 
Double_t fValueError
 
const VQwHardwareChannel * fNormChannelPtr
 
Double_t fClockNormalization
 
std::string fNormChannelName
 
Bool_t fNeedsExternalClock
 
Bool_t fIsDifferentialScaler
 
Int_t fNumEvtsWithHWErrors
 
Int_t fNumEvtsWithEventCutsRejected
 
- 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 Protected Attributes

static const Bool_t kDEBUG = kFALSE
 
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.
 

Additional Inherited Members

- Public Types inherited from VQwDataElement
enum  EDataToSave { kRaw = 0 , kDerived , kMoments }
 

Detailed Description

Abstract base class for scaler channels.

Provides common infrastructure for scaler-based hardware channels, including differential scaler support, external clock normalization, and mock data generation. Concrete implementations handle the hardware-specific details of scaler decoding.

Definition at line 34 of file QwScaler_Channel.h.

Constructor & Destructor Documentation

◆ VQwScaler_Channel() [1/4]

VQwScaler_Channel::VQwScaler_Channel ( )
inline

Definition at line 53 of file QwScaler_Channel.h.

53 : MQwMockable() {
54 InitializeChannel("","");
55 }
VQwScaler_Channel::InitializeChannel
void InitializeChannel(TString name, TString datatosave="raw") override
Initialize the fields in this object.
Definition QwScaler_Channel.cc:22

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

Referenced by AccumulateRunningSum(), AccumulateRunningSum(), AddValueFrom(), AssignScaledValue(), AssignValueFrom(), CopyFrom(), DeaccumulateRunningSum(), Difference(), DivideBy(), DivideBy(), FillTreeVector(), MultiplyBy(), operator*=(), operator*=(), operator+=(), operator+=(), operator-=(), operator-=(), operator/=(), operator/=(), operator=(), Product(), QwScaler_Channel< data_mask, data_shift >::QwScaler_Channel(), QwScaler_Channel< data_mask, data_shift >::QwScaler_Channel(), QwScaler_Channel< data_mask, data_shift >::QwScaler_Channel(), QwScaler_Channel< data_mask, data_shift >::QwScaler_Channel(), Ratio(), ScaledAdd(), SubtractValueFrom(), Sum(), VQwScaler_Channel(), and VQwScaler_Channel().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ VQwScaler_Channel() [2/4]

VQwScaler_Channel::VQwScaler_Channel ( TString name,
TString datatosave = "raw" )
inline

Definition at line 57 of file QwScaler_Channel.h.

57 : MQwMockable() {
58 InitializeChannel(name,datatosave);
59 };

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

+ Here is the call graph for this function:

◆ VQwScaler_Channel() [3/4]

VQwScaler_Channel::VQwScaler_Channel ( const VQwScaler_Channel & source)
inline

Definition at line 60 of file QwScaler_Channel.h.

61 : VQwHardwareChannel(source),MQwMockable(source),
62 fValue_Raw_Old(source.fValue_Raw_Old),
63 fValue_Raw(source.fValue_Raw),
64 fValue(source.fValue),
65 fValueM2(source.fValueM2),
66 fValueError(source.fValueError),
67 // TODO: Don't copy the pointer; we need to regenerate it somehow.
68 //fNormChannelPtr(source.fNormChannelPtr);
69 fClockNormalization(source.fClockNormalization),
70 fNormChannelName(source.fNormChannelName),
71 fNeedsExternalClock(source.fNeedsExternalClock),
72 fIsDifferentialScaler(source.fIsDifferentialScaler)
73 { }
VQwScaler_Channel::fNormChannelName
std::string fNormChannelName
Definition QwScaler_Channel.h:245

References fClockNormalization, fIsDifferentialScaler, fNeedsExternalClock, fNormChannelName, fValue, fValue_Raw, fValue_Raw_Old, fValueError, fValueM2, MQwMockable::MQwMockable(), VQwHardwareChannel::VQwHardwareChannel(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ VQwScaler_Channel() [4/4]

VQwScaler_Channel::VQwScaler_Channel ( const VQwScaler_Channel & source,
VQwDataElement::EDataToSave datatosave )
inline

Definition at line 74 of file QwScaler_Channel.h.

75 : VQwHardwareChannel(source,datatosave),MQwMockable(source),
76 fValue_Raw_Old(source.fValue_Raw_Old),
77 fValue_Raw(source.fValue_Raw),
78 fValue(source.fValue),
79 fValueM2(source.fValueM2),
80 fValueError(source.fValueError),
81 // TODO: Don't copy the pointer; we need to regenerate it somehow.
82 //fNormChannelPtr(source.fNormChannelPtr);
83 fClockNormalization(source.fClockNormalization),
84 fNormChannelName(source.fNormChannelName),
85 fNeedsExternalClock(source.fNeedsExternalClock),
86 fIsDifferentialScaler(source.fIsDifferentialScaler)
87 { }

References fClockNormalization, fIsDifferentialScaler, fNeedsExternalClock, fNormChannelName, fValue, fValue_Raw, fValue_Raw_Old, fValueError, fValueM2, MQwMockable::MQwMockable(), VQwHardwareChannel::VQwHardwareChannel(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ ~VQwScaler_Channel()

VQwScaler_Channel::~VQwScaler_Channel ( )
inlineoverride

Definition at line 88 of file QwScaler_Channel.h.

88{ };

Member Function Documentation

◆ AccumulateRunningSum() [1/2]

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

Reimplemented from VQwHardwareChannel.

Definition at line 201 of file QwScaler_Channel.h.

201 {
202 const VQwScaler_Channel *tmp_ptr = dynamic_cast<const VQwScaler_Channel*>(value);
203 if (tmp_ptr != NULL) {
204 AccumulateRunningSum(*tmp_ptr, count, ErrorMask);
205 } else {
206 throw std::invalid_argument("Standard exception from VQwScaler_Channel::AccumulateRunningSum: incompatible hardware channel type");
207 }
208 };
VQwScaler_Channel::AccumulateRunningSum
void AccumulateRunningSum(const VQwScaler_Channel &value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF)
Definition QwScaler_Channel.cc:786

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

+ Here is the call graph for this function:

◆ AccumulateRunningSum() [2/2]

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

Definition at line 786 of file QwScaler_Channel.cc.

787{
788
789 if(count==0){
790 count = value.fGoodEventCount;
791 }
792
793 // Moment calculations
794 Int_t n1 = fGoodEventCount;
795 Int_t n2 = count;
796
797 // If there are no good events, check whether device HW is good
798 if (n2 == 0 && value.fErrorFlag == 0) {
799 n2 = 1;
800 }
801
802 // If a single event is removed from the sum, check all but stability fail flags
803 if (n2 == -1) {
804 if ((value.fErrorFlag & ErrorMask) == 0) {
805 n2 = -1;
806 } else {
807 n2 = 0;
808 }
809 }
810
811 if (ErrorMask == kPreserveError){
812 //n = 1;
813 if (n2 == 0) {
814 n2 = 1;
815 }
816 if (count == -1) {
817 n2 = -1;
818 }
819 }
820
821 // New total number of good events
822 Int_t n = n1 + n2;
823
824 // Set up variables
825 Double_t M11 = fValue;
826 Double_t M12 = value.fValue;
827 Double_t M22 = value.fValueM2;
828 if (n2 == 0) {
829 // no good events for addition
830 return;
831 } else if (n2 == -1) {
832 // simple version for removal of single event from the sum
833 fGoodEventCount--;
834 if (n > 1) {
835 fValue -= (M12 - M11) / n;
836 fValueM2 -= (M12 - M11)
837 * (M12 - fValue); // note: using updated mean
838 } else if (n == 1) {
839 fValue -= (M12 - M11) / n;
840 fValueM2 -= (M12 - M11)
841 * (M12 - fValue); // note: using updated mean
842 if (fabs(fValueM2) < 10.*std::numeric_limits<double>::epsilon())
843 fValueM2 = 0; // rounding
844 } else if (n == 0) {
845 fValue -= M12;
846 fValueM2 -= M22;
847 if (fabs(fValue) < 10.*std::numeric_limits<double>::epsilon())
848 fValue = 0; // rounding
849 if (fabs(fValueM2) < 10.*std::numeric_limits<double>::epsilon())
850 fValueM2 = 0; // rounding
851 } else {
852 QwWarning << "Running sum has deaccumulated to negative good events." << QwLog::endl;
853 }
854 } else if (n2 == 1) {
855 // simple version for addition of single event
856 fGoodEventCount++;
857 fValue += (M12 - M11) / n;
858 fValueM2 += (M12 - M11) * (M12 - fValue); // note: using updated mean
859 } else if (n2 > 1) {
860 // general version for addition of multi-event sets
861 fGoodEventCount += n2;
862 fValue += n2 * (M12 - M11) / n;
863 fValueM2 += M22 + n1 * n2 * (M12 - M11) * (M12 - M11) / n;
864 }
865
866 // Nanny
867 if (fValue != fValue)
868 QwWarning << "Angry Nanny: NaN detected in " << GetElementName() << QwLog::endl;
869}
QwWarning
#define QwWarning
Predefined log drain for warnings.
Definition QwLog.h:44
kPreserveError
static const UInt_t kPreserveError
Definition QwTypes.h:186
QwLog::endl
static std::ostream & endl(std::ostream &)
End of the line.
Definition QwLog.cc:297
VQwDataElement::fGoodEventCount
UInt_t fGoodEventCount
Number of good events accumulated in this element.
Definition VQwDataElement.h:260
VQwDataElement::GetElementName
virtual const TString & GetElementName() const
Get the name of this element.
Definition VQwDataElement.h:128
VQwDataElement::fErrorFlag
UInt_t fErrorFlag
This the standard error code generated for the channel that contains the global/local/stability flags...
Definition VQwDataElement.h:271

References QwLog::endl(), VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fValue, fValueM2, VQwDataElement::GetElementName(), kPreserveError, QwWarning, and VQwScaler_Channel().

Referenced by AccumulateRunningSum(), and DeaccumulateRunningSum().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ AddChannelOffset()

void VQwScaler_Channel::AddChannelOffset ( Double_t Offset)

Definition at line 695 of file QwScaler_Channel.cc.

696{
697 if (!IsNameEmpty())
698 {
699 fValue += offset;
700 }
701}
VQwDataElement::IsNameEmpty
Bool_t IsNameEmpty() const
Is the name of this element empty?
Definition VQwDataElement.h:124

References fValue, and VQwDataElement::IsNameEmpty().

+ Here is the call graph for this function:

◆ AddValueFrom()

void VQwScaler_Channel::AddValueFrom ( const VQwHardwareChannel * valueptr)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 447 of file QwScaler_Channel.cc.

448{
449 const VQwScaler_Channel* tmpptr;
450 tmpptr = dynamic_cast<const VQwScaler_Channel*>(valueptr);
451 if (tmpptr!=NULL){
452 *this += *tmpptr;
453 } else {
454 TString loc="Standard exception from VQwScaler_Channel::AddValueFrom = "
455 +valueptr->GetElementName()+" is an incompatible type.";
456 throw std::invalid_argument(loc.Data());
457 }
458}

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

+ Here is the call graph for this function:

◆ ApplyHWChecks()

Int_t VQwScaler_Channel::ApplyHWChecks ( )
overridevirtual

Implements VQwHardwareChannel.

Definition at line 719 of file QwScaler_Channel.cc.

719 {
720 // fErrorFlag=0;
721 if (bEVENTCUTMODE>0){//Global switch to ON/OFF event cuts set at the event cut file
722 //check for the hw_sum is zero
723 if (GetRawValue()==0){
724 fErrorFlag|=kErrorFlag_ZeroHW;
725 }
726 }
727 return fErrorFlag;
728}
kErrorFlag_ZeroHW
static const UInt_t kErrorFlag_ZeroHW
Definition QwTypes.h:164
VQwScaler_Channel::GetRawValue
Int_t GetRawValue() const
Definition VQwHardwareChannel.h:125

References VQwHardwareChannel::bEVENTCUTMODE, VQwDataElement::fErrorFlag, GetRawValue(), and kErrorFlag_ZeroHW.

+ Here is the call graph for this function:

◆ ApplySingleEventCuts()

Bool_t VQwScaler_Channel::ApplySingleEventCuts ( )
overridevirtual

Implements VQwHardwareChannel.

Definition at line 732 of file QwScaler_Channel.cc.

733{
734 //std::cout << "Here in VQwScaler_Channel: "<< std::endl;
735 Bool_t status;
736 //QwError<<" Single Event Check ! "<<QwLog::endl;
737 if (bEVENTCUTMODE>=2){//Global switch to ON/OFF event cuts set at the event cut file
738 //std::cout << "Upper : " << fULimit << " , Lower: " << fLLimit << std::endl;
739 if (fULimit < fLLimit){
740 // std::cout << "First" << std::endl;
741 status=kTRUE;
742 } else if (GetValue()<=fULimit && GetValue()>=fLLimit){
743 //std::cout << "Second" << std::endl;
744 //QwError<<" Single Event Cut passed "<<GetElementName()<<" "<<GetValue()<<QwLog::endl;
745 if (fErrorFlag !=0)
746 status=kFALSE;
747 else
748 status=kTRUE;
749 }
750 else{
751 //std::cout << "Third" << std::endl;
752 //QwError<<" Single Event Cut Failed "<<GetElementName()<<" "<<GetValue()<<QwLog::endl;
753 if (GetValue()> fULimit)
754 fErrorFlag|=kErrorFlag_EventCut_U;
755 else
756 fErrorFlag|=kErrorFlag_EventCut_L;
757 status=kFALSE;
758 }
759
760 if (bEVENTCUTMODE==3){
761 status=kTRUE; //Update the event cut fail flag but pass the event.
762 }
763
764 }
765 else{
766 status=kTRUE;
767 fErrorFlag=0;
768 }
769
770
771 return status;
772}
kErrorFlag_EventCut_L
static const UInt_t kErrorFlag_EventCut_L
Definition QwTypes.h:165
kErrorFlag_EventCut_U
static const UInt_t kErrorFlag_EventCut_U
Definition QwTypes.h:166
VQwScaler_Channel::GetValue
Double_t GetValue() const
Definition VQwHardwareChannel.h:126

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

+ Here is the call graph for this function:

◆ AssignScaledValue()

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

Definition at line 511 of file QwScaler_Channel.cc.

513{
514 if (!IsNameEmpty()) {
515 this->fValue = value.fValue * scale;
516 this->fValueError = value.fValueError;
517 this->fValueM2 = value.fValueM2 * scale * scale;
518 this->fErrorFlag = value.fErrorFlag;//error code is updated.
519 this->fGoodEventCount = value.fGoodEventCount;
520 }
521 return;
522}

References VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fValue, fValueError, fValueM2, VQwDataElement::IsNameEmpty(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ AssignValueFrom()

void VQwScaler_Channel::AssignValueFrom ( const VQwDataElement * valueptr)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 436 of file QwScaler_Channel.cc.

436 {
437 const VQwScaler_Channel* tmpptr;
438 tmpptr = dynamic_cast<const VQwScaler_Channel*>(valueptr);
439 if (tmpptr!=NULL){
440 *this = *tmpptr;
441 } else {
442 TString loc="Standard exception from VQwScaler_Channel::AssignValueFrom = "
443 +valueptr->GetElementName()+" is an incompatible type.";
444 throw std::invalid_argument(loc.Data());
445 }
446}

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

+ Here is the call graph for this function:

◆ CalculateRunningAverage()

void VQwScaler_Channel::CalculateRunningAverage ( )
overridevirtual

Implements VQwHardwareChannel.

Definition at line 871 of file QwScaler_Channel.cc.

872{
873 // See notes in QwVQWK_Channel; we are using:
874 // error = sqrt(M2)/n,
875 // or alternately we could use the unbiased estimator for both
876 // the sigma and error on the mean:
877 // error = sqrt(M2)/(n-1)
878 if(fGoodEventCount > 0) {
879 fValueError = sqrt(fValueM2) / fGoodEventCount;
880 } else {
881 fValueError = 0.0;
882 }
883
884}

References VQwDataElement::fGoodEventCount, fValueError, and fValueM2.

◆ CheckForBurpFail()

Bool_t VQwScaler_Channel::CheckForBurpFail ( const VQwDataElement * )
inline

Definition at line 177 of file QwScaler_Channel.h.

177{return kFALSE;};

References VQwDataElement::VQwDataElement().

+ Here is the call graph for this function:

◆ ClearEventData()

void VQwScaler_Channel::ClearEventData ( )
overridevirtual

Clear the event data in this element.

Reimplemented from VQwHardwareChannel.

Definition at line 67 of file QwScaler_Channel.cc.

68{
69 fHeader = 0;
70 fValue_Raw = 0;
71 fValue = 0.0;
72 fValueM2 = 0.0;
73 fValueError = 0.0;
74
75 fGoodEventCount = 0;
76 fErrorFlag = 0;
77}

References VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fHeader, fValue, fValue_Raw, fValueError, and fValueM2.

◆ ConstructBranch()

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

Implements VQwHardwareChannel.

Definition at line 293 of file QwScaler_Channel.cc.

294{
295 if (IsNameEmpty()){
296 // This channel is not used, so skip setting up the tree.
297 } else {
298 TString basename = prefix + GetElementName();
299
300 tree->Branch(basename, &fValue, basename+"/D");
301 }
302}

References fValue, VQwDataElement::GetElementName(), and VQwDataElement::IsNameEmpty().

+ Here is the call graph for this function:

◆ ConstructBranchAndVector()

void VQwScaler_Channel::ConstructBranchAndVector ( TTree * tree,
TString & prefix,
QwRootTreeBranchVector & values )
overridepure virtual

Implements VQwHardwareChannel.

Implemented in QwScaler_Channel< data_mask, data_shift >, and QwScaler_Channel< 0x00ffffff, 0 >.

◆ ConstructHistograms()

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

Construct the histograms for this data element.

Implements VQwDataElement.

Definition at line 231 of file QwScaler_Channel.cc.

231 {
232 // If we have defined a subdirectory in the ROOT file, then change into it.
233 if (folder != NULL) folder->cd();
234
235 if (GetElementName()==""){
236 // This channel is not used, so skip filling the histograms.
237 } else {
238 // Now create the histograms.
239 TString basename = prefix + GetElementName();
240
241 fHistograms.resize(1, NULL);
242 size_t index=0;
243 fHistograms[index] = gQwHists.Construct1DHist(basename);
244 index += 1;
245 }
246}
gQwHists
QwHistogramHelper gQwHists
Globally defined instance of the QwHistogramHelper class.
Definition QwHistogramHelper.cc:18
MQwHistograms::fHistograms
std::vector< TH1_ptr > fHistograms
Histograms associated with this data element.
Definition MQwHistograms.h:62
QwHistogramHelper::Construct1DHist
TH1F * Construct1DHist(const TString &inputfile, const TString &name_title)
Definition QwHistogramHelper.h:48

References MQwHistograms::fHistograms, VQwDataElement::GetElementName(), and gQwHists.

+ Here is the call graph for this function:

◆ CopyFrom()

void VQwScaler_Channel::CopyFrom ( const VQwScaler_Channel & value)
inline

Definition at line 90 of file QwScaler_Channel.h.

90 {
91 VQwHardwareChannel::CopyFrom(value);
92 fValue_Raw_Old = value.fValue_Raw_Old;
93 fValue_Raw = value.fValue_Raw;
94 fValue = value.fValue;
95 fValueM2 = value.fValueM2;
96 fValueError = value.fValueError;
97 fClockNormalization = value.fClockNormalization;
98 fNormChannelName = value.fNormChannelName;
99 fNeedsExternalClock = value.fNeedsExternalClock;
100 fIsDifferentialScaler = value.fIsDifferentialScaler;
101 };
VQwHardwareChannel::CopyFrom
void CopyFrom(const VQwHardwareChannel &value)
Definition VQwHardwareChannel.cc:78

References VQwHardwareChannel::CopyFrom(), fClockNormalization, fIsDifferentialScaler, fNeedsExternalClock, fNormChannelName, fValue, fValue_Raw, fValue_Raw_Old, fValueError, fValueM2, and VQwScaler_Channel().

Referenced by QwScaler_Channel< 0x00ffffff, 0 >::CopyFrom().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ DeaccumulateRunningSum() [1/2]

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

Reimplemented from VQwHardwareChannel.

Definition at line 255 of file VQwHardwareChannel.h.

255 {
256 AccumulateRunningSum(value, -1, ErrorMask);
257 };

◆ DeaccumulateRunningSum() [2/2]

void VQwScaler_Channel::DeaccumulateRunningSum ( const VQwScaler_Channel & value,
Int_t ErrorMask )
inline

Definition at line 209 of file QwScaler_Channel.h.

209 {
210 AccumulateRunningSum(value, -1, ErrorMask);
211 };

References AccumulateRunningSum(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ Difference()

void VQwScaler_Channel::Difference ( VQwScaler_Channel & value1,
VQwScaler_Channel & value2 )

Definition at line 620 of file QwScaler_Channel.cc.

620 {
621 *this = value1;
622 *this -= value2;
623}

References VQwScaler_Channel().

+ Here is the call graph for this function:

◆ DivideBy() [1/2]

void VQwScaler_Channel::DivideBy ( const VQwHardwareChannel * valueptr)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 484 of file QwScaler_Channel.cc.

485{
486 const VQwScaler_Channel* tmpptr;
487 tmpptr = dynamic_cast<const VQwScaler_Channel*>(valueptr);
488 if (tmpptr!=NULL){
489 *this /= *tmpptr;
490 } else {
491 TString loc="Standard exception from VQwScaler_Channel::DivideBy = "
492 +valueptr->GetElementName()+" is an incompatible type.";
493 throw std::invalid_argument(loc.Data());
494 }
495}

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

+ Here is the call graph for this function:

◆ DivideBy() [2/2]

void VQwScaler_Channel::DivideBy ( const VQwScaler_Channel & denom)

Definition at line 713 of file QwScaler_Channel.cc.

714{
715 *this /= denom;
716}

References VQwScaler_Channel().

+ Here is the call graph for this function:

◆ EncodeEventData()

void VQwScaler_Channel::EncodeEventData ( std::vector< UInt_t > & buffer)
overridepure virtual

Encode the event data into a CODA buffer.

Implements MQwMockable.

Implemented in QwScaler_Channel< data_mask, data_shift >, and QwScaler_Channel< 0x00ffffff, 0 >.

◆ FillHistograms()

void VQwScaler_Channel::FillHistograms ( )
overridevirtual

Fill the histograms for this data element.

Implements VQwDataElement.

Definition at line 248 of file QwScaler_Channel.cc.

249{
250 size_t index = 0;
251 if (IsNameEmpty()) {
252 // This channel is not used, so skip creating the histograms.
253 } else {
254 if (index < fHistograms.size() && fHistograms[index] != NULL && fErrorFlag==0)
255 fHistograms[index]->Fill(this->fValue);
256 index += 1;
257 }
258}

References VQwDataElement::fErrorFlag, MQwHistograms::fHistograms, fValue, and VQwDataElement::IsNameEmpty().

+ Here is the call graph for this function:

◆ FillTreeVector()

void VQwScaler_Channel::FillTreeVector ( QwRootTreeBranchVector & values) const
overridepure virtual

Implements VQwHardwareChannel.

Implemented in QwScaler_Channel< data_mask, data_shift >, and QwScaler_Channel< 0x00ffffff, 0 >.

References VQwScaler_Channel().

+ Here is the call graph for this function:

◆ GetBufferOffset()

Int_t VQwScaler_Channel::GetBufferOffset ( Int_t scalerindex,
Int_t wordindex,
UInt_t header = 1 )
static

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

Parameters
scalerindexScaler index within this buffer; counts from 1
wordindexWord index within this scaler; counts from 1
headerNumber of header words; normally is 1
Returns
The number of words offset to the beginning of this scaler word from the beginning of the buffer.

Definition at line 111 of file QwScaler_Channel.cc.

112{
113 Int_t offset = -1;
114 Int_t kMaxWords = 32; // usually the scalers have 32 data words starting from 0
115
116 if (scalerindex<0 ){
117 QwError << "QwScaler_Channel::GetBufferOffset: Invalid scaler index,"
118 << scalerindex
119 << ". Must be zero or greater."
120 << QwLog::endl;
121 } else if (scalerindex<0 || wordindex>kMaxWords){
122 QwError << "QwScaler_Channel::GetBufferOffset: Invalid word index,"
123 << wordindex
124 << ". Must be in range [0," << kMaxWords << "]."
125 << QwLog::endl;
126 } else {
127 offset = (header + kMaxWords)*scalerindex + header + wordindex ;
128 }
129 return offset;
130}
QwError
#define QwError
Predefined log drain for errors.
Definition QwLog.h:39

References QwLog::endl(), 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:

◆ GetExternalClockName()

std::string VQwScaler_Channel::GetExternalClockName ( )
inlineoverridevirtual

Reimplemented from VQwDataElement.

Definition at line 221 of file QwScaler_Channel.h.

221{ return fNormChannelName; };

References fNormChannelName.

◆ GetRawValue() [1/2]

Int_t VQwHardwareChannel::GetRawValue ( ) const
inline

Definition at line 125 of file VQwHardwareChannel.h.

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

Referenced by ApplyHWChecks().

+ Here is the caller graph for this function:

◆ GetRawValue() [2/2]

Int_t VQwScaler_Channel::GetRawValue ( size_t ) const
inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 142 of file QwScaler_Channel.h.

142{ return fValue_Raw; };

References fValue_Raw.

◆ GetValue() [1/2]

Double_t VQwHardwareChannel::GetValue ( ) const
inline

Definition at line 126 of file VQwHardwareChannel.h.

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

Referenced by ApplySingleEventCuts(), and PrintValue().

+ Here is the caller graph for this function:

◆ GetValue() [2/2]

Double_t VQwScaler_Channel::GetValue ( size_t ) const
inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 143 of file QwScaler_Channel.h.

143{ return fValue; };

References fValue.

◆ GetValueError() [1/2]

Double_t VQwHardwareChannel::GetValueError ( ) const
inline

Definition at line 128 of file VQwHardwareChannel.h.

128{return this->GetValueError(0);};
VQwScaler_Channel::GetValueError
Double_t GetValueError() const
Definition VQwHardwareChannel.h:128

Referenced by PrintValue().

+ Here is the caller graph for this function:

◆ GetValueError() [2/2]

Double_t VQwScaler_Channel::GetValueError ( size_t ) const
inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 145 of file QwScaler_Channel.h.

145{ return fValueError; };

References fValueError.

◆ GetValueM2() [1/2]

Double_t VQwHardwareChannel::GetValueM2 ( ) const
inline

Definition at line 127 of file VQwHardwareChannel.h.

127{return this->GetValueM2(0);};
VQwScaler_Channel::GetValueM2
Double_t GetValueM2() const
Definition VQwHardwareChannel.h:127

◆ GetValueM2() [2/2]

Double_t VQwScaler_Channel::GetValueM2 ( size_t ) const
inlineoverridevirtual

Implements VQwHardwareChannel.

Definition at line 144 of file QwScaler_Channel.h.

144{ return fValueM2; };

References fValueM2.

◆ GetValueWidth() [1/2]

Double_t VQwHardwareChannel::GetValueWidth ( ) const
inline

Definition at line 129 of file VQwHardwareChannel.h.

129{return this->GetValueWidth(0);};
VQwScaler_Channel::GetValueWidth
Double_t GetValueWidth() const
Definition VQwHardwareChannel.h:129

Referenced by PrintValue().

+ 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.

134 {
135 RangeCheck(element);
136 Double_t width;
137 if (fGoodEventCount>0){
138 width = (GetValueError(element)*std::sqrt(Double_t(fGoodEventCount)));
139 } else {
140 width = 0.0;
141 }
142 return width;
143 };
VQwHardwareChannel::RangeCheck
void RangeCheck(size_t element) const
Checks that the requested element is in range, to be used in accesses to subelements similar to std::...
Definition VQwHardwareChannel.h:310

◆ IncrementErrorCounters()

void VQwScaler_Channel::IncrementErrorCounters ( )
overridevirtual

Implements VQwHardwareChannel.

Definition at line 774 of file QwScaler_Channel.cc.

775{
776 if ( (kErrorFlag_ZeroHW & fErrorFlag)==kErrorFlag_ZeroHW){
777 fNumEvtsWithHWErrors++; //increment the hw error counter
778 }
779 if ( ((kErrorFlag_EventCut_L & fErrorFlag)==kErrorFlag_EventCut_L)
780 || ((kErrorFlag_EventCut_U & fErrorFlag)==kErrorFlag_EventCut_U)){
781 fNumEvtsWithEventCutsRejected++; //increment the event cut error counter
782 }
783}

References VQwDataElement::fErrorFlag, fNumEvtsWithEventCutsRejected, fNumEvtsWithHWErrors, kErrorFlag_EventCut_L, kErrorFlag_EventCut_U, and kErrorFlag_ZeroHW.

◆ InitializeChannel() [1/2]

void VQwScaler_Channel::InitializeChannel ( TString name,
TString datatosave = "raw" )
overridevirtual

Initialize the fields in this object.

Implements VQwHardwareChannel.

Definition at line 22 of file QwScaler_Channel.cc.

23{
24 fNormChannelPtr = NULL;
25 fNeedsExternalClock = kFALSE;
26 fIsDifferentialScaler = false;
27
28 SetElementName(name);
29 SetDataToSave(datatosave);
30 SetNumberOfDataWords(1); //Scaler - single word, 32 bits
31 SetNumberOfSubElements(1);
32
33 // Default mockdata parameters
34 SetRandomEventParameters(300.0, 50.0);
35
36 fHeader = 0;
37 fValue_Raw_Old = 0;
38 fValue_Raw = 0;
39 fValue = 0.0;
40 fValueM2 = 0.0;
41 fValueError = 0.0;
42 fPedestal = 0.0;
43 fCalibrationFactor = 1.0;
44
45 fClockNormalization = 1.0;
46
47 fTreeArrayIndex = 0;
48 fTreeArrayNumEntries =0;
49
50 fNumEvtsWithHWErrors=0;//init error counters
51 fNumEvtsWithEventCutsRejected=0;//init error counters
52
53 fErrorFlag = 0;
54 fErrorConfigFlag=0;
55 fGoodEventCount = 0;
56 return;
57};
MQwMockable::SetRandomEventParameters
void SetRandomEventParameters(Double_t mean, Double_t sigma)
Set the normal random event parameters.
Definition MQwMockable.cc:80
VQwScaler_Channel::fNormChannelPtr
const VQwHardwareChannel * fNormChannelPtr
Definition QwScaler_Channel.h:243
VQwDataElement::fErrorConfigFlag
UInt_t fErrorConfigFlag
contains the global/local/stability flags
Definition VQwDataElement.h:272
VQwDataElement::SetElementName
void SetElementName(const TString &name)
Set the name of this element.
Definition VQwDataElement.h:126
VQwHardwareChannel::SetDataToSave
void SetDataToSave(TString datatosave)
Set the flag indicating if raw or derived values are in this data element.
Definition VQwHardwareChannel.h:283
VQwHardwareChannel::SetNumberOfSubElements
void SetNumberOfSubElements(const size_t elements)
Set the number of data words in this data element.
Definition VQwHardwareChannel.h:279
VQwHardwareChannel::SetNumberOfDataWords
void SetNumberOfDataWords(const UInt_t &numwords)
Set the number of data words in this data element.
Definition VQwHardwareChannel.h:277

References VQwHardwareChannel::fCalibrationFactor, fClockNormalization, VQwDataElement::fErrorConfigFlag, VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fHeader, fIsDifferentialScaler, fNeedsExternalClock, fNormChannelPtr, fNumEvtsWithEventCutsRejected, fNumEvtsWithHWErrors, VQwHardwareChannel::fPedestal, VQwHardwareChannel::fTreeArrayIndex, VQwHardwareChannel::fTreeArrayNumEntries, fValue, fValue_Raw, fValue_Raw_Old, fValueError, fValueM2, VQwHardwareChannel::SetDataToSave(), VQwDataElement::SetElementName(), VQwHardwareChannel::SetNumberOfDataWords(), VQwHardwareChannel::SetNumberOfSubElements(), and MQwMockable::SetRandomEventParameters().

Referenced by InitializeChannel(), VQwScaler_Channel(), and VQwScaler_Channel().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ InitializeChannel() [2/2]

void VQwScaler_Channel::InitializeChannel ( TString subsystem,
TString instrumenttype,
TString name,
TString datatosave )
overridevirtual

Initialize the fields in this object.

Implements VQwHardwareChannel.

Definition at line 61 of file QwScaler_Channel.cc.

61 {
62 InitializeChannel(name,datatosave);
63 SetSubsystemName(subsystem);
64 SetModuleType(instrumenttype);
65}
VQwDataElement::SetSubsystemName
void SetSubsystemName(TString sysname)
Set the name of the inheriting subsystem name.
Definition VQwDataElement.h:223
VQwDataElement::SetModuleType
void SetModuleType(TString ModuleType)
set the type of the beam instrument
Definition VQwDataElement.h:233

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

+ Here is the call graph for this function:

◆ IsDifferentialScaler()

virtual Bool_t VQwScaler_Channel::IsDifferentialScaler ( )
inlinevirtual

Definition at line 226 of file QwScaler_Channel.h.

226{ return fIsDifferentialScaler; };

References fIsDifferentialScaler.

Referenced by QwScaler_Channel< data_mask, data_shift >::ProcessEvBuffer(), and SetRawEventData().

+ Here is the caller graph for this function:

◆ LoadChannelParameters()

void VQwScaler_Channel::LoadChannelParameters ( QwParameterFile & paramfile)
overridevirtual

Reimplemented from VQwDataElement.

Definition at line 141 of file QwScaler_Channel.cc.

141 {
142 std::string varvalue;
143 if (paramfile.ReturnValue("normclock",varvalue)){
144 boost::to_lower(varvalue);
145 SetExternalClockName(varvalue);
146 fNeedsExternalClock = kTRUE;
147 }
148};
QwParameterFile::ReturnValue
Bool_t ReturnValue(const std::string keyname, T &retvalue)
Definition QwParameterFile.h:229
VQwScaler_Channel::SetExternalClockName
void SetExternalClockName(const std::string name) override
Definition QwScaler_Channel.h:223

References fNeedsExternalClock, QwParameterFile::ReturnValue(), and SetExternalClockName().

+ 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.

24 {
25 Bool_t ldebug=kFALSE;
26 Double_t asym=0.0, mean=0.0, sigma=0.0;
27 Double_t amplitude=0.0, phase=0.0, frequency=0.0;
28
29 //Check to see if this line contains "drift"
30 if (paramfile.GetLine().find("drift")!=std::string::npos){
31 // "drift" appears somewhere in the line. Assume it is the next token and move on...
32 paramfile.GetNextToken(); //Throw away this token. Now the next three should be the drift parameters.
33 //read 3 parameters
34 amplitude = paramfile.GetTypedNextToken<Double_t>();
35 phase = paramfile.GetTypedNextToken<Double_t>();
36 frequency = paramfile.GetTypedNextToken<Double_t>(); // The frequency we read in should be in Hz.
37 this->AddRandomEventDriftParameters(amplitude, phase, frequency*Qw::Hz);
38 // std::cout << "In MQwMockable::LoadMockDataParameters: amp = " << amplitude << "\t phase = " << phase << "\t freq = " << frequency << std::endl;
39 }
40 else {
41 asym = paramfile.GetTypedNextToken<Double_t>();
42 mean = paramfile.GetTypedNextToken<Double_t>();
43 sigma = paramfile.GetTypedNextToken<Double_t>();
44 if (ldebug==1) {
45 std::cout << "#################### \n";
46 std::cout << "asym, mean, sigma \n" << std::endl;
47 std::cout << asym << " / "
48 << mean << " / "
49 << sigma << " / "
50 << std::endl;
51 }
52 this->SetRandomEventParameters(mean, sigma);
53 this->SetRandomEventAsymmetry(asym);
54 }
55}
Qw::Hz
static const double Hz
Frequency units: base unit is kHz.
Definition QwUnits.h:88
MQwMockable::AddRandomEventDriftParameters
void AddRandomEventDriftParameters(Double_t amplitude, Double_t phase, Double_t frequency)
Add drift parameters to the internal set.
Definition MQwMockable.cc:71
MQwMockable::SetRandomEventAsymmetry
void SetRandomEventAsymmetry(Double_t asymmetry)
Set the helicity asymmetry.
Definition MQwMockable.cc:87
QwParameterFile::GetTypedNextToken
T GetTypedNextToken()
Get next token into specific type.
Definition QwParameterFile.h:137
QwParameterFile::GetLine
std::string GetLine()
Definition QwParameterFile.h:141
QwParameterFile::GetNextToken
std::string GetNextToken(const std::string &separatorchars)
Get next token as a string.
Definition QwParameterFile.cc:739

◆ MultiplyBy()

void VQwScaler_Channel::MultiplyBy ( const VQwHardwareChannel * valueptr)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 471 of file QwScaler_Channel.cc.

472{
473 const VQwScaler_Channel* tmpptr;
474 tmpptr = dynamic_cast<const VQwScaler_Channel*>(valueptr);
475 if (tmpptr!=NULL){
476 *this *= *tmpptr;
477 } else {
478 TString loc="Standard exception from VQwScaler_Channel::MultiplyBy = "
479 +valueptr->GetElementName()+" is an incompatible type.";
480 throw std::invalid_argument(loc.Data());
481 }
482}

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

+ Here is the call graph for this function:

◆ NeedsExternalClock()

Bool_t VQwScaler_Channel::NeedsExternalClock ( )
inlineoverridevirtual

Reimplemented from VQwDataElement.

Definition at line 219 of file QwScaler_Channel.h.

219{ return fNeedsExternalClock; };

References fNeedsExternalClock.

Referenced by ProcessEvent().

+ Here is the caller graph for this function:

◆ operator*=() [1/2]

VQwHardwareChannel & VQwScaler_Channel::operator*= ( const VQwHardwareChannel & input)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 585 of file QwScaler_Channel.cc.

586{
587 const VQwScaler_Channel* tmpptr;
588 tmpptr = dynamic_cast<const VQwScaler_Channel*>(&source);
589 if (tmpptr!=NULL){
590 *this *= *tmpptr;
591 } else {
592 TString loc="Standard exception from VQwScaler_Channel::operator*= "
593 +source.GetElementName()+" "
594 +this->GetElementName()+" are not of the same type";
595 throw(std::invalid_argument(loc.Data()));
596 }
597 return *this;
598}

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

+ Here is the call graph for this function:

◆ operator*=() [2/2]

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

Definition at line 545 of file QwScaler_Channel.cc.

546{
547 if (!IsNameEmpty()){
548 this->fValue *= value.fValue;
549 fHeader = 0;
550 fValue_Raw = 0;
551 this->fValueM2 = 0.0;
552 this->fErrorFlag |= (value.fErrorFlag);//error code is ORed.
553 }
554 return *this;
555}

References VQwDataElement::fErrorFlag, fHeader, fValue, fValue_Raw, fValueM2, VQwDataElement::IsNameEmpty(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ operator+=() [1/2]

VQwHardwareChannel & VQwScaler_Channel::operator+= ( const VQwHardwareChannel & input)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 557 of file QwScaler_Channel.cc.

558{
559 try {
560 const VQwScaler_Channel* tmpptr;
561 tmpptr = dynamic_cast<const VQwScaler_Channel*>(&source);
562 *this += *tmpptr;
563 } catch(const std::exception& e) {
564 TString loc="Standard exception from VQwScaler_Channel::operator+= "
565 +source.GetElementName()+" "
566 +this->GetElementName()+" are not of the same type";
567 throw(std::invalid_argument(loc.Data()));
568 }
569 return *this;
570}

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

+ Here is the call graph for this function:

◆ operator+=() [2/2]

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

Definition at line 525 of file QwScaler_Channel.cc.

526{
527 if (!IsNameEmpty()){
528 this->fValue += value.fValue;
529 this->fValueM2 = 0.0;
530 this->fErrorFlag |= value.fErrorFlag;//error code is ORed.
531 }
532 return *this;
533}

References VQwDataElement::fErrorFlag, fValue, fValueM2, VQwDataElement::IsNameEmpty(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ operator-=() [1/2]

VQwHardwareChannel & VQwScaler_Channel::operator-= ( const VQwHardwareChannel & input)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 571 of file QwScaler_Channel.cc.

572{
573 const VQwScaler_Channel* tmpptr;
574 tmpptr = dynamic_cast<const VQwScaler_Channel*>(&source);
575 if (tmpptr!=NULL){
576 *this -= *tmpptr;
577 } else {
578 TString loc="Standard exception from VQwScaler_Channel::operator-= "
579 +source.GetElementName()+" "
580 +this->GetElementName()+" are not of the same type";
581 throw(std::invalid_argument(loc.Data()));
582 }
583 return *this;
584}

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

+ Here is the call graph for this function:

◆ operator-=() [2/2]

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

Definition at line 535 of file QwScaler_Channel.cc.

536{
537 if (!IsNameEmpty()){
538 this->fValue -= value.fValue;
539 this->fValueM2 = 0.0;
540 this->fErrorFlag |= (value.fErrorFlag);//error code is ORed.
541 }
542 return *this;
543}

References VQwDataElement::fErrorFlag, fValue, fValueM2, VQwDataElement::IsNameEmpty(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ operator/=() [1/2]

VQwHardwareChannel & VQwScaler_Channel::operator/= ( const VQwHardwareChannel & input)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 599 of file QwScaler_Channel.cc.

600{
601 const VQwScaler_Channel* tmpptr;
602 tmpptr = dynamic_cast<const VQwScaler_Channel*>(&source);
603 if (tmpptr!=NULL){
604 *this /= *tmpptr;
605 } else {
606 TString loc="Standard exception from VQwScaler_Channel::operator/= "
607 +source.GetElementName()+" "
608 +this->GetElementName()+" are not of the same type";
609 throw(std::invalid_argument(loc.Data()));
610 }
611 return *this;
612}

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

+ Here is the call graph for this function:

◆ operator/=() [2/2]

VQwScaler_Channel & VQwScaler_Channel::operator/= ( const VQwScaler_Channel & denom)
protected

Definition at line 641 of file QwScaler_Channel.cc.

642{
643 // In this function, leave the "raw" variables untouched.
644 Double_t ratio;
645 Double_t variance;
646 if (!IsNameEmpty()){
647 // The variances are calculated using the following formula:
648 // Var[ratio] = ratio^2 (Var[numer] / numer^2 + Var[denom] / denom^2)
649 //
650 // This requires that both the numerator and denominator are non-zero!
651 //
652 if (this->fValue != 0.0 && denom.fValue != 0.0){
653 ratio = (this->fValue) / (denom.fValue);
654 variance = ratio * ratio *
655 (this->fValueM2 / this->fValue / this->fValue
656 + denom.fValueM2 / denom.fValue / denom.fValue);
657 fValue = ratio;
658 fValueM2 = variance;
659 } else if (this->fValue == 0.0) {
660 fValue = 0.0;
661 fValueM2 = 0.0;
662 } else {
663 QwVerbose << "Attempting to divide by zero in "
664 << GetElementName() << QwLog::endl;
665 fValue = 0.0;
666 fValueM2 = 0.0;
667 }
668
669 // Remaining variables
670 // Don't change fGoodEventCount.
671 // 'OR' the device error codes together.
672 fErrorFlag |= denom.fErrorFlag;
673 }
674
675 // Nanny
676 if (fValue != fValue)
677 QwWarning << "Angry Nanny: NaN detected in " << GetElementName() << QwLog::endl;
678 return *this;
679}
QwVerbose
#define QwVerbose
Predefined log drain for verbose messages.
Definition QwLog.h:54

References QwLog::endl(), VQwDataElement::fErrorFlag, fValue, fValueM2, VQwDataElement::GetElementName(), VQwDataElement::IsNameEmpty(), QwVerbose, QwWarning, and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ operator=()

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

Definition at line 497 of file QwScaler_Channel.cc.

498{
499 if(this == &value) return *this;
500 if (!IsNameEmpty()) {
501 VQwHardwareChannel::operator=(value);
502 this->fHeader = value.fHeader;
503 this->fValue_Raw = value.fValue_Raw;
504 this->fValue = value.fValue;
505 this->fValueError = value.fValueError;
506 this->fValueM2 = value.fValueM2;
507 }
508 return *this;
509}
VQwHardwareChannel::operator=
VQwHardwareChannel & operator=(const VQwHardwareChannel &value)
Arithmetic assignment operator: Should only copy event-based data.
Definition VQwHardwareChannel.h:209

References fHeader, fValue, fValue_Raw, fValueError, fValueM2, VQwDataElement::IsNameEmpty(), VQwHardwareChannel::operator=(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ PrintErrorCounterHead()

static void VQwScaler_Channel::PrintErrorCounterHead ( )
static

◆ PrintErrorCounters()

void VQwScaler_Channel::PrintErrorCounters ( ) const
overridevirtual

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

Reimplemented from VQwDataElement.

Definition at line 886 of file QwScaler_Channel.cc.

886 {
887 if (fNumEvtsWithHWErrors>0)
888 QwMessage << "QwScaler_Channel " << GetElementName()
889 << " had " << fNumEvtsWithHWErrors
890 << " events with a hardware failure."
891 << QwLog::endl;
892
893 if (fNumEvtsWithEventCutsRejected>0)
894 QwMessage << "QwScaler_Channel " << GetElementName()
895 << " had " << fNumEvtsWithEventCutsRejected
896 << " events rejected by Event Cuts."
897 << QwLog::endl;
898 }
QwMessage
#define QwMessage
Predefined log drain for regular messages.
Definition QwLog.h:49

References QwLog::endl(), fNumEvtsWithEventCutsRejected, fNumEvtsWithHWErrors, VQwDataElement::GetElementName(), and QwMessage.

+ Here is the call graph for this function:

◆ PrintErrorCounterTail()

static void VQwScaler_Channel::PrintErrorCounterTail ( )
static

References VQwHardwareChannel::AccumulateRunningSum(), VQwHardwareChannel::DeaccumulateRunningSum(), VQwHardwareChannel::GetRawValue(), VQwHardwareChannel::GetValue(), VQwHardwareChannel::GetValueError(), VQwHardwareChannel::GetValueM2(), VQwHardwareChannel::GetValueWidth(), and MQwMockable::LoadMockDataParameters().

+ Here is the call graph for this function:

◆ PrintInfo()

void VQwScaler_Channel::PrintInfo ( ) const
overridevirtual

Print multiple lines of information about this data element.

Reimplemented from VQwDataElement.

Definition at line 224 of file QwScaler_Channel.cc.

225{
226 QwMessage << "***************************************" << QwLog::endl;
227 QwMessage << "QwScaler channel: " << GetElementName()
228 << QwLog::endl;
229}

References QwLog::endl(), VQwDataElement::GetElementName(), and QwMessage.

+ Here is the call graph for this function:

◆ PrintValue()

void VQwScaler_Channel::PrintValue ( ) const
overridevirtual

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

Reimplemented from VQwDataElement.

Definition at line 211 of file QwScaler_Channel.cc.

212{
213 QwMessage << std::setprecision(4)
214 << std::setw(18) << std::left << GetSubsystemName() << " "
215 << std::setw(18) << std::left << GetModuleType() << " "
216 << std::setw(18) << std::left << GetElementName() << " "
217 << std::setw(12) << std::left << GetValue() << " +/- "
218 << std::setw(12) << std::left << GetValueError() << " sig "
219 << std::setw(12) << std::left << GetValueWidth() << " "
220 << std::setw(12) << std::left << GetGoodEventCount() << " "
221 << QwLog::endl;
222}
VQwDataElement::GetSubsystemName
TString GetSubsystemName() const
Return the name of the inheriting subsystem name.
Definition VQwDataElement.h:218
VQwDataElement::GetGoodEventCount
UInt_t GetGoodEventCount() const
Definition VQwDataElement.h:146
VQwDataElement::GetModuleType
TString GetModuleType() const
Return the type of the beam instrument.
Definition VQwDataElement.h:228

References QwLog::endl(), VQwDataElement::GetElementName(), VQwDataElement::GetGoodEventCount(), VQwDataElement::GetModuleType(), VQwDataElement::GetSubsystemName(), GetValue(), GetValueError(), GetValueWidth(), and QwMessage.

+ Here is the call graph for this function:

◆ ProcessEvBuffer()

Int_t VQwScaler_Channel::ProcessEvBuffer ( UInt_t * buffer,
UInt_t num_words_left,
UInt_t subelement = 0 )
overridepure virtual

Process the CODA event buffer for this element.

Implements VQwDataElement.

Implemented in QwScaler_Channel< data_mask, data_shift >, and QwScaler_Channel< 0x00ffffff, 0 >.

◆ ProcessEvent()

void VQwScaler_Channel::ProcessEvent ( )
overridevirtual

Implements VQwHardwareChannel.

Definition at line 192 of file QwScaler_Channel.cc.

193{
194 if (NeedsExternalClock()){
195 if(fNormChannelPtr){
196 Double_t time = fNormChannelPtr->GetValue();
197 //QwError << "VQwScaler_Channel::ProcessEvent() "<<GetElementName()<<" "<< fValue_Raw<< " "<< fValue<<" "<<fCalibrationFactor<<" "<< fPedestal<<QwLog::endl;
198 fValue = fCalibrationFactor * (Double_t(fValue_Raw)/time - fPedestal);
199 } else {
200 QwWarning << "VQwScaler_Channel::ProcessEvent: "
201 << "Missing the reference clock, "
202 << fNormChannelName
203 << ", for data element "
204 << GetElementName()
205 << QwLog::endl;
206 }
207 }
208}
VQwScaler_Channel::NeedsExternalClock
Bool_t NeedsExternalClock() override
Definition QwScaler_Channel.h:219

References QwLog::endl(), VQwHardwareChannel::fCalibrationFactor, fNormChannelName, fNormChannelPtr, VQwHardwareChannel::fPedestal, fValue, fValue_Raw, VQwDataElement::GetElementName(), NeedsExternalClock(), and QwWarning.

+ Here is the call graph for this function:

◆ Product()

void VQwScaler_Channel::Product ( VQwScaler_Channel & numer,
VQwScaler_Channel & denom )

Definition at line 681 of file QwScaler_Channel.cc.

682{
683 if (!IsNameEmpty()){
684 fValue = numer.fValue * denom.fValue;
685 fHeader = 0;
686 fValue_Raw = 0;
687
688 // Remaining variables
689 fGoodEventCount = denom.fGoodEventCount;
690 fErrorFlag = (numer.fErrorFlag|denom.fErrorFlag);//error code is ORed.
691 }
692}

References VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fHeader, fValue, fValue_Raw, VQwDataElement::IsNameEmpty(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ RandomizeEventData()

void VQwScaler_Channel::RandomizeEventData ( int helicity = 0,
double time = 0.0 )
overridevirtual

Internally generate random event data.

Implements MQwMockable.

Definition at line 79 of file QwScaler_Channel.cc.

80{
81 // Calculate drift (if time is not specified, it stays constant at zero)
82 Double_t drift = 0.0;
83 for (UInt_t i = 0; i < fMockDriftFrequency.size(); i++) {
84 drift += fMockDriftAmplitude[i] * sin(2.0 * Qw::pi * fMockDriftFrequency[i] * time + fMockDriftPhase[i]);
85 }
86
87 Double_t value = fMockGaussianMean * (1 + helicity * fMockAsymmetry)
88 + fMockGaussianSigma * GetRandomValue()
89 + drift;
90
91 fValue = value;
92 fValue_Raw = Int_t(value / fCalibrationFactor + fPedestal);
93}
Qw::pi
static const double pi
Angles: base unit is radian.
Definition QwUnits.h:107
MQwMockable::fMockDriftAmplitude
std::vector< Double_t > fMockDriftAmplitude
Harmonic drift amplitude.
Definition MQwMockable.h:120
MQwMockable::fMockDriftFrequency
std::vector< Double_t > fMockDriftFrequency
Harmonic drift frequency.
Definition MQwMockable.h:121
MQwMockable::fMockAsymmetry
Double_t fMockAsymmetry
Helicity asymmetry.
Definition MQwMockable.h:117
MQwMockable::fMockGaussianSigma
Double_t fMockGaussianSigma
Sigma of normal distribution.
Definition MQwMockable.h:119
MQwMockable::fMockGaussianMean
Double_t fMockGaussianMean
Mean of normal distribution.
Definition MQwMockable.h:118
MQwMockable::fMockDriftPhase
std::vector< Double_t > fMockDriftPhase
Harmonic drift phase.
Definition MQwMockable.h:122
MQwMockable::GetRandomValue
Double_t GetRandomValue()
Definition MQwMockable.cc:93

References VQwHardwareChannel::fCalibrationFactor, MQwMockable::fMockAsymmetry, MQwMockable::fMockDriftAmplitude, MQwMockable::fMockDriftFrequency, MQwMockable::fMockDriftPhase, MQwMockable::fMockGaussianMean, MQwMockable::fMockGaussianSigma, VQwHardwareChannel::fPedestal, fValue, fValue_Raw, MQwMockable::GetRandomValue(), and Qw::pi.

+ Here is the call graph for this function:

◆ Ratio()

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

Definition at line 625 of file QwScaler_Channel.cc.

626{
627 if (!IsNameEmpty()){
628 *this = numer;
629 *this /= denom;
630
631 // Set the raw values to zero.
632 fHeader = 0;
633 fValue_Raw = 0;
634
635 // Remaining variables
636 fGoodEventCount = denom.fGoodEventCount;
637 fErrorFlag = (numer.fErrorFlag|denom.fErrorFlag);//error code is ORed.
638 }
639}

References VQwDataElement::fErrorFlag, VQwDataElement::fGoodEventCount, fHeader, fValue_Raw, VQwDataElement::IsNameEmpty(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ Scale()

void VQwScaler_Channel::Scale ( Double_t Offset)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 704 of file QwScaler_Channel.cc.

705{
706 if (!IsNameEmpty())
707 {
708 fValue *= scale;
709 fValueM2 *= scale * scale;
710 }
711}

References fValue, fValueM2, and VQwDataElement::IsNameEmpty().

+ Here is the call graph for this function:

◆ ScaledAdd()

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

Implements VQwHardwareChannel.

Definition at line 900 of file QwScaler_Channel.cc.

900 {
901
902 const VQwScaler_Channel* input = dynamic_cast<const VQwScaler_Channel*>(value);
903
904 // follows same steps as += but w/ scaling factor
905 if (input!=NULL && !IsNameEmpty()){
906 this->fValue += scale * input->fValue;
907 this->fValueM2 = 0.0;
908 this->fErrorFlag |= (input->fErrorFlag);
909 } else if (input == NULL && value != NULL) {
910 TString loc="Standard exception from VQwScaler_Channel::ScaledAdd "
911 +value->GetElementName()+" "
912 +this->GetElementName()+" are not of the same type";
913 throw(std::invalid_argument(loc.Data()));
914 }
915}

References VQwDataElement::fErrorFlag, fValue, fValueM2, VQwDataElement::GetElementName(), VQwDataElement::IsNameEmpty(), VQwHardwareChannel::VQwHardwareChannel(), and VQwScaler_Channel().

+ Here is the call graph for this function:

◆ SetDefaultSampleSize()

void VQwScaler_Channel::SetDefaultSampleSize ( size_t )
inline

Definition at line 110 of file QwScaler_Channel.h.

110 {
111 //std::cerr << "QwScaler_Channel SetDefaultSampleSize does nothing!"
112 // << std::endl;
113 }

◆ SetDifferentialScaler()

virtual void VQwScaler_Channel::SetDifferentialScaler ( Bool_t diff)
inlinevirtual

Definition at line 227 of file QwScaler_Channel.h.

227{ fIsDifferentialScaler = diff; };

References fIsDifferentialScaler.

Referenced by QwScaler::LoadChannelMap().

+ Here is the caller graph for this function:

◆ SetEventData()

void VQwScaler_Channel::SetEventData ( Double_t value)

Definition at line 133 of file QwScaler_Channel.cc.

133 {
134
135 this->fValue = value;
136 this->fValue_Raw = (UInt_t)value;
137 //std::cout<<"fValue is set to: value = "<<value<<std::endl;
138
139}

References fValue, and fValue_Raw.

◆ SetExternalClockName()

void VQwScaler_Channel::SetExternalClockName ( const std::string name)
inlineoverridevirtual

Reimplemented from VQwDataElement.

Definition at line 223 of file QwScaler_Channel.h.

223{ fNormChannelName = name; };

References fNormChannelName.

Referenced by LoadChannelParameters().

+ Here is the caller graph for this function:

◆ SetExternalClockPtr()

void VQwScaler_Channel::SetExternalClockPtr ( const VQwHardwareChannel * clock)
inlineoverridevirtual

Reimplemented from VQwDataElement.

Definition at line 222 of file QwScaler_Channel.h.

222{ fNormChannelPtr = clock; };

References fNormChannelPtr, and VQwHardwareChannel::VQwHardwareChannel().

+ Here is the call graph for this function:

◆ SetNeedsExternalClock()

void VQwScaler_Channel::SetNeedsExternalClock ( Bool_t needed)
inlineoverridevirtual

Reimplemented from VQwDataElement.

Definition at line 220 of file QwScaler_Channel.h.

220{ fNeedsExternalClock = needed; };

References fNeedsExternalClock.

◆ SetRawEventData()

void VQwScaler_Channel::SetRawEventData ( )
inlineoverridevirtual

Implements MQwMockable.

Definition at line 121 of file QwScaler_Channel.h.

121 {
122 //fValue = fCalibrationFactor * (Double_t(fValue_Raw) - Double_t(fValue_Raw_Old) - fPedestal);
123
124 fValue_Raw = Int_t(fValue/fCalibrationFactor + fPedestal) + fValue_Raw_Old;
125 if (IsDifferentialScaler())
126 fValue_Raw_Old = fValue_Raw;
127 else
128 fValue_Raw_Old = 0;
129
130};
VQwScaler_Channel::IsDifferentialScaler
virtual Bool_t IsDifferentialScaler()
Definition QwScaler_Channel.h:226

References VQwHardwareChannel::fCalibrationFactor, VQwHardwareChannel::fPedestal, fValue, fValue_Raw, fValue_Raw_Old, and IsDifferentialScaler().

Referenced by SmearByResolution().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ SmearByResolution()

void VQwScaler_Channel::SmearByResolution ( double resolution)
overridevirtual

Implements MQwMockable.

Definition at line 95 of file QwScaler_Channel.cc.

96{
97 fValue = resolution*GetRandomValue();
98 fValueM2 = 0.0;
99 SetRawEventData();
100}
VQwScaler_Channel::SetRawEventData
void SetRawEventData() override
Definition QwScaler_Channel.h:121

References fValue, fValueM2, MQwMockable::GetRandomValue(), and SetRawEventData().

+ Here is the call graph for this function:

◆ SubtractValueFrom()

void VQwScaler_Channel::SubtractValueFrom ( const VQwHardwareChannel * valueptr)
overridevirtual

Implements VQwHardwareChannel.

Definition at line 459 of file QwScaler_Channel.cc.

460{
461 const VQwScaler_Channel* tmpptr;
462 tmpptr = dynamic_cast<const VQwScaler_Channel*>(valueptr);
463 if (tmpptr!=NULL){
464 *this -= *tmpptr;
465 } else {
466 TString loc="Standard exception from VQwScaler_Channel::SubtractValueFrom = "
467 +valueptr->GetElementName()+" is an incompatible type.";
468 throw std::invalid_argument(loc.Data());
469 }
470}

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

+ Here is the call graph for this function:

◆ Sum()

void VQwScaler_Channel::Sum ( VQwScaler_Channel & value1,
VQwScaler_Channel & value2 )

Definition at line 614 of file QwScaler_Channel.cc.

615{
616 *this = value1;
617 *this += value2;
618}

References VQwScaler_Channel().

+ Here is the call graph for this function:

Field Documentation

◆ fClockNormalization

Double_t VQwScaler_Channel::fClockNormalization
protected

Definition at line 244 of file QwScaler_Channel.h.

Referenced by CopyFrom(), InitializeChannel(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ fHeader

UInt_t VQwScaler_Channel::fHeader
protected

Definition at line 237 of file QwScaler_Channel.h.

Referenced by ClearEventData(), QwScaler_Channel< data_mask, data_shift >::FillTreeVector(), InitializeChannel(), operator*=(), operator=(), QwScaler_Channel< data_mask, data_shift >::ProcessEvBuffer(), Product(), and Ratio().

◆ fIsDifferentialScaler

Bool_t VQwScaler_Channel::fIsDifferentialScaler
protected

Definition at line 248 of file QwScaler_Channel.h.

Referenced by CopyFrom(), InitializeChannel(), IsDifferentialScaler(), SetDifferentialScaler(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ fNeedsExternalClock

Bool_t VQwScaler_Channel::fNeedsExternalClock
protected

Definition at line 247 of file QwScaler_Channel.h.

Referenced by CopyFrom(), InitializeChannel(), LoadChannelParameters(), NeedsExternalClock(), SetNeedsExternalClock(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ fNormChannelName

std::string VQwScaler_Channel::fNormChannelName
protected

Definition at line 245 of file QwScaler_Channel.h.

Referenced by CopyFrom(), GetExternalClockName(), ProcessEvent(), SetExternalClockName(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ fNormChannelPtr

const VQwHardwareChannel* VQwScaler_Channel::fNormChannelPtr
protected

Definition at line 243 of file QwScaler_Channel.h.

Referenced by InitializeChannel(), ProcessEvent(), and SetExternalClockPtr().

◆ fNumEvtsWithEventCutsRejected

Int_t VQwScaler_Channel::fNumEvtsWithEventCutsRejected
protected

Definition at line 252 of file QwScaler_Channel.h.

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

◆ fNumEvtsWithHWErrors

Int_t VQwScaler_Channel::fNumEvtsWithHWErrors
protected

Definition at line 251 of file QwScaler_Channel.h.

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

◆ fValue

Double_t VQwScaler_Channel::fValue
protected

Definition at line 240 of file QwScaler_Channel.h.

Referenced by AccumulateRunningSum(), AddChannelOffset(), AssignScaledValue(), ClearEventData(), ConstructBranch(), CopyFrom(), FillHistograms(), QwScaler_Channel< data_mask, data_shift >::FillTreeVector(), GetValue(), InitializeChannel(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), QwScaler_Channel< data_mask, data_shift >::ProcessEvBuffer(), ProcessEvent(), Product(), RandomizeEventData(), Scale(), ScaledAdd(), SetEventData(), SetRawEventData(), SmearByResolution(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ fValue_Raw

UInt_t VQwScaler_Channel::fValue_Raw
protected

Definition at line 239 of file QwScaler_Channel.h.

Referenced by ClearEventData(), CopyFrom(), QwScaler_Channel< data_mask, data_shift >::EncodeEventData(), QwScaler_Channel< data_mask, data_shift >::FillTreeVector(), GetRawValue(), InitializeChannel(), operator*=(), operator=(), QwScaler_Channel< data_mask, data_shift >::ProcessEvBuffer(), ProcessEvent(), Product(), RandomizeEventData(), Ratio(), SetEventData(), SetRawEventData(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ fValue_Raw_Old

UInt_t VQwScaler_Channel::fValue_Raw_Old
protected

Definition at line 238 of file QwScaler_Channel.h.

Referenced by CopyFrom(), InitializeChannel(), QwScaler_Channel< data_mask, data_shift >::ProcessEvBuffer(), SetRawEventData(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ fValueError

Double_t VQwScaler_Channel::fValueError
protected

Definition at line 242 of file QwScaler_Channel.h.

Referenced by AssignScaledValue(), CalculateRunningAverage(), ClearEventData(), CopyFrom(), QwScaler_Channel< data_mask, data_shift >::FillTreeVector(), GetValueError(), InitializeChannel(), operator=(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ fValueM2

Double_t VQwScaler_Channel::fValueM2
protected

Definition at line 241 of file QwScaler_Channel.h.

Referenced by AccumulateRunningSum(), AssignScaledValue(), CalculateRunningAverage(), ClearEventData(), CopyFrom(), QwScaler_Channel< data_mask, data_shift >::FillTreeVector(), GetValueM2(), InitializeChannel(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), Scale(), ScaledAdd(), SmearByResolution(), VQwScaler_Channel(), and VQwScaler_Channel().

◆ kDEBUG

const Bool_t VQwScaler_Channel::kDEBUG = kFALSE
staticprotected

Definition at line 235 of file QwScaler_Channel.h.

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