Subsystem for helicity data decoding. More...

#include <QwHelicityDecoder.h>

Inheritance diagram for QwHelicityDecoder:

Collaboration diagram for QwHelicityDecoder:

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

	QwHelicityDecoder (const QwHelicityDecoder &source)
	Copy constructor.

virtual	~QwHelicityDecoder () override
	Virtual destructor.

void	ProcessOptions (QwOptions &options) override
	Process the command line options.

Int_t	LoadChannelMap (TString mapfile) override
	Mandatory map file definition.

Int_t	LoadInputParameters (TString pedestalfile) override
	Mandatory parameter file definition.

Int_t	LoadEventCuts (TString filename) override
	Optional event cut file.

Bool_t	ApplySingleEventCuts () override
	Apply the single event cuts.

Bool_t	CheckForBurpFail (const VQwSubsystem *ev_error) override
	Report the number of events failed due to HW and event cut failures.

void	UpdateErrorFlag (const VQwSubsystem *ev_error) override
	update the error flag in the subsystem level from the top level routines related to stability checks. This will uniquely update the errorflag at each channel based on the error flag in the corresponding channel in the ev_error subsystem

Int_t	ProcessConfigurationBuffer (const ROCID_t roc_id, const BankID_t bank_id, UInt_t *buffer, UInt_t num_words) override

Int_t	ProcessEvBuffer (const ROCID_t roc_id, const BankID_t bank_id, UInt_t *buffer, UInt_t num_words)
	TODO: The non-event-type-aware ProcessEvBuffer routine should be replaced with the event-type-aware version.

Int_t	ProcessEvBuffer (UInt_t ev_type, const ROCID_t roc_id, const BankID_t bank_id, UInt_t *buffer, UInt_t num_words) override

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

virtual void	ClearEventData () override

virtual void	ProcessEvent () override

UInt_t	GetRandomSeedActual ()

UInt_t	GetRandomSeedDelayed ()

void	PredictHelicity ()

void	RunPredictor ()

void	SetHelicityDelay (Int_t delay)

void	SetHelicityBitPattern (TString hex)

void	SetFirstBits (UInt_t nbits, UInt_t firstbits)

VQwSubsystem &	operator= (VQwSubsystem *value) override
	Assignment Note: Must be called at the beginning of all subsystems routine call to operator=(VQwSubsystem *value) by VQwSubsystem::operator=(value)

VQwSubsystem &	operator+= (VQwSubsystem *value) override

VQwSubsystem &	operator-= (VQwSubsystem *value) override

void	Ratio (VQwSubsystem numer, VQwSubsystem denom) override

void	AccumulateRunningSum (VQwSubsystem *value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF) override
	Update the running sums for devices.

void	DeaccumulateRunningSum (VQwSubsystem *value, Int_t ErrorMask=0xFFFFFFF) override
	remove one entry from the running sums for devices

void	ConstructHistograms (TDirectory *folder, TString &prefix) override
	Construct the histograms for this subsystem in a folder with a prefix.

void	FillHistograms () override
	Fill the histograms for this subsystem.

void	ConstructBranchAndVector (TTree *tree, TString &prefix, QwRootTreeBranchVector &values) override
	Construct the branch and tree vector.

void	ConstructBranch (TTree *tree, TString &prefix) override
	Construct the branch and tree vector.

void	ConstructBranch (TTree *tree, TString &prefix, QwParameterFile &trim_file) override
	Construct the branch and tree vector based on the trim file.

void	FillTreeVector (QwRootTreeBranchVector &values) const override
	Fill the tree vector.

void	Print () const

void	CheckPatternNum (VQwSubsystem *value)

void	MergeCounters (VQwSubsystem *value)

Bool_t	CheckIORegisterMask (const UInt_t &ioregister, const UInt_t &mask) const

void	SetHistoTreeSave (const TString &prefix)

Bool_t	Compare (VQwSubsystem *source)

void	FillHDVariables (uint32_t data, uint32_t index)

virtual void	ConstructHistograms ()
	Construct the histograms for this subsystem.

virtual void	ConstructHistograms (TDirectory *folder)
	Construct the histograms for this subsystem in a folder.

virtual void	ConstructHistograms (TString &prefix)
	Construct the histograms for this subsystem with a prefix.

virtual void	ConstructBranchAndVector (TTree *tree, QwRootTreeBranchVector &values)
	Construct the branch and tree vector.

Public Member Functions inherited from QwHelicityBase
	QwHelicityBase (const TString &name)
	Constructor with name.

	QwHelicityBase (const QwHelicityBase &source)
	Copy constructor.

virtual	~QwHelicityBase () override
	Virtual destructor.

void	IncrementErrorCounters () override
	Increment the error counters.

void	PrintErrorCounters () const override

UInt_t	GetEventcutErrorFlag () override
	Return the error flag to the top level routines related to stability checks and ErrorFlag updates.

UInt_t	GetRandomSeedActual ()

UInt_t	GetRandomSeedDelayed ()

void	PredictHelicity ()

void	RunPredictor ()

void	SetHelicityDelay (Int_t delay)

void	SetHelicityBitPattern (TString hex)

Int_t	GetHelicityReported ()

Int_t	GetHelicityActual ()

Int_t	GetHelicityDelayed ()

Long_t	GetEventNumber ()

Long_t	GetPatternNumber ()

Int_t	GetPhaseNumber ()

Int_t	GetMaxPatternPhase ()

Int_t	GetMinPatternPhase ()

void	SetFirstBits (UInt_t nbits, UInt_t firstbits)

void	SetEventPatternPhase (Int_t event, Int_t pattern, Int_t phase)

void	Scale (Double_t factor) override

void	CalculateRunningAverage () override
	Calculate the average for all good events.

void	Print () const

Bool_t	IsHelicityIgnored ()

virtual Bool_t	IsGoodHelicity ()

Public Member Functions inherited from VQwSubsystemParity
	VQwSubsystemParity (const TString &name)
	Constructor with name.

	VQwSubsystemParity (const VQwSubsystemParity &source)
	Copy constructor.

	~VQwSubsystemParity () override
	Default destructor.

virtual void	FillDB_MPS (QwParityDB *, TString)
	Fill the database with MPS-based variables Note that most subsystems don't need to do this.

virtual void	FillDB (QwParityDB *, TString)
	Fill the database.

virtual void	FillErrDB (QwParityDB *, TString)

virtual void	Sum (VQwSubsystem value1, VQwSubsystem value2)

virtual void	Difference (VQwSubsystem value1, VQwSubsystem value2)

Int_t	LoadEventCuts (TString filename) override
	Load the event cuts file.

virtual void	LoadEventCuts_Init ()

virtual void	LoadEventCuts_Line (QwParameterFile &, TString &, Int_t &)

virtual void	LoadEventCuts_Fin (Int_t &)

virtual UInt_t	UpdateErrorFlag ()
	Uses the error flags of contained data elements to update Returns the error flag to the top level routines related to stability checks and ErrorFlag updates.

virtual void	Blind (const QwBlinder *)
	Blind the asymmetry of this subsystem.

virtual void	Blind (const QwBlinder , const VQwSubsystemParity )
	Blind the difference of this subsystem.

virtual void	PrintValue () const
	Print values of all channels.

virtual void	WritePromptSummary (QwPromptSummary *, TString)

virtual Bool_t	CheckForEndOfBurst () const

virtual void	LoadMockDataParameters (TString)

Public Member Functions inherited from VQwSubsystem
	VQwSubsystem (const TString &name)
	Constructor with name.

	VQwSubsystem (const VQwSubsystem &orig)
	Copy constructor by object.

	~VQwSubsystem () override
	Default destructor.

TString	GetName () const

Bool_t	HasDataLoaded () const

VQwSubsystem *	GetSibling (const std::string &name) const
	Get the sibling with specified name.

virtual std::vector< TString >	GetParamFileNameList ()

virtual std::map< TString, TString >	GetDetectorMaps ()

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

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

virtual Int_t	LoadDetectorMaps (QwParameterFile &file)
	Parse parameter file to find the map files.

virtual Int_t	LoadGeometryDefinition (TString)
	Optional geometry definition.

virtual Int_t	LoadCrosstalkDefinition (TString)
	Optional crosstalk definition.

void	SetEventTypeMask (const UInt_t mask)
	Set event type mask.

UInt_t	GetEventTypeMask () const
	Get event type mask.

virtual void	ExchangeProcessedData ()
	Request processed data from other subsystems for internal use in the second event processing stage. Not all derived classes will require data from other subsystems.

virtual void	ProcessEvent_2 ()
	Process the event data again, including data from other subsystems. Not all derived classes will require a second stage of event data processing.

virtual void	AtEndOfEventLoop ()
	Perform actions at the end of the event loop.

virtual void	RandomizeEventData (int=0, double=0.0)

virtual void	ConstructObjects ()
	Construct the objects for this subsystem.

virtual void	ConstructObjects (TDirectory *folder)
	Construct the objects for this subsystem in a folder.

virtual void	ConstructObjects (TString &prefix)
	Construct the objects for this subsystem with a prefix.

virtual void	ConstructObjects (TDirectory *, TString &)
	Construct the objects for this subsystem in a folder with a prefix.

virtual void	ConstructTree ()
	Construct the tree for this subsystem.

virtual void	ConstructTree (TDirectory *folder)
	Construct the tree for this subsystem in a folder.

virtual void	ConstructTree (TString &prefix)
	Construct the tree for this subsystem with a prefix.

virtual void	ConstructTree (TDirectory *, TString &)
	Construct the tree for this subsystem in a folder with a prefix.

virtual void	FillTree ()
	Fill the tree for this subsystem.

virtual void	DeleteTree ()
	Delete the tree for this subsystem.

virtual void	PrintInfo () const
	Print some information about the subsystem.

virtual void	PrintDetectorMaps (Bool_t status) const

void	GetMarkerWordList (const ROCID_t roc_id, const BankID_t bank_id, std::vector< UInt_t > &marker) const

std::vector< ROCID_t >	GetROCIds () const

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

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

	MQwPublishable_child (const MQwPublishable_child &source)
	Copy constructor.

virtual	~MQwPublishable_child ()
	Virtual destructor.

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

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

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

VQwSubsystem *	Clone () const override
	Concrete clone method.

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

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

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

Static Public Member Functions
static void	DefineOptions (QwOptions &options)
	Define options function.

Static Public Member Functions inherited from QwHelicityBase
static void	DefineOptions (QwOptions &options)
	Define options function.

Static Public Member Functions inherited from VQwSubsystem
static void	DefineOptions ()
	Define options function (note: no virtual static functions in C++)

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

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

Data Fields
UInt_t	fSeed_Reported

Int_t	fNum_TStable_Fall

Int_t	fNum_Pair_Sync

Int_t	fTime_since_TStable

Int_t	fTime_since_TSettle

Int_t	fLast_Duration_TStable

Int_t	fLast_Duration_TSettle

Int_t	fEventPolarity

Int_t	fReportedPatternHel

Int_t	fBit_Helicity

Int_t	fBit_PairSync

Int_t	fBit_PatSync

Int_t	fBit_TStable

UInt_t	fEvtHistory_PatSync

UInt_t	fEvtHistory_PairSync

UInt_t	fEvtHistory_ReportedHelicity

UInt_t	fPatHistory_ReportedHelicity

Static Public Attributes
static const std::vector< UInt_t >	kDefaultHelicityBitPattern {0x69}

static const Bool_t	kDEBUG =kFALSE

static const Int_t	kUndefinedHelicity = -9999

static const Int_t	fNumDecoderWords =14

Private Member Functions
	QwHelicityDecoder ()
	Private default constructor (not implemented, will throw linker error on use)

Additional Inherited Members
Protected Types inherited from QwHelicityBase
enum	HelicityRootSavingType { kHelSaveMPS = 0 , kHelSavePattern , kHelNoSave }

Protected Member Functions inherited from QwHelicityBase
void	CheckPatternNum (VQwSubsystem *value)

void	MergeCounters (VQwSubsystem *value)

void	SetHistoTreeSave (const TString &prefix)

Bool_t	IsGoodPatternNumber ()

Bool_t	IsGoodEventNumber ()

Bool_t	MatchActualHelicity (Int_t actual)

Bool_t	IsGoodPhaseNumber ()

Bool_t	IsContinuous ()

virtual UInt_t	GetRandbit (UInt_t &ranseed)

UInt_t	GetRandbit24 (UInt_t &ranseed)

UInt_t	GetRandbit30 (UInt_t &ranseed)

UInt_t	GetRandomSeed (UShort_t *first24randbits)

virtual Bool_t	CollectRandBits ()

Bool_t	CollectRandBits24 ()

Bool_t	CollectRandBits30 ()

void	ResetPredictor ()

Bool_t	Compare (VQwSubsystem *source)

void	ClearErrorCounters ()

UInt_t	BuildHelicityBitPattern (Int_t patternsize)

unsigned int	parity (unsigned int v)

void	ClearAllBankRegistrations ()
	Clear all registration of ROC and Bank IDs for this subsystem.

virtual Int_t	RegisterROCNumber (const ROCID_t roc_id, const BankID_t bank_id=0)
	Tell the object that it will decode data from this ROC and sub-bank.

Int_t	RegisterSubbank (const BankID_t bank_id)
	Tell the object that it will decode data from this sub-bank in the ROC currently open for registration.

Int_t	RegisterMarkerWord (const UInt_t markerword)

void	RegisterRocBankMarker (QwParameterFile &mapstr)

Int_t	GetSubbankIndex () const

Int_t	GetSubbankIndex (const ROCID_t roc_id, const BankID_t bank_id) const

void	SetDataLoaded (Bool_t flag)

template<class T>
Int_t	FindIndex (const std::vector< T > &myvec, const T value) const

Bool_t	Compare (VQwSubsystem *source)

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 Member Functions inherited from MQwPublishable_child< QwSubsystemArray, VQwSubsystem >
Bool_t	RequestExternalValue (const TString &name, VQwHardwareChannel *value) const
	Retrieve the variable name from other subsystem arrays Get the value corresponding to some variable name from a different data array.

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

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

Protected Attributes inherited from QwHelicityBase
std::vector< UInt_t >	fHelicityBitPattern

std::vector< QwWord >	fWord

std::vector< std::pair< Int_t, Int_t > >	fWordsPerSubbank

Int_t	fHelicityDecodingMode

Int_t	kUserbit

Int_t	kScalerCounter

Int_t	kInputRegister

Int_t	kPatternCounter

Int_t	kMpsCounter

Int_t	kPatternPhase

UInt_t	kEventTypeHelPlus

UInt_t	kEventTypeHelMinus

Int_t	fEventNumberOld

Int_t	fEventNumber

Int_t	fPatternPhaseNumberOld

Int_t	fPatternPhaseNumber

Int_t	fPatternNumberOld

Int_t	fPatternNumber

Int_t	fPatternSeed

Int_t	fActualPatternPolarity
	True polarity of the current pattern.

Int_t	fDelayedPatternPolarity
	Reported polarity of the current pattern.

Int_t	fPreviousPatternPolarity
	True polarity of the previous pattern.

Int_t	fHelicityReported

Int_t	fHelicityActual

Int_t	fHelicityDelayed

Bool_t	fHelicityBitPlus

Bool_t	fHelicityBitMinus

Bool_t	fGoodHelicity

Bool_t	fGoodPattern

Int_t	fHistoType

size_t	fTreeArrayIndex

size_t	fTreeArrayNumEntries

UInt_t	n_ranbits

UInt_t	iseed_Actual

UInt_t	iseed_Delayed

Int_t	fHelicityDelay

Int_t	fMaxPatternPhase

Int_t	fMinPatternPhase

Int_t	fRandBits

Bool_t	fUsePredictor

Bool_t	fHelicityInfoOK

Int_t	fPatternPhaseOffset

Bool_t	fIgnoreHelicity

UInt_t	fEventType

Int_t	fEventNumberFirst

Int_t	fPatternNumberFirst

Int_t	fNumMissedGates

Int_t	fNumMissedEventBlocks

Int_t	fNumMultSyncErrors

Int_t	fNumHelicityErrors

UInt_t	fErrorFlag

Bool_t	fSuppressMPSErrorMsgs

Protected Attributes inherited from VQwSubsystem
std::vector< std::vector< TString > >	fPublishList

TString	fSystemName
	Name of this subsystem.

UInt_t	fEventTypeMask
	Mask of event types.

Bool_t	fIsDataLoaded
	Has this subsystem gotten data to be processed?

std::vector< TString >	fDetectorMapsNames
	Names of loaded detector map files.

std::map< TString, TString >	fDetectorMaps
	Map of file name to full path or content.

ROCID_t	fCurrentROC_ID
	ROC ID that is currently being processed.

BankID_t	fCurrentBank_ID
	Bank ID (and Marker word) that is currently being processed;.

std::vector< ROCID_t >	fROC_IDs
	Vector of ROC IDs associated with this subsystem.

std::vector< std::vector< BankID_t > >	fBank_IDs
	Vector of Bank IDs per ROC ID associated with this subsystem.

std::vector< std::vector< std::vector< UInt_t > > >	fMarkerWords
	Vector of marker words per ROC & subbank associated with this subsystem.

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

Static Protected Attributes inherited from QwHelicityBase
static const std::vector< UInt_t >	kDefaultHelicityBitPattern {0x69}

static const Bool_t	kDEBUG =kFALSE

static const Int_t	kUndefinedHelicity = -9999

Detailed Description

Subsystem for helicity data decoding.

Manages helicity information from the polarized electron beam, including helicity state determination, pattern recognition, delayed helicity decoding, and helicity-correlated systematic checks. Supports multiple helicity encoding modes and provides helicity information to other subsystems.

Definition at line 35 of file QwHelicityDecoder.h.

Constructor & Destructor Documentation

◆ QwHelicityDecoder() [1/3]

QwHelicityDecoder::QwHelicityDecoder ( )

private

Private default constructor (not implemented, will throw linker error on use)

References QwHelicityDecoder().

Referenced by AccumulateRunningSum(), CheckPatternNum(), Compare(), MergeCounters(), operator=(), QwHelicityDecoder(), and QwHelicityDecoder().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QwHelicityDecoder() [2/3]

QwHelicityDecoder::QwHelicityDecoder ( const TString & name )

Constructor with name.

constructor

Definition at line 37 of file QwHelicityDecoder.cc.

: VQwSubsystem(name),
  QwHelicityBase(name)
{
}

References QwHelicityBase::QwHelicityBase(), and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ QwHelicityDecoder() [3/3]

QwHelicityDecoder::QwHelicityDecoder ( const QwHelicityDecoder & source )

Copy constructor.

Definition at line 44 of file QwHelicityDecoder.cc.

: VQwSubsystem(source.GetName()),
  QwHelicityBase(source.GetName())
{
}

References VQwSubsystem::GetName(), QwHelicityBase::QwHelicityBase(), QwHelicityDecoder(), and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ ~QwHelicityDecoder()

virtual QwHelicityDecoder::~QwHelicityDecoder ( )

inlineoverridevirtual

Virtual destructor.

Definition at line 47 of file QwHelicityDecoder.h.

47{ }

Member Function Documentation

◆ AccumulateRunningSum()

void QwHelicityDecoder::AccumulateRunningSum	(	VQwSubsystem *	value,
		Int_t	count = 0,
		Int_t	ErrorMask = 0xFFFFFFF )

overridevirtual

Update the running sums for devices.

Reimplemented from QwHelicityBase.

Definition at line 1236 of file QwHelicityDecoder.cc.

                                                                                              {
  if (Compare(value)) {
    MergeCounters(value);
    QwHelicityDecoder* input = dynamic_cast<QwHelicityDecoder*>(value);
    fPatternNumber = (fPatternNumber <=0 ) ? input->fPatternNumber :
      std::min(fPatternNumber, input->fPatternNumber);
    //  Keep track of the various error quantities, so we can print
    //  them at the end.
    fNumMissedGates       = input->fNumMissedGates;
    fNumMissedEventBlocks = input->fNumMissedEventBlocks;
    fNumMultSyncErrors    = input->fNumMultSyncErrors;
    fNumHelicityErrors    = input->fNumHelicityErrors;
  }
}

References Compare(), QwHelicityBase::fNumHelicityErrors, QwHelicityBase::fNumMissedEventBlocks, QwHelicityBase::fNumMissedGates, QwHelicityBase::fNumMultSyncErrors, QwHelicityBase::fPatternNumber, MergeCounters(), QwHelicityDecoder(), and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ ApplySingleEventCuts()

Bool_t QwHelicityDecoder::ApplySingleEventCuts ( )

overridevirtual

Apply the single event cuts.

Reimplemented from QwHelicityBase.

Definition at line 183 of file QwHelicityDecoder.cc.

                                              {
 
  return kTRUE;
}

◆ CheckForBurpFail()

Bool_t QwHelicityDecoder::CheckForBurpFail ( const VQwSubsystem * subsys )

inlineoverridevirtual

Report the number of events failed due to HW and event cut failures.

Reimplemented from QwHelicityBase.

Definition at line 60 of file QwHelicityDecoder.h.

                                                                 {
    return kFALSE;
  };

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ CheckIORegisterMask()

Bool_t QwHelicityDecoder::CheckIORegisterMask	(	const UInt_t &	ioregister,
		const UInt_t &	mask ) const

inline

Definition at line 116 of file QwHelicityDecoder.h.

                                                                                 {
    return ((mask != 0)&&((ioregister & mask) == mask));
  };

◆ CheckPatternNum()

void QwHelicityDecoder::CheckPatternNum ( VQwSubsystem * value )

Definition at line 1192 of file QwHelicityDecoder.cc.

{
  //  Bool_t localdebug=kFALSE;
  if(Compare(value)) {
    QwHelicityDecoder* input= dynamic_cast<QwHelicityDecoder*>(value);
    QwDebug << "QwHelicityDecoder::MergeCounters: this->fPatternNumber=" << this->fPatternNumber
            << ", input->fPatternNumber=" << input->fPatternNumber << QwLog::endl;
 
    this->fErrorFlag |= input->fErrorFlag;
 
    //  Make sure the pattern number and poalrity agree!
    if(this->fPatternNumber!=input->fPatternNumber)
      this->fPatternNumber=-999999;
    if(this->fActualPatternPolarity!=input->fActualPatternPolarity)
      this->fPatternNumber=-999999;
    if (this->fPatternNumber==-999999){
      this->fErrorFlag |= kErrorFlag_Helicity + kGlobalCut + kEventCutMode3;
    }
  }
}

References Compare(), QwLog::endl(), QwHelicityBase::fActualPatternPolarity, QwHelicityBase::fErrorFlag, QwHelicityBase::fPatternNumber, kErrorFlag_Helicity, kEventCutMode3, kGlobalCut, QwDebug, QwHelicityDecoder(), and VQwSubsystem::VQwSubsystem().

Referenced by operator+=(), and Ratio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearEventData()

void QwHelicityDecoder::ClearEventData ( )

overridevirtual

Reset data by setting the old event number, pattern number and pattern phase to the values of the previous event.

Clear out helicity variables

Reimplemented from QwHelicityBase.

Definition at line 140 of file QwHelicityDecoder.cc.

{
  SetDataLoaded(kFALSE);
  for (size_t i=0;i<fWord.size();i++)
    fWord[i].ClearEventData();
 
  /**Reset data by setting the old event number, pattern number and pattern phase
     to the values of the previous event.*/
  if (fEventNumberFirst==-1 && fEventNumberOld!= -1){
    fEventNumberFirst = fEventNumberOld;
  }
  if (fPatternNumberFirst==-1 && fPatternNumberOld!=-1
      && fPatternNumber==fPatternNumberOld+1){
    fPatternNumberFirst = fPatternNumberOld;
  }
 
  fEventNumberOld = fEventNumber;
  fPatternNumberOld = fPatternNumber;
  fPatternPhaseNumberOld = fPatternPhaseNumber;
 
  /**Clear out helicity variables */
  fHelicityReported = kUndefinedHelicity;
  fHelicityActual = kUndefinedHelicity;
  fHelicityDelayed= kUndefinedHelicity;
  fHelicityBitPlus = kFALSE;
  fHelicityBitMinus = kFALSE;
  fEventNumber = -1;
  fPatternPhaseNumber = -1;
  fPatternNumber = -1;
  return;
}

References ClearEventData(), QwHelicityBase::fEventNumber, QwHelicityBase::fEventNumberFirst, QwHelicityBase::fEventNumberOld, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityBitMinus, QwHelicityBase::fHelicityBitPlus, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternNumberFirst, QwHelicityBase::fPatternNumberOld, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternPhaseNumberOld, QwHelicityBase::fWord, kUndefinedHelicity, and VQwSubsystem::SetDataLoaded().

Referenced by ClearEventData().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Compare()

Bool_t QwHelicityDecoder::Compare ( VQwSubsystem * source )

Definition at line 1251 of file QwHelicityDecoder.cc.

{
  Bool_t res=kTRUE;
  if(typeid(*value)!=typeid(*this)) {
    res=kFALSE;
  } else {
    QwHelicityDecoder* input= dynamic_cast<QwHelicityDecoder*>(value);
    if(input->fWord.size()!=fWord.size()) {
      res=kFALSE;
    }
  }
  return res;
}

References QwHelicityBase::fWord, QwHelicityDecoder(), and VQwSubsystem::VQwSubsystem().

Referenced by AccumulateRunningSum(), CheckPatternNum(), MergeCounters(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructBranch() [1/2]

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

overridevirtual

Construct the branch and tree vector.

Construct the branches for this subsystem.

Parameters

tree	Output ROOT tree.
prefix	Name prefix for all branch names.

Reimplemented from QwHelicityBase.

Definition at line 833 of file QwHelicityDecoder.cc.

{
TString basename;
 
  SetHistoTreeSave(prefix);
// print the branch and type name (arindam)
//std::cout << "QwHelicityDecoder::ConstructBranch" << std::endl;
//std::cout << tree->GetName() << " " << prefix << " " << std::endl;
//std::cout << "Histo type --> " << fHistoType << std::endl;
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSaveMPS)
    {
      // basename = "hd_actual_helicity";    //predicted actual helicity before being delayed.
      // tree->Branch(basename, &fHelicityActual, basename+"/I");
      //
      basename = "hd_delayed_helicity";   //predicted delayed helicity
      tree->Branch(basename, &fHelicityDelayed, basename+"/I");
      //
      basename = "hd_reported_helicity";  //delayed helicity reported by the input register.
      tree->Branch(basename, &fHelicityReported, basename+"/I");
      //
      basename = "hd_pattern_phase";
      tree->Branch(basename, &fPatternPhaseNumber, basename+"/I");
      //
      basename = "hd_pattern_number";
      tree->Branch(basename, &fPatternNumber, basename+"/I");
      //
      basename = "hd_pattern_seed";
      tree->Branch(basename, &fPatternSeed, basename+"/I");
      //
      basename = "hd_event_number";
      tree->Branch(basename, &fEventNumber, basename+"/I");
 
      basename = "hd_event_Polarity";
      tree->Branch(basename, &fEventPolarity, basename+"/I");
 
      basename = "hd_Reported_Pattern_Hel";
      tree->Branch(basename, &fReportedPatternHel, basename+"/I");
    }
  else if(fHistoType==kHelSavePattern)
    {
      basename = "hd_actual_helicity";    //predicted actual helicity before being delayed.
      tree->Branch(basename, &fHelicityActual, basename+"/I");
      //
      basename = "hd_actual_pattern_polarity";
      tree->Branch(basename, &fActualPatternPolarity, basename+"/I");
      //
      basename = "hd_actual_previous_pattern_polarity";
      tree->Branch(basename, &fPreviousPatternPolarity, basename+"/I");
      //
      basename = "hd_delayed_pattern_polarity";
      tree->Branch(basename, &fDelayedPatternPolarity, basename+"/I");
     //
      basename = "hd_pattern_number";
      tree->Branch(basename, &fPatternNumber, basename+"/I");
      //
      basename = "hd_pattern_seed";
      tree->Branch(basename, &fPatternSeed, basename+"/I");
 
      for (size_t i=0; i<fWord.size(); i++)
        {
          basename = fWord[i].fWordName;
          tree->Branch(basename, &fWord[i].fValue, basename+"/I");
        }
    }
  //QwError << "entering construct branch should not be here : arindam" << QwLog::endl;
 
  return;
}

References QwHelicityBase::fActualPatternPolarity, QwHelicityBase::fDelayedPatternPolarity, QwHelicityBase::fEventNumber, fEventPolarity, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fHistoType, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternSeed, QwHelicityBase::fPreviousPatternPolarity, fReportedPatternHel, QwHelicityBase::fWord, QwHelicityBase::kHelNoSave, QwHelicityBase::kHelSaveMPS, QwHelicityBase::kHelSavePattern, and SetHistoTreeSave().

Here is the call graph for this function:

◆ ConstructBranch() [2/2]

void QwHelicityDecoder::ConstructBranch	(	TTree *	tree,
		TString &	prefix,
		QwParameterFile &	trim_file )

overridevirtual

Construct the branch and tree vector based on the trim file.

Construct the branches for this subsystem using a trim file.

Parameters

tree	Output ROOT tree.
prefix	Name prefix for all branch names.
trim_file	Trim file describing which branches to construct.

Reimplemented from QwHelicityBase.

Definition at line 906 of file QwHelicityDecoder.cc.

{
  TString basename;
 
  SetHistoTreeSave(prefix);
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSaveMPS)
    {
      // basename = "hd_actual_helicity";    //predicted actual helicity before being delayed.
      // tree->Branch(basename, &fHelicityActual, basename+"/I");
      //
      basename = "hd_delayed_helicity";   //predicted delayed helicity
      tree->Branch(basename, &fHelicityDelayed, basename+"/I");
      //
      basename = "hd_reported_helicity";  //delayed helicity reported by the input register.
      tree->Branch(basename, &fHelicityReported, basename+"/I");
      //
      basename = "hd_pattern_phase";
      tree->Branch(basename, &fPatternPhaseNumber, basename+"/I");
      //
      basename = "hd_pattern_number";
      tree->Branch(basename, &fPatternNumber, basename+"/I");
      //
      basename = "hd_pattern_seed";
      tree->Branch(basename, &fPatternSeed, basename+"/I");
      //
      basename = "hd_event_number";
      tree->Branch(basename, &fEventNumber, basename+"/I");
 
      basename = "hd_event_Polarity";
      tree->Branch(basename, &fEventPolarity, basename+"/I");
 
      basename = "hd_Reported_Pattern_Hel";
      tree->Branch(basename, &fReportedPatternHel, basename+"/I");
    }
  else if(fHistoType==kHelSavePattern)
    {
      basename = "hd_actual_helicity";    //predicted actual helicity before being delayed.
      tree->Branch(basename, &fHelicityActual, basename+"/I");
      //
      basename = "hd_actual_pattern_polarity";
      tree->Branch(basename, &fActualPatternPolarity, basename+"/I");
      //
      basename = "hd_actual_previous_pattern_polarity";
      tree->Branch(basename, &fPreviousPatternPolarity, basename+"/I");
      //
      basename = "hd_delayed_pattern_polarity";
      tree->Branch(basename, &fDelayedPatternPolarity, basename+"/I");
      //
      basename = "hd_pattern_number";
      tree->Branch(basename, &fPatternNumber, basename+"/I");
      //
      basename = "hd_pattern_seed";
      tree->Branch(basename, &fPatternSeed, basename+"/I");
 
      for (size_t i=0; i<fWord.size(); i++)
        {
          basename = fWord[i].fWordName;
          tree->Branch(basename,&fWord[i].fValue, basename+"/I");
        }
 
    }
 
  return;
}

References QwHelicityBase::fActualPatternPolarity, QwHelicityBase::fDelayedPatternPolarity, QwHelicityBase::fEventNumber, fEventPolarity, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fHistoType, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternSeed, QwHelicityBase::fPreviousPatternPolarity, fReportedPatternHel, QwHelicityBase::fWord, QwHelicityBase::kHelNoSave, QwHelicityBase::kHelSaveMPS, QwHelicityBase::kHelSavePattern, and SetHistoTreeSave().

Here is the call graph for this function:

◆ ConstructBranchAndVector() [1/2]

virtual void VQwSubsystem::ConstructBranchAndVector	(	TTree *	tree,
		QwRootTreeBranchVector &	values )

inlinevirtual

Construct the branch and tree vector.

Reimplemented from QwHelicityBase.

Definition at line 303 of file VQwSubsystem.h.

                                                                                     {
    TString tmpstr("");
    ConstructBranchAndVector(tree,tmpstr,values);
  };

◆ ConstructBranchAndVector() [2/2]

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

overridevirtual

Construct the branch and tree vector.

Construct the branch and fill the provided values vector.

Parameters

tree	Output ROOT tree to which branches are added.
prefix	Name prefix for all branch names.
values	Vector that will be filled by FillTreeVector.

Reimplemented from QwHelicityBase.

Definition at line 718 of file QwHelicityDecoder.cc.

{
  SetHistoTreeSave(prefix);
  fTreeArrayIndex  = values.size();
  TString basename;
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSaveMPS)
    {
       basename = "hd_actual_helicity";    //predicted actual helicity before being delayed.
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      basename = "hd_delayed_helicity";   //predicted delayed helicity
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
            basename = "hd_reported_helicity";  //delayed helicity reported by the input register.
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_pattern_phase";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_pattern_number";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_pattern_seed";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_event_number";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      basename = "hd_event_Polarity";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      basename = "hd_Reported_Pattern_Hel";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //new time / status variables
       basename = "hd_num_tstable_fall";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      basename = "hd_num_pair_sync";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      basename = "hd_time_since_tstable";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      basename = "hd_time_since_tsettle";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      basename = "hd_last_duration_tstable";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      basename = "hd_last_duration_tsettle";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
 
      for (size_t i=0; i<fWord.size(); i++)
        {
          basename = fWord[i].fWordName;
          values.push_back(basename, 'I');
          tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
        }
    }
 else if(fHistoType==kHelSavePattern)
    {
      basename = "hd_actual_helicity";    //predicted actual helicity before being delayed.
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_actual_pattern_polarity";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_actual_previous_pattern_polarity";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_delayed_pattern_polarity";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_pattern_number";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "hd_pattern_seed";
       values.push_back(basename, 'I');
       tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      for (size_t i=0; i<fWord.size(); i++)
        {
          basename = fWord[i].fWordName;
          values.push_back(basename, 'I');
          tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
        }
    }
  std::cout << "after construction size " << values.size() << std::endl;
  return;
}

References QwRootTreeBranchVector::back(), QwHelicityBase::fHistoType, QwHelicityBase::fTreeArrayIndex, QwHelicityBase::fWord, QwHelicityBase::kHelNoSave, QwHelicityBase::kHelSaveMPS, QwHelicityBase::kHelSavePattern, QwRootTreeBranchVector::push_back(), SetHistoTreeSave(), and QwRootTreeBranchVector::size().

Here is the call graph for this function:

◆ ConstructHistograms() [1/4]

virtual void VQwSubsystem::ConstructHistograms ( )

inlinevirtual

Construct the histograms for this subsystem.

Reimplemented from QwHelicityBase.

Definition at line 270 of file VQwSubsystem.h.

                                      {
    TString tmpstr("");
    ConstructHistograms((TDirectory*) NULL, tmpstr);
  };

◆ ConstructHistograms() [2/4]

virtual void VQwSubsystem::ConstructHistograms ( TDirectory * folder )

inlinevirtual

Construct the histograms for this subsystem in a folder.

Reimplemented from QwHelicityBase.

Definition at line 275 of file VQwSubsystem.h.

                                                        {
    TString tmpstr("");
    ConstructHistograms(folder, tmpstr);
  };

◆ ConstructHistograms() [3/4]

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

overridevirtual

Construct the histograms for this subsystem in a folder with a prefix.

Reimplemented from QwHelicityBase.

Definition at line 617 of file QwHelicityDecoder.cc.

{
  SetHistoTreeSave(prefix);
  if (folder != NULL) folder->cd();
  TString basename;
  size_t index=0;
 
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSavePattern)
    {
      fHistograms.resize(1+fWord.size(), NULL);
      basename="pattern_polarity";
      fHistograms[index]   = gQwHists.Construct1DHist(basename);
      index+=1;
      for (size_t i=0; i<fWord.size(); i++){
        basename="hel_"+fWord[i].fWordName;
        fHistograms[index]   = gQwHists.Construct1DHist(basename);
        index+=1;
      }
    }
  else if(fHistoType==kHelSaveMPS)
    {
      fHistograms.resize(4+fWord.size(), NULL);
      //eventnumber, patternnumber, helicity, patternphase + fWord.size
      basename=prefix+"delta_event_number";
      fHistograms[index]   = gQwHists.Construct1DHist(basename);
      index+=1;
      basename=prefix+"delta_pattern_number";
      fHistograms[index]   = gQwHists.Construct1DHist(basename);
      index+=1;
      basename=prefix+"pattern_phase";
      fHistograms[index]   = gQwHists.Construct1DHist(basename);
      index+=1;
      basename=prefix+"helicity";
      fHistograms[index]   = gQwHists.Construct1DHist(basename);
      index+=1;
      for (size_t i=0; i<fWord.size(); i++){
        basename=prefix+fWord[i].fWordName;
        fHistograms[index]   = gQwHists.Construct1DHist(basename);
        index+=1;
      }
    }
  else
    QwError << "QwHelicityDecoder::ConstructHistograms this prefix--" << prefix << "-- is not unknown:: no histo created" << QwLog::endl;
 
  return;
}

References QwLog::endl(), MQwHistograms::fHistograms, QwHelicityBase::fHistoType, QwHelicityBase::fWord, gQwHists, QwHelicityBase::kHelNoSave, QwHelicityBase::kHelSaveMPS, QwHelicityBase::kHelSavePattern, QwError, and SetHistoTreeSave().

Here is the call graph for this function:

◆ ConstructHistograms() [4/4]

virtual void VQwSubsystem::ConstructHistograms ( TString & prefix )

inlinevirtual

Construct the histograms for this subsystem with a prefix.

Reimplemented from QwHelicityBase.

Definition at line 280 of file VQwSubsystem.h.

                                                     {
    ConstructHistograms((TDirectory*) NULL, prefix);
  };

◆ DeaccumulateRunningSum()

void QwHelicityDecoder::DeaccumulateRunningSum	(	VQwSubsystem *	value,
		Int_t	ErrorMask = 0xFFFFFFF )

inlineoverridevirtual

remove one entry from the running sums for devices

Reimplemented from QwHelicityBase.

Definition at line 98 of file QwHelicityDecoder.h.

98{ };

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ DefineOptions()

void QwHelicityDecoder::DefineOptions ( QwOptions & options )

static

Define options function.

Definition at line 51 of file QwHelicityDecoder.cc.

{
  options.AddOptions("Helicity options")
      ("helicity.seed", po::value<int>(),
          "Number of bits in random seed");
  options.AddOptions("Helicity options")
      ("helicity.bitpattern", po::value<std::string>(),
          "Helicity bit pattern: 0x1 (pair), 0x9 (quartet), 0x69 (octet), 0x666999 (hexo-quad), 0x66669999 (octo-quad)");
  options.AddOptions("Helicity options")
      ("helicity.patternoffset", po::value<int>(),
          "Set 1 when pattern starts with 1 or 0 when starts with 0");
  options.AddOptions("Helicity options")
      ("helicity.patternphase", po::value<int>(),
          "Maximum pattern phase");
  options.AddOptions("Helicity options")
      ("helicity.delay", po::value<int>(),
          "Default delay is 2 patterns, set at the helicity map file.");
  options.AddOptions("Helicity options")
      ("helicity.toggle-mode", po::value<bool>()->default_bool_value(false),
          "Activates helicity toggle-mode, overriding the 'delay', 'patternphase', 'bitpattern', and 'seed' options.");
}

References QwOptions::AddOptions().

Here is the call graph for this function:

◆ EncodeEventData()

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

overridevirtual

Reimplemented from VQwSubsystem.

Definition at line 251 of file QwHelicityDecoder.cc.

252{

253}

◆ FillHDVariables()

void QwHelicityDecoder::FillHDVariables	(	uint32_t	data,
		uint32_t	index )

Definition at line 538 of file QwHelicityDecoder.cc.

                                                                     {
 
  switch (index) {
  case 0:
    fSeed_Reported=data;
    break;
  case 1:
    fNum_TStable_Fall=data;
    break;
  case 2:
    fEventNumber=data;
    break;
  case 3:
    fPatternNumber=data;
    break;
  case 4:
    fNum_Pair_Sync=data;
    break;
  case 5:
    fTime_since_TStable=data;
    break;
  case 6:
    fTime_since_TSettle=data;
    break;
  case 7:
    fLast_Duration_TStable=data;
    break;
  case 8:
    fLast_Duration_TSettle=data;
    break;
  case 9:
    fPatternPhaseNumber = ((data>>8) & 0xff)+1;
    fEventPolarity      = (data>>5) & 0x1;
    fReportedPatternHel = (data>>4) & 0x1;
    fBit_Helicity       = (data>>3) & 0x1;
    fBit_PairSync       = (data>>2) & 0x1;
    fBit_PatSync        = (data>>1) & 0x1;
    fBit_TStable        = data      & 0x1;
    break;
  case 10:
    fEvtHistory_PatSync=data;
    break;
  case 11:
    fEvtHistory_PairSync=data;
    break;
  case 12:
    fEvtHistory_ReportedHelicity=data;
    break;
  case 13:
    fPatHistory_ReportedHelicity=data;
    break;
  }
}

References fBit_Helicity, fBit_PairSync, fBit_PatSync, fBit_TStable, QwHelicityBase::fEventNumber, fEventPolarity, fEvtHistory_PairSync, fEvtHistory_PatSync, fEvtHistory_ReportedHelicity, fLast_Duration_TSettle, fLast_Duration_TStable, fNum_Pair_Sync, fNum_TStable_Fall, fPatHistory_ReportedHelicity, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternPhaseNumber, fReportedPatternHel, fSeed_Reported, fTime_since_TSettle, and fTime_since_TStable.

Referenced by ProcessEvBuffer().

Here is the caller graph for this function:

◆ FillHistograms()

void QwHelicityDecoder::FillHistograms ( )

overridevirtual

Fill the histograms for this subsystem.

Reimplemented from QwHelicityBase.

Definition at line 668 of file QwHelicityDecoder.cc.

{
  if (fHistograms.size()==0){return;}
  size_t index=0;
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSavePattern)
    {
      QwDebug << "QwHelicityDecoder::FillHistograms helicity info " << QwLog::endl;
      QwDebug << "QwHelicityDecoder::FillHistograms  pattern polarity=" << fActualPatternPolarity << QwLog::endl;
      if (fHistograms[index]!=NULL)
        fHistograms[index]->Fill(fActualPatternPolarity);
      index+=1;
 
      for (size_t i=0; i<fWord.size(); i++){
        if (fHistograms[index]!=NULL)
          fHistograms[index]->Fill(fWord[i].fValue);
        index+=1;
        QwDebug << "QwHelicityDecoder::FillHistograms " << fWord[i].fWordName << "=" << fWord[i].fValue << QwLog::endl;
      }
    }
  else if(fHistoType==kHelSaveMPS)
    {
      QwDebug << "QwHelicityDecoder::FillHistograms mps info " << QwLog::endl;
      if (fHistograms[index]!=NULL)
        fHistograms[index]->Fill(fEventNumber-fEventNumberOld);
      index+=1;
      if (fHistograms[index]!=NULL)
        fHistograms[index]->Fill(fPatternNumber-fPatternNumberOld);
      index+=1;
      if (fHistograms[index]!=NULL)
        fHistograms[index]->Fill(fPatternPhaseNumber);
      index+=1;
      if (fHistograms[index]!=NULL)
        fHistograms[index]->Fill(fHelicityActual);
      index+=1;
      for (size_t i=0; i<fWord.size(); i++){
        if (fHistograms[index]!=NULL)
          fHistograms[index]->Fill(fWord[i].fValue);
        index+=1;
        QwDebug << "QwHelicityDecoder::FillHistograms " << fWord[i].fWordName << "=" << fWord[i].fValue << QwLog::endl;
      }
    }
 
  return;
}

References QwLog::endl(), QwHelicityBase::fActualPatternPolarity, QwHelicityBase::fEventNumber, QwHelicityBase::fEventNumberOld, QwHelicityBase::fHelicityActual, MQwHistograms::fHistograms, QwHelicityBase::fHistoType, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternNumberOld, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fWord, QwHelicityBase::kHelNoSave, QwHelicityBase::kHelSaveMPS, QwHelicityBase::kHelSavePattern, and QwDebug.

Here is the call graph for this function:

◆ FillTreeVector()

void QwHelicityDecoder::FillTreeVector ( QwRootTreeBranchVector & values ) const

overridevirtual

Fill the tree vector.

Fill the tree export vector with the current event values.

Parameters

values Output vector to be filled.

Reimplemented from QwHelicityBase.

Definition at line 975 of file QwHelicityDecoder.cc.

{
 
  size_t index=fTreeArrayIndex;
  if(fHistoType==kHelSaveMPS)
    {
      values.SetValue(index++, fHelicityActual);
      values.SetValue(index++, fHelicityDelayed);
      values.SetValue(index++, fHelicityReported);
      values.SetValue(index++, fPatternPhaseNumber);
      values.SetValue(index++, fPatternNumber);
      values.SetValue(index++, fPatternSeed);
      values.SetValue(index++, fEventNumber);
      values.SetValue(index++, fEventPolarity);
      values.SetValue(index++, fReportedPatternHel);
       // NEW TIME / STATUS VARIABLES
      values.SetValue(index++, fNum_TStable_Fall);
      values.SetValue(index++, fNum_Pair_Sync);
      values.SetValue(index++, fTime_since_TStable);
      values.SetValue(index++, fTime_since_TSettle);
      values.SetValue(index++, fLast_Duration_TStable);
      values.SetValue(index++, fLast_Duration_TSettle);
 
      for (size_t i=0; i<fWord.size(); i++)
        values.SetValue(index++, fWord[i].fValue);
    }
  else if(fHistoType==kHelSavePattern)
    {
      values.SetValue(index++, fHelicityActual);
      values.SetValue(index++, fActualPatternPolarity);
      values.SetValue(index++, fPreviousPatternPolarity);
      values.SetValue(index++, fDelayedPatternPolarity);
      values.SetValue(index++, fPatternNumber);
      values.SetValue(index++, fPatternSeed);
      for (size_t i=0; i<fWord.size(); i++){
        values.SetValue(index++, fWord[i].fValue);
      }
    }
 
  return;
}

References QwHelicityBase::fActualPatternPolarity, QwHelicityBase::fDelayedPatternPolarity, QwHelicityBase::fEventNumber, fEventPolarity, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fHistoType, fLast_Duration_TSettle, fLast_Duration_TStable, fNum_Pair_Sync, fNum_TStable_Fall, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternSeed, QwHelicityBase::fPreviousPatternPolarity, fReportedPatternHel, fTime_since_TSettle, fTime_since_TStable, QwHelicityBase::fTreeArrayIndex, QwHelicityBase::fWord, QwHelicityBase::kHelSaveMPS, QwHelicityBase::kHelSavePattern, and QwRootTreeBranchVector::SetValue().

Here is the call graph for this function:

◆ GetRandomSeedActual()

UInt_t QwHelicityDecoder::GetRandomSeedActual ( )

inline

Definition at line 80 of file QwHelicityDecoder.h.

80{ return iseed_Actual; };

QwHelicityBase::iseed_Actual

UInt_t iseed_Actual

Definition QwHelicityBase.h:235

References QwHelicityBase::iseed_Actual.

◆ GetRandomSeedDelayed()

UInt_t QwHelicityDecoder::GetRandomSeedDelayed ( )

inline

Definition at line 81 of file QwHelicityDecoder.h.

81{ return iseed_Delayed; };

QwHelicityBase::iseed_Delayed

UInt_t iseed_Delayed

Definition QwHelicityBase.h:236

References QwHelicityBase::iseed_Delayed.

◆ LoadChannelMap()

Int_t QwHelicityDecoder::LoadChannelMap ( TString mapfile )

overridevirtual

Mandatory map file definition.

Reimplemented from QwHelicityBase.

Definition at line 277 of file QwHelicityDecoder.cc.

{
  UInt_t value = 0;
  TString valuestr;
 
  QwParameterFile mapstr(mapfile.Data());  //Open the file
  fDetectorMaps.insert(mapstr.GetParamFileNameContents());
  mapstr.EnableGreediness();
  mapstr.SetCommentChars("!");
 
  while (mapstr.ReadNextLine()){
    //  This class doesn't have any normal decode lines in the map file,
    //  so there is nothing to do in this loop.  We just need the one
    //  call to "ReadNextLine" to populate the list of key/vale pairs.
 
    // std::cout << "in the loop: " << mapstr.GetLine() << std::endl;
    // RegisterRocBankMarker(mapstr);
  }
  //std::cout << "finished loop" << std::endl;
 
  //  Call "RegisterRocBankMarker" to record the ROC/Bank our data is in.
  RegisterRocBankMarker(mapstr);
 
  //  If we have other key/values we want to use, we'd need to go though
  //  them here to see if they were found in the mapfile.
  if (mapstr.PopValue("patternphase",value)) {
    fMaxPatternPhase=value;
    //QwMessage << " fMaxPatternPhase " << fMaxPatternPhase << QwLog::endl;
  }
 
 
  //PrintInfo();
  return 0;
}

References QwParameterFile::EnableGreediness(), VQwSubsystem::fDetectorMaps, QwHelicityBase::fMaxPatternPhase, QwParameterFile::GetParamFileNameContents(), QwParameterFile::PopValue(), QwParameterFile::ReadNextLine(), VQwSubsystem::RegisterRocBankMarker(), and QwParameterFile::SetCommentChars().

Here is the call graph for this function:

◆ LoadEventCuts()

Int_t QwHelicityDecoder::LoadEventCuts ( TString )

overridevirtual

Optional event cut file.

Reimplemented from QwHelicityBase.

Definition at line 313 of file QwHelicityDecoder.cc.

◆ LoadInputParameters()

Int_t QwHelicityDecoder::LoadInputParameters ( TString mapfile )

overridevirtual

Mandatory parameter file definition.

Reimplemented from QwHelicityBase.

Definition at line 177 of file QwHelicityDecoder.cc.

{
  return 0;
}

◆ MergeCounters()

void QwHelicityDecoder::MergeCounters ( VQwSubsystem * value )

Definition at line 1213 of file QwHelicityDecoder.cc.

{
  //  Bool_t localdebug=kFALSE;
  if(Compare(value)) {
    QwHelicityDecoder* input= dynamic_cast<QwHelicityDecoder*>(value);
 
    fEventNumber = (fEventNumber == 0) ? input->fEventNumber :
      std::min(fEventNumber, input->fEventNumber);
    for (size_t i=0; i<fWord.size(); i++) {
      fWord[i].fValue =  (fWord[i].fValue == 0) ? input->fWord[i].fValue :
        std::min( fWord[i].fValue, input->fWord[i].fValue);
    }
  }
}

References Compare(), QwHelicityBase::fEventNumber, QwHelicityBase::fWord, QwHelicityDecoder(), and VQwSubsystem::VQwSubsystem().

Referenced by AccumulateRunningSum(), operator+=(), and Ratio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator+=()

VQwSubsystem & QwHelicityDecoder::operator+= ( VQwSubsystem * value )

overridevirtual

Reimplemented from QwHelicityBase.

Definition at line 1178 of file QwHelicityDecoder.cc.

{
  //  Bool_t localdebug=kFALSE;
  QwDebug << "Entering QwHelicityDecoder::operator+= adding " << value->GetName() << " to " << this->GetName() << " " << QwLog::endl;
 
  //this routine is most likely to be called during the computation of asymmetry
  //this call doesn't make too much sense for this class so the following lines
  //are only use to put safe gards testing for example if the two instantiation indeed
  // refers to elements in the same pattern.
  CheckPatternNum(value);
  MergeCounters(value);
  return *this;
}

References CheckPatternNum(), QwLog::endl(), VQwSubsystem::GetName(), MergeCounters(), QwDebug, and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ operator-=()

VQwSubsystem & QwHelicityDecoder::operator-= ( VQwSubsystem * value )

inlineoverridevirtual

Reimplemented from QwHelicityBase.

Definition at line 93 of file QwHelicityDecoder.h.

93{return *this;};

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ operator=()

VQwSubsystem & QwHelicityDecoder::operator= ( VQwSubsystem * value )

overridevirtual

Assignment Note: Must be called at the beginning of all subsystems routine call to operator=(VQwSubsystem *value) by VQwSubsystem::operator=(value)

Reimplemented from QwHelicityBase.

Definition at line 1123 of file QwHelicityDecoder.cc.

{
  Bool_t ldebug = kFALSE;
  if(Compare(value))
    {
 
       //QwHelicityDecoder* input= (QwHelicityDecoder*)value;
      VQwSubsystem::operator=(value);
      QwHelicityDecoder* input= dynamic_cast<QwHelicityDecoder*>(value);
 
      for(size_t i=0;i<input->fWord.size();i++)
        this->fWord[i].fValue=input->fWord[i].fValue;
      this->fHelicityActual = input->fHelicityActual;
      this->fPatternNumber  = input->fPatternNumber;
      this->fPatternSeed    = input->fPatternSeed;
      this->fPatternPhaseNumber=input->fPatternPhaseNumber;
      this->fEventNumber=input->fEventNumber;
      this->fActualPatternPolarity=input->fActualPatternPolarity;
      this->fDelayedPatternPolarity=input->fDelayedPatternPolarity;
      this->fPreviousPatternPolarity=input->fPreviousPatternPolarity;
      this->fHelicityReported=input->fHelicityReported;
      this->fHelicityActual=input->fHelicityActual;
      this->fHelicityDelayed=input->fHelicityDelayed;
      this->fHelicityBitPlus=input->fHelicityBitPlus;
      this->fHelicityBitMinus=input->fHelicityBitMinus;
      this->fGoodHelicity=input->fGoodHelicity;
      this->fGoodPattern=input->fGoodPattern;
      this->fIgnoreHelicity = input->fIgnoreHelicity;
      this->fEventPolarity = input->fEventPolarity;
      this->fReportedPatternHel = input->fReportedPatternHel;
      //new time / status variables
      this->fNum_TStable_Fall     = input->fNum_TStable_Fall;
      this->fNum_Pair_Sync        = input->fNum_Pair_Sync;
      this->fTime_since_TStable   = input->fTime_since_TStable;
      this->fTime_since_TSettle   = input->fTime_since_TSettle;
      this->fLast_Duration_TStable = input->fLast_Duration_TStable;
      this->fLast_Duration_TSettle = input->fLast_Duration_TSettle;
 
      this->fErrorFlag = input->fErrorFlag;
      this->fEventNumberFirst     = input->fEventNumberFirst;
      this->fPatternNumberFirst   = input->fPatternNumberFirst;
      this->fNumMissedGates       = input->fNumMissedGates;
      this->fNumMissedEventBlocks = input->fNumMissedEventBlocks;
      this->fNumMultSyncErrors    = input->fNumMultSyncErrors;
      this->fNumHelicityErrors    = input->fNumHelicityErrors;
 
      if(ldebug){
        std::cout << "QwHelicityDecoder::operator = this->fPatternNumber=" << this->fPatternNumber << std::endl;
        std::cout << "input->fPatternNumber=" << input->fPatternNumber << "\n";
      }
    }
 
  return *this;
}

References Compare(), QwHelicityBase::fActualPatternPolarity, QwHelicityBase::fDelayedPatternPolarity, QwHelicityBase::fErrorFlag, QwHelicityBase::fEventNumber, QwHelicityBase::fEventNumberFirst, fEventPolarity, QwHelicityBase::fGoodHelicity, QwHelicityBase::fGoodPattern, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityBitMinus, QwHelicityBase::fHelicityBitPlus, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fIgnoreHelicity, fLast_Duration_TSettle, fLast_Duration_TStable, fNum_Pair_Sync, fNum_TStable_Fall, QwHelicityBase::fNumHelicityErrors, QwHelicityBase::fNumMissedEventBlocks, QwHelicityBase::fNumMissedGates, QwHelicityBase::fNumMultSyncErrors, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternNumberFirst, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternSeed, QwHelicityBase::fPreviousPatternPolarity, fReportedPatternHel, fTime_since_TSettle, fTime_since_TStable, QwHelicityBase::fWord, VQwSubsystem::operator=(), QwHelicityDecoder(), and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ PredictHelicity()

void QwHelicityDecoder::PredictHelicity ( )

Definition at line 1068 of file QwHelicityDecoder.cc.

{
   Bool_t ldebug=kFALSE;
 
   if(ldebug)  std::cout << "Entering QwHelicityDecoder::PredictHelicity \n";
   if(ldebug)  std::cout << "QwHelicityDecoder::PredictHelicity=>Predicting the  helicity \n";
     RunPredictor();
 
   if(ldebug)  std::cout << "n_ranbit exiting the function = " << n_ranbits << "\n";
 
   return;
}

References QwHelicityBase::n_ranbits, and RunPredictor().

Referenced by ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Print()

void QwHelicityDecoder::Print ( ) const

Definition at line 255 of file QwHelicityDecoder.cc.

{
  QwOut << "===========================\n"
        << "This event: Event#, Pattern#, PatternPhase#="
        << fEventNumber << ", "
        << fPatternNumber << ", "
        << fPatternPhaseNumber << QwLog::endl;
  QwOut << "Previous event: Event#, Pattern#, PatternPhase#="
        << fEventNumberOld << ", "
        << fPatternNumberOld << ", "
        << fPatternPhaseNumberOld << QwLog::endl;
  QwOut << "delta = \n(fEventNumberOld)-(fMaxPatternPhase)x(fPatternNumberOld)-(fPatternPhaseNumberOld)= "
        << ((fEventNumberOld)-(fMaxPatternPhase)*(fPatternNumberOld)-(fPatternPhaseNumberOld)) << QwLog::endl;
  QwOut << "Helicity Reported, Delayed, Actual ="
        << fHelicityReported << ","
        << fHelicityDelayed << ","
        << fHelicityActual << QwLog::endl;
  QwOut << "===" << QwLog::endl;
  return;
}

References QwLog::endl(), QwHelicityBase::fEventNumber, QwHelicityBase::fEventNumberOld, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fMaxPatternPhase, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternNumberOld, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternPhaseNumberOld, and QwOut.

Here is the call graph for this function:

◆ ProcessConfigurationBuffer()

Int_t QwHelicityDecoder::ProcessConfigurationBuffer	(	const ROCID_t	roc_id,
		const BankID_t	bank_id,
		UInt_t *	buffer,
		UInt_t	num_words )

overridevirtual

Reimplemented from QwHelicityBase.

Definition at line 172 of file QwHelicityDecoder.cc.

{
  return 0;
}

◆ ProcessEvBuffer() [1/2]

Int_t QwHelicityDecoder::ProcessEvBuffer	(	const ROCID_t	roc_id,
		const BankID_t	bank_id,
		UInt_t *	buffer,
		UInt_t	num_words )

inlinevirtual

TODO: The non-event-type-aware ProcessEvBuffer routine should be replaced with the event-type-aware version.

Reimplemented from QwHelicityBase.

Definition at line 69 of file QwHelicityDecoder.h.

                                                                                                         {
    return ProcessEvBuffer(0x1,roc_id,bank_id,buffer,num_words);
  };

References ProcessEvBuffer().

Referenced by ProcessEvBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessEvBuffer() [2/2]

Int_t QwHelicityDecoder::ProcessEvBuffer	(	UInt_t	ev_type,
		const ROCID_t	roc_id,
		const BankID_t	bank_id,
		UInt_t *	buffer,
		UInt_t	num_words )

overridevirtual

Reimplemented from QwHelicityBase.

Definition at line 318 of file QwHelicityDecoder.cc.

{
 
  Bool_t lkDEBUG = kFALSE;
  //std::cout << " roc id = " << roc_id << "bank id = " << bank_id << std::endl;
  Int_t index = GetSubbankIndex(roc_id,bank_id);
  //std::cout << "index = " << index << std::endl;
  if (index >= 0 && num_words > 0) {
    SetDataLoaded(kTRUE);
 // lkDEBUG=kTRUE;
 
  uint32_t type_last = 15;       /* initialize to type FILLER WORD */
  uint32_t time_last = 0;
  uint32_t decoder_index = 0;
  uint32_t num_decoder_words = 1;
 
  uint32_t slot_id_ev_hd = 0;
  uint32_t slot_id_dnv = 0;
  uint32_t slot_id_fill = 0;
 
  uint32_t new_type;
  uint32_t type;
  uint32_t slot_id_hd;
  uint32_t mod_id_hd;
  uint32_t slot_id_tr;
  uint32_t n_evts;
  uint32_t blk_num;
  uint32_t n_words;
  uint32_t evt_num_1;
  uint32_t trig_time;
  uint32_t time_now=0;
  uint32_t time_1;
  uint32_t time_2;
 
  uint32_t data;
 
  if (num_words<fNumDecoderWords+4){
    std::cerr << "Not enough words in the bank:"<< std::endl;
    return kFALSE;
 
  } else
    for (size_t i=0; i<num_words; i++){
 
      data = buffer[i];
      if(decoder_index)             /* decoder type data word - set by decoder header word */
        {
          type = 16;        /*  set decoder data words as type 16 */
          new_type = 0;
          if(decoder_index < num_decoder_words)
            {
              FillHDVariables(data, decoder_index - 1);
              if(lkDEBUG)
                printf("%8X - decoder data(%d) = %d\n", data, (decoder_index - 1),
                       data);
              decoder_index++;
            }
          else                      /* last decoder word */
 
            {
              FillHDVariables(data, decoder_index - 1);
              if(lkDEBUG)
                printf("%8X - decoder data(%d) = %d\n", data, (decoder_index - 1),
                       data);
              decoder_index = 0;
              num_decoder_words = 1;
            }
        }
      else                          /* normal typed word */
        {
          if(data & 0x80000000)     /* data type defining word */
            {
              new_type = 1;
              type = (data & 0x78000000) >> 27;
            }
          else                      /* data type continuation word */
            {
              new_type = 0;
              type = type_last;
            }
 
          switch (type)
            {
            case 0:         /* BLOCK HEADER */
              slot_id_hd = (data & 0x7C00000) >> 22;
              mod_id_hd = (data & 0x3C0000) >> 18;
              n_evts = (data & 0x000FF);
              blk_num = (data & 0x3FF00) >> 8;
              if(lkDEBUG)
                printf
                  ("%8X - BLOCK HEADER - slot = %d  id = %d  n_evts = %d  n_blk = %d\n",
                   data, slot_id_hd, mod_id_hd, n_evts,
                   blk_num);
              break;
 
            case 1:         /* BLOCK TRAILER */
              slot_id_tr = (data & 0x7C00000) >> 22;
              n_words = (data & 0x3FFFFF);
              if(lkDEBUG)
                printf("%8X - BLOCK TRAILER - slot = %d   n_words = %d\n",
                       data, slot_id_tr, n_words);
              break;
 
            case 2:         /* EVENT HEADER */
              if(new_type)
                {
                  slot_id_ev_hd = (data & 0x07C00000) >> 22;
                  evt_num_1 = (data & 0x00000FFF);
                  trig_time = (data & 0x003FF000) >> 12;
                  if(lkDEBUG)
                    printf
                      ("%8X - EVENT HEADER - slot = %d  evt_num = %d  trig_time = %d (%X)\n",
                       data, slot_id_ev_hd, evt_num_1, trig_time,
                       trig_time);
                }
              break;
 
            case 3:         /* TRIGGER TIME */
 
              if(new_type)
                {
                  time_1 = (data & 0x7FFFFFF);
                  if(lkDEBUG)
                    printf("%8X - TRIGGER TIME 1 - time = %X\n", data,
                           time_1);
                  time_now = 1;
                  time_last = 1;
                }
              else
                {
                  if(time_last == 1)
                    {
                      time_2 = (data & 0xFFFFF);
                      if(lkDEBUG)
                        printf("%8X - TRIGGER TIME 2 - time = %X\n", data,
                               time_2);
                      time_now = 2;
                    }
                  else if(lkDEBUG)
                    printf("%8X - TRIGGER TIME - (ERROR)\n", data);
 
                  time_last = time_now;
                }
          break;
 
            case 4:         /* UNDEFINED TYPE */
              if(lkDEBUG)
                printf("%8X - UNDEFINED TYPE = %d\n", data, type);
              break;
 
            case 5:         /* UNDEFINED TYPE */
              if(lkDEBUG)
                printf("%8X - UNDEFINED TYPE = %d\n", data, type);
              break;
 
            case 6:         /* UNDEFINED TYPE */
              if(lkDEBUG)
                printf("%8X - UNDEFINED TYPE = %d\n", data, type);
              break;
 
            case 7:         /* UNDEFINED TYPE */
              if(lkDEBUG)
                printf("%8X - UNDEFINED TYPE = %d\n", data, type);
              break;
 
            case 8:         /* DECODER HEADER */
              num_decoder_words = (data & 0x3F);    /* number of decoder words to follow */
              decoder_index = 1;    /* identify next word as a decoder data word */
              if(lkDEBUG)
                printf("%8X - DECODER HEADER = %d  (NUM DECODER WORDS = %d)\n",
                       data, type, num_decoder_words);
              break;
 
            case 9:         /* UNDEFINED TYPE */
              if(lkDEBUG)
                printf("%8X - UNDEFINED TYPE = %d\n", data, type);
              break;
 
            case 10:                /* UNDEFINED TYPE */
              if(lkDEBUG)
                printf("%8X - UNDEFINED TYPE = %d\n", data, type);
              break;
 
            case 11:                /* UNDEFINED TYPE */
              if(lkDEBUG)
                printf("%8X - UNDEFINED TYPE = %d\n", data, type);
              break;
 
            case 12:                /* UNDEFINED TYPE */
              if(lkDEBUG)
                printf("%8X - UNDEFINED TYPE = %d\n", data, type);
              break;
 
            case 13:                /* END OF EVENT */
              if(lkDEBUG)
                printf("%8X - END OF EVENT = %d\n", data, type);
              break;
 
            case 14:                /* DATA NOT VALID (no data available) */
              slot_id_dnv = (data & 0x7C00000) >> 22;
              if(lkDEBUG)
                printf("%8X - DATA NOT VALID = %d  slot = %d\n", data,
                       type, slot_id_dnv);
              break;
 
            case 15:                /* FILLER WORD */
              slot_id_fill = (data & 0x7C00000) >> 22;
              if(lkDEBUG)
                printf("%8X - FILLER WORD = %d  slot = %d\n", data, type,
                       slot_id_fill);
              break;
            }
 
          type_last = type; /* save type of current data word */
 
        }
    }
  }
  return 0;
}

References FillHDVariables(), fNumDecoderWords, VQwSubsystem::GetSubbankIndex(), and VQwSubsystem::SetDataLoaded().

Here is the call graph for this function:

◆ ProcessEvent()

void QwHelicityDecoder::ProcessEvent ( )

overridevirtual

Implements VQwSubsystem.

Definition at line 188 of file QwHelicityDecoder.cc.

{
  Bool_t ldebug = kFALSE;
  fErrorFlag = 0;
 
  if (! HasDataLoaded()) return;
 
  static Bool_t firstpattern = kTRUE;
 
  if(firstpattern && fPatternNumber > fPatternNumberOld){
    firstpattern = kFALSE;
  }
 
  if((fEventNumberFirst!=-1) && (fEventNumber!=(fEventNumberOld+1))){
    Int_t nummissed(fEventNumber - (fEventNumberOld+1));
    QwError << "QwHelicityDecoder::ProcessEvent read event# ("
            << fEventNumber << ") is not  old_event#+1; missed "
            << nummissed << " gates" << QwLog::endl;
    fNumMissedGates += nummissed;
    fNumMissedEventBlocks++;
  }
 
  fHelicityReported=fBit_Helicity;
 
  if (fHelicityReported == 1){
    fHelicityBitPlus=kTRUE;
    fHelicityBitMinus=kFALSE;
  } else {
    fHelicityBitPlus=kFALSE;
    fHelicityBitMinus=kTRUE;
  }
 
 
  if(fHelicityBitPlus==fHelicityBitMinus)
    fHelicityReported=-1;
 
  // Predict helicity if delay is non zero.
  if(fUsePredictor && !fIgnoreHelicity){
    PredictHelicity();
  } else {
    // Else use the reported helicity values.
    fHelicityActual  = fHelicityReported;
    fHelicityDelayed = fHelicityReported;
  }
 
  fPatternSeed = fSeed_Reported & 0x7fffffff;
 
  if(ldebug){
    std::cout<<"\nevent number= "<<fEventNumber<<std::endl;
    std::cout<<"pattern number = "<<fPatternNumber<<std::endl;
    std::cout<<"pattern phase = "<<fPatternPhaseNumber<<std::endl;
    std::cout<<"max pattern phase = "<<fMaxPatternPhase<<std::endl;
    std::cout<<"min pattern phase = "<<fMinPatternPhase<<std::endl;
    std::cout << "Helicity Info: [Reported = " << fHelicityReported
          << ", Delayed = " << fHelicityDelayed
          << ", Actual = " << fHelicityActual << "]" << std::endl;
 
 
  }
  return;
}

References QwLog::endl(), fBit_Helicity, QwHelicityBase::fErrorFlag, QwHelicityBase::fEventNumber, QwHelicityBase::fEventNumberFirst, QwHelicityBase::fEventNumberOld, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityBitMinus, QwHelicityBase::fHelicityBitPlus, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fIgnoreHelicity, QwHelicityBase::fMaxPatternPhase, QwHelicityBase::fMinPatternPhase, QwHelicityBase::fNumMissedEventBlocks, QwHelicityBase::fNumMissedGates, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternNumberOld, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternSeed, fSeed_Reported, QwHelicityBase::fUsePredictor, VQwSubsystem::HasDataLoaded(), PredictHelicity(), and QwError.

Here is the call graph for this function:

◆ ProcessOptions()

void QwHelicityDecoder::ProcessOptions ( QwOptions & )

overridevirtual

Process the command line options.

Reimplemented from QwHelicityBase.

Definition at line 75 of file QwHelicityDecoder.cc.

{
 // Read the cmd options and override channel map settings
  QwMessage << "QwHelicityDecoder::ProcessOptions" << QwLog::endl;
  if (options.HasValue("helicity.patternoffset")) {
    if (options.GetValue<int>("helicity.patternoffset") == 1
     || options.GetValue<int>("helicity.patternoffset") == 0) {
      fPatternPhaseOffset = options.GetValue<int>("helicity.patternoffset");
      QwMessage << " Pattern Phase Offset = " << fPatternPhaseOffset << QwLog::endl;
    } else QwError << "Pattern phase offset should be 0 or 1!" << QwLog::endl;
  }
 
  if (options.HasValue("helicity.patternphase")) {
    if (options.GetValue<int>("helicity.patternphase") % 2 == 0) {
      fMaxPatternPhase = options.GetValue<int>("helicity.patternphase");
      QwMessage << " Maximum Pattern Phase = " << fMaxPatternPhase << QwLog::endl;
    } else QwError << "Pattern phase should be an even integer!" << QwLog::endl;
  }
 
  if (options.HasValue("helicity.seed")) {
    if (options.GetValue<int>("helicity.seed") == 24
     || options.GetValue<int>("helicity.seed") == 30) {
      QwMessage << " Random Bits = " << options.GetValue<int>("helicity.seed") << QwLog::endl;
      fRandBits = options.GetValue<int>("helicity.seed");
    } else QwError << "Number of random seed bits should be 24 or 30!" << QwLog::endl;
  }
 
  if (options.HasValue("helicity.delay")) {
    QwMessage << " Helicity Delay = " << options.GetValue<int>("helicity.delay") << QwLog::endl;
    SetHelicityDelay(options.GetValue<int>("helicity.delay"));
  }
 
  if (options.HasValue("helicity.bitpattern")) {
    QwMessage << " Helicity Pattern ="
              << options.GetValue<std::string>("helicity.bitpattern")
              << QwLog::endl;
    std::string hex = options.GetValue<std::string>("helicity.bitpattern");
    //UInt_t bits = QwParameterFile::GetUInt(hex);
    SetHelicityBitPattern(hex);
  } else {
    BuildHelicityBitPattern(fMaxPatternPhase);
  }
 
  if (options.GetValue<bool>("helicity.toggle-mode")) {
    fHelicityDelay   = 0;
    fUsePredictor    = kFALSE;
    fMaxPatternPhase = 2;
    fHelicityBitPattern = kDefaultHelicityBitPattern;
  }
 
  //  If we have the default Helicity Bit Pattern & a large fMaxPatternPhase,
  //  try to recompute the Helicity Bit Pattern.
  if (fMaxPatternPhase > 8 && fHelicityBitPattern == kDefaultHelicityBitPattern) {
    BuildHelicityBitPattern(fMaxPatternPhase);
  }
 
  //  Here we're going to try to get the "online" option which
  //  is defined by QwEventBuffer.
  if (options.HasValue("online")){
    fSuppressMPSErrorMsgs = options.GetValue<bool>("online");
  } else {
    fSuppressMPSErrorMsgs = kFALSE;
  }
}

References QwHelicityBase::BuildHelicityBitPattern(), QwLog::endl(), QwHelicityBase::fHelicityBitPattern, QwHelicityBase::fHelicityDelay, QwHelicityBase::fMaxPatternPhase, QwHelicityBase::fPatternPhaseOffset, QwHelicityBase::fRandBits, QwHelicityBase::fSuppressMPSErrorMsgs, QwHelicityBase::fUsePredictor, QwOptions::GetValue(), QwOptions::HasValue(), kDefaultHelicityBitPattern, QwError, QwMessage, SetHelicityBitPattern(), and SetHelicityDelay().

Here is the call graph for this function:

◆ Ratio()

void QwHelicityDecoder::Ratio	(	VQwSubsystem *	numer,
		VQwSubsystem *	denom )

overridevirtual

Reimplemented from QwHelicityBase.

Definition at line 1228 of file QwHelicityDecoder.cc.

{
  // this is stub function defined here out of completion and uniformity between each subsystem
  *this =  value1;
  CheckPatternNum(value2);
  MergeCounters(value2);
}

References CheckPatternNum(), MergeCounters(), and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ RunPredictor()

void QwHelicityDecoder::RunPredictor ( )

Update the random seed if the new event is from a different pattern. Check the difference between old pattern number and the new one and to see how many patterns we have missed or skipped. Then loop back to get the correct pattern polarities.

set the polarity of the current pattern to be equal to the reported helicity,

then use it as the delayed helicity,

if the helicity is delayed by a positive number of patterns then loop the delayed ranseed backward to get the ranseed for the actual helicity

, get the pattern polarity for the actual pattern using that actual ranseed.

Definition at line 1017 of file QwHelicityDecoder.cc.

{
  Int_t ldebug = kFALSE;
 
  if(ldebug)  std::cout  << "Entering QwHelicityDecoder::RunPredictor for fEventNumber, " << fEventNumber
                         << ", fPatternNumber, " << fPatternNumber
                         <<  ", and fPatternPhaseNumber, " << fPatternPhaseNumber << std::endl;
 
    /**Update the random seed if the new event is from a different pattern.
       Check the difference between old pattern number and the new one and
       to see how many patterns we have missed or skipped. Then loop back
       to get the correct pattern polarities.
    */
      if((fPatternPhaseNumber==fMinPatternPhase)&& (fPatternNumber>=0)) {
        iseed_Delayed = fSeed_Reported & 0x7fffffff;
 
        /** set the polarity of the current pattern to be equal to the reported helicity,*/
        fDelayedPatternPolarity = fHelicityReported;
        QwDebug << "QwHelicityDecoder:: CollectRandBits30:  delayedpatternpolarity =" << fDelayedPatternPolarity << QwLog::endl;
 
        /** then use it as the delayed helicity, */
        fHelicityDelayed = fDelayedPatternPolarity;
 
        /**if the helicity is delayed by a positive number of patterns then loop the delayed ranseed backward to get the ranseed
           for the actual helicity */
        if(fHelicityDelay >=0){
          iseed_Actual = iseed_Delayed;
          for(Int_t i=0; i<fHelicityDelay; i++) {
            /**, get the pattern polarity for the actual pattern using that actual ranseed.*/
            fPreviousPatternPolarity = fActualPatternPolarity;
            fActualPatternPolarity = GetRandbit30(iseed_Actual);
          }
        }
     }
    fHelicityActual  = fActualPatternPolarity ^ fEventPolarity;
    fHelicityDelayed = fDelayedPatternPolarity ^ fEventPolarity;
//std::cout << "printing values : fHelicityDelayed = " << fHelicityDelayed << " : fDelayedPatternPolarity = " << fDelayedPatternPolarity << " : fEventPolarity = " << fEventPolarity << " : reported hel =" << fHelicityReported << " : pattern phase=" << fPatternPhaseNumber << std::endl;
 
  if(ldebug){
    std::cout << "Predicted Polarity ::: Delayed ="
              << fDelayedPatternPolarity << " Actual ="
              << fActualPatternPolarity << "\n";
    std::cout << "Predicted Helicity ::: Delayed Helicity=" << fHelicityDelayed
              << " Actual Helicity=" << fHelicityActual << " Reported Helicity=" << fHelicityReported << "\n";
    QwError << "Exiting QwHelicityDecoder::RunPredictor " << QwLog::endl;
 
  }
 
  return;
}

References QwLog::endl(), QwHelicityBase::fActualPatternPolarity, QwHelicityBase::fDelayedPatternPolarity, QwHelicityBase::fEventNumber, fEventPolarity, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityDelay, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fMinPatternPhase, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPreviousPatternPolarity, fSeed_Reported, QwHelicityBase::GetRandbit30(), QwHelicityBase::iseed_Actual, QwHelicityBase::iseed_Delayed, QwDebug, and QwError.

Referenced by PredictHelicity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFirstBits()

void QwHelicityDecoder::SetFirstBits	(	UInt_t	nbits,
		UInt_t	firstbits )

Definition at line 592 of file QwHelicityDecoder.cc.

{
  // This gives the predictor a quick start
  UShort_t firstbits[nbits];
  for (unsigned int i = 0; i < nbits; i++) firstbits[i] = (seed >> i) & 0x1;
  // Set delayed seed
  iseed_Delayed = GetRandomSeed(firstbits);
  // Progress actual seed by the helicity delay
  iseed_Actual = iseed_Delayed;
  for (int i = 0; i < fHelicityDelay; i++) GetRandbit(iseed_Actual);
}

References QwHelicityBase::fHelicityDelay, QwHelicityBase::GetRandbit(), QwHelicityBase::GetRandomSeed(), QwHelicityBase::iseed_Actual, and QwHelicityBase::iseed_Delayed.

Here is the call graph for this function:

◆ SetHelicityBitPattern()

void QwHelicityDecoder::SetHelicityBitPattern ( TString hex )

Definition at line 1106 of file QwHelicityDecoder.cc.

{
  fHelicityBitPattern.clear();
  fHelicityBitPattern = kDefaultHelicityBitPattern;
    /*  // Set the helicity pattern bits
  if (parity(bits) == 0)
    fHelicityBitPattern = bits;
  else QwError << "What, exactly, are you trying to do ?!?!?" << QwLog::endl;
    */
  // Notify the user
  QwMessage << " fPatternBits 0x" ;
  for (int i = fHelicityBitPattern.size()-1;i>=0; i--){
    QwMessage << std::hex << fHelicityBitPattern[i] << " ";
  }
  QwMessage << std::dec << QwLog::endl;
}

References QwLog::endl(), QwHelicityBase::fHelicityBitPattern, kDefaultHelicityBitPattern, and QwMessage.

Referenced by ProcessOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHelicityDelay()

void QwHelicityDecoder::SetHelicityDelay ( Int_t delay )

Sets the number of bits the helicity reported gets delayed with. We predict helicity only if there is a non-zero pattern delay given.

Definition at line 1083 of file QwHelicityDecoder.cc.

{
  /**Sets the number of bits the helicity reported gets delayed with.
     We predict helicity only if there is a non-zero pattern delay given. */
 
  if(delay>=0){
    fHelicityDelay = delay;
    if(delay == 0){
      QwWarning << "QwHelicityDecoder : SetHelicityDelay ::  helicity delay is set to 0."
                << " Disabling helicity predictor and using reported helicity information."
                << QwLog::endl;
      fUsePredictor = kFALSE;
    }
    else
      fUsePredictor = kTRUE;
  }
  else
    QwError << "QwHelicityDecoder::SetHelicityDelay We cannot handle negative delay in the prediction of delayed helicity. Exiting.." << QwLog::endl;
 
  return;
}

References QwLog::endl(), QwHelicityBase::fHelicityDelay, QwHelicityBase::fUsePredictor, QwError, and QwWarning.

Referenced by ProcessOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHistoTreeSave()

void QwHelicityDecoder::SetHistoTreeSave ( const TString & prefix )

Definition at line 604 of file QwHelicityDecoder.cc.

{
 Ssiz_t len;
  if (TRegexp("diff_").Index(prefix,&len) == 0
   || TRegexp("asym[1-9]*_").Index(prefix,&len) == 0)
    fHistoType = kHelNoSave;
  else if (TRegexp("yield_").Index(prefix,&len) == 0)
    fHistoType = kHelSavePattern;
  else
    fHistoType = kHelSaveMPS;
 
}

References QwHelicityBase::fHistoType, QwHelicityBase::kHelNoSave, QwHelicityBase::kHelSaveMPS, and QwHelicityBase::kHelSavePattern.

Referenced by ConstructBranch(), ConstructBranch(), ConstructBranchAndVector(), and ConstructHistograms().

Here is the caller graph for this function:

◆ UpdateErrorFlag()

void QwHelicityDecoder::UpdateErrorFlag ( const VQwSubsystem * ev_error )

inlineoverridevirtual

update the error flag in the subsystem level from the top level routines related to stability checks. This will uniquely update the errorflag at each channel based on the error flag in the corresponding channel in the ev_error subsystem

Reimplemented from QwHelicityBase.

Definition at line 64 of file QwHelicityDecoder.h.

64 {

65 };

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

Field Documentation

◆ fBit_Helicity

Int_t QwHelicityDecoder::fBit_Helicity

Definition at line 153 of file QwHelicityDecoder.h.

Referenced by FillHDVariables(), and ProcessEvent().

◆ fBit_PairSync

Int_t QwHelicityDecoder::fBit_PairSync

Definition at line 154 of file QwHelicityDecoder.h.

Referenced by FillHDVariables().

◆ fBit_PatSync

Int_t QwHelicityDecoder::fBit_PatSync

Definition at line 155 of file QwHelicityDecoder.h.

Referenced by FillHDVariables().

◆ fBit_TStable

Int_t QwHelicityDecoder::fBit_TStable

Definition at line 156 of file QwHelicityDecoder.h.

Referenced by FillHDVariables().

◆ fEventPolarity

Int_t QwHelicityDecoder::fEventPolarity

Definition at line 151 of file QwHelicityDecoder.h.

Referenced by ConstructBranch(), ConstructBranch(), FillHDVariables(), FillTreeVector(), operator=(), and RunPredictor().

◆ fEvtHistory_PairSync

UInt_t QwHelicityDecoder::fEvtHistory_PairSync

Definition at line 158 of file QwHelicityDecoder.h.

Referenced by FillHDVariables().

◆ fEvtHistory_PatSync

UInt_t QwHelicityDecoder::fEvtHistory_PatSync

Definition at line 157 of file QwHelicityDecoder.h.

Referenced by FillHDVariables().

◆ fEvtHistory_ReportedHelicity

UInt_t QwHelicityDecoder::fEvtHistory_ReportedHelicity

Definition at line 159 of file QwHelicityDecoder.h.

Referenced by FillHDVariables().

◆ fLast_Duration_TSettle

Int_t QwHelicityDecoder::fLast_Duration_TSettle

Definition at line 150 of file QwHelicityDecoder.h.

Referenced by FillHDVariables(), FillTreeVector(), and operator=().

◆ fLast_Duration_TStable

Int_t QwHelicityDecoder::fLast_Duration_TStable

Definition at line 149 of file QwHelicityDecoder.h.

Referenced by FillHDVariables(), FillTreeVector(), and operator=().

◆ fNum_Pair_Sync

Int_t QwHelicityDecoder::fNum_Pair_Sync

Definition at line 146 of file QwHelicityDecoder.h.

Referenced by FillHDVariables(), FillTreeVector(), and operator=().

◆ fNum_TStable_Fall

Int_t QwHelicityDecoder::fNum_TStable_Fall

Definition at line 145 of file QwHelicityDecoder.h.

Referenced by FillHDVariables(), FillTreeVector(), and operator=().

◆ fNumDecoderWords

const Int_t QwHelicityDecoder::fNumDecoderWords =14

static

Definition at line 164 of file QwHelicityDecoder.h.

Referenced by ProcessEvBuffer().

◆ fPatHistory_ReportedHelicity

UInt_t QwHelicityDecoder::fPatHistory_ReportedHelicity

Definition at line 160 of file QwHelicityDecoder.h.

Referenced by FillHDVariables().

◆ fReportedPatternHel

Int_t QwHelicityDecoder::fReportedPatternHel

Definition at line 152 of file QwHelicityDecoder.h.

Referenced by ConstructBranch(), ConstructBranch(), FillHDVariables(), FillTreeVector(), and operator=().

◆ fSeed_Reported

UInt_t QwHelicityDecoder::fSeed_Reported

Definition at line 144 of file QwHelicityDecoder.h.

Referenced by FillHDVariables(), ProcessEvent(), and RunPredictor().

◆ fTime_since_TSettle

Int_t QwHelicityDecoder::fTime_since_TSettle

Definition at line 148 of file QwHelicityDecoder.h.

Referenced by FillHDVariables(), FillTreeVector(), and operator=().

◆ fTime_since_TStable

Int_t QwHelicityDecoder::fTime_since_TStable

Definition at line 147 of file QwHelicityDecoder.h.

Referenced by FillHDVariables(), FillTreeVector(), and operator=().

◆ kDEBUG

const Bool_t QwHelicityDecoder::kDEBUG =kFALSE

static

Definition at line 131 of file QwHelicityDecoder.h.

◆ kDefaultHelicityBitPattern

const std::vector< UInt_t > QwHelicityDecoder::kDefaultHelicityBitPattern {0x69}

static

Definition at line 31 of file QwHelicityDecoder.h.

Referenced by ProcessOptions(), and SetHelicityBitPattern().

◆ kUndefinedHelicity

const Int_t QwHelicityDecoder::kUndefinedHelicity = -9999

static

Definition at line 136 of file QwHelicityDecoder.h.

Referenced by ClearEventData().

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

Public Member Functions

Static Public Member Functions

Data Fields

Static Public Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ QwHelicityDecoder() [1/3]

◆ QwHelicityDecoder() [2/3]

◆ QwHelicityDecoder() [3/3]

◆ ~QwHelicityDecoder()

Member Function Documentation

◆ AccumulateRunningSum()

◆ ApplySingleEventCuts()

◆ CheckForBurpFail()

◆ CheckIORegisterMask()

◆ CheckPatternNum()

◆ ClearEventData()

◆ Compare()

◆ ConstructBranch() [1/2]

◆ ConstructBranch() [2/2]

◆ ConstructBranchAndVector() [1/2]

◆ ConstructBranchAndVector() [2/2]

◆ ConstructHistograms() [1/4]

◆ ConstructHistograms() [2/4]

◆ ConstructHistograms() [3/4]

◆ ConstructHistograms() [4/4]

◆ DeaccumulateRunningSum()

◆ DefineOptions()

◆ EncodeEventData()

◆ FillHDVariables()

◆ FillHistograms()

◆ FillTreeVector()

◆ GetRandomSeedActual()

◆ GetRandomSeedDelayed()

◆ LoadChannelMap()

◆ LoadEventCuts()

◆ LoadInputParameters()

◆ MergeCounters()

◆ operator+=()

◆ operator-=()

◆ operator=()

◆ PredictHelicity()

◆ Print()

◆ ProcessConfigurationBuffer()

◆ ProcessEvBuffer() [1/2]

◆ ProcessEvBuffer() [2/2]

◆ ProcessEvent()

◆ ProcessOptions()

◆ Ratio()

◆ RunPredictor()

◆ SetFirstBits()

◆ SetHelicityBitPattern()

◆ SetHelicityDelay()

◆ SetHistoTreeSave()

◆ UpdateErrorFlag()

Field Documentation

◆ fBit_Helicity

◆ fBit_PairSync

◆ fBit_PatSync

◆ fBit_TStable

◆ fEventPolarity

◆ fEvtHistory_PairSync

◆ fEvtHistory_PatSync

◆ fEvtHistory_ReportedHelicity

◆ fLast_Duration_TSettle

◆ fLast_Duration_TStable

◆ fNum_Pair_Sync

◆ fNum_TStable_Fall

◆ fNumDecoderWords

◆ fPatHistory_ReportedHelicity

◆ fReportedPatternHel

◆ fSeed_Reported

◆ fTime_since_TSettle

◆ fTime_since_TStable

◆ kDEBUG

◆ kDefaultHelicityBitPattern

◆ kUndefinedHelicity