Subsystem for helicity state management and pattern recognition. More...

#include <QwHelicity.h>

Inheritance diagram for QwHelicity:

Collaboration diagram for QwHelicity:

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

	QwHelicity (const QwHelicity &source)
	Copy constructor.

virtual	~QwHelicity () 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.

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) override
	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	ProcessEventUserbitMode ()
	Process helicity information from userbit configuration data.

void	ProcessEventInputRegisterMode ()

void	ProcessEventInputMollerMode ()

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

void	ClearEventData () override

void	ProcessEvent () override

UInt_t	GetRandomSeedActual ()

UInt_t	GetRandomSeedDelayed ()

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

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)

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, TString &prefix, QwRootTreeBranchVector &values)=0
	Construct the branch and tree vector.

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

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

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)

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

virtual VQwSubsystem &	operator-= (VQwSubsystem *value) override

void	Scale (Double_t factor) 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	CalculateRunningAverage () override
	Calculate the average for all good events.

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

Bool_t	IsHelicityIgnored ()

virtual Bool_t	IsGoodHelicity ()

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 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, QwHelicity >
	~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)

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, QwHelicity >
static VQwSubsystem *	Create (const std::string &name)
	Object creation.

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

Protected Types
enum	HelicityEncodingType { kHelUserbitMode =0 , kHelInputRegisterMode , kHelLocalyMadeUp , kHelInputMollerMode }

enum	InputRegisterBits { kDefaultInputReg_HelPlus = 0x1 , kDefaultInputReg_HelMinus = 0x2 , kDefaultInputReg_PatternSync = 0x4 , kDefaultInputReg_FakeMPS = 0x8000 }

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

Protected Member Functions
Bool_t	CheckIORegisterMask (const UInt_t &ioregister, const UInt_t &mask) const

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
UInt_t	fInputReg_FakeMPS

UInt_t	fInputReg_HelPlus

UInt_t	fInputReg_HelMinus

UInt_t	fInputReg_PatternSync

UInt_t	fInputReg_PairSync

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.

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

Additional Inherited Members
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 state management and pattern recognition.

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 QwHelicity.h.

Member Enumeration Documentation

◆ HelicityEncodingType

enum QwHelicity::HelicityEncodingType

protected

Enumerator
kHelUserbitMode
kHelInputRegisterMode
kHelLocalyMadeUp
kHelInputMollerMode

Definition at line 92 of file QwHelicity.h.

                           {kHelUserbitMode=0,
                kHelInputRegisterMode,
                kHelLocalyMadeUp,
                kHelInputMollerMode};

◆ InputRegisterBits

enum QwHelicity::InputRegisterBits

protected

Enumerator
kDefaultInputReg_HelPlus
kDefaultInputReg_HelMinus
kDefaultInputReg_PatternSync
kDefaultInputReg_FakeMPS

Definition at line 98 of file QwHelicity.h.

                        {kDefaultInputReg_HelPlus     = 0x1,
             kDefaultInputReg_HelMinus    = 0x2,
             kDefaultInputReg_PatternSync = 0x4,
             kDefaultInputReg_FakeMPS     = 0x8000};

Constructor & Destructor Documentation

◆ QwHelicity() [1/3]

QwHelicity::QwHelicity ( )

private

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

References QwHelicity().

Referenced by QwHelicity(), and QwHelicity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QwHelicity() [2/3]

QwHelicity::QwHelicity ( const TString & name )

Constructor with name.

Default helicity bit pattern of 0x69 represents a -++-+–+ octet (event polarity listed in reverse time order), where the LSB of the bit pattern is the first event of the pattern.

Definition at line 33 of file QwHelicity.cc.

: VQwSubsystem(name),
  QwHelicityBase(name),
  fInputReg_HelPlus(kDefaultInputReg_HelPlus),
  fInputReg_HelMinus(kDefaultInputReg_HelMinus),
  fInputReg_PatternSync(kDefaultInputReg_PatternSync),
  fInputReg_PairSync(0)
{
 
  fInputReg_FakeMPS = kDefaultInputReg_FakeMPS;
}

References fInputReg_FakeMPS, fInputReg_HelMinus, fInputReg_HelPlus, fInputReg_PairSync, fInputReg_PatternSync, kDefaultInputReg_FakeMPS, kDefaultInputReg_HelMinus, kDefaultInputReg_HelPlus, kDefaultInputReg_PatternSync, QwHelicityBase::QwHelicityBase(), and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ QwHelicity() [3/3]

QwHelicity::QwHelicity ( const QwHelicity & source )

Copy constructor.

Definition at line 46 of file QwHelicity.cc.

: VQwSubsystem(source.GetName()),
  QwHelicityBase(source.GetName()),
  fInputReg_HelPlus(source.fInputReg_HelPlus),
  fInputReg_HelMinus(source.fInputReg_HelMinus),
  fInputReg_PatternSync(source.fInputReg_PatternSync),
  fInputReg_PairSync(source.fInputReg_PairSync)
{
  fHelicityBitPattern = source.fHelicityBitPattern; 
  ClearErrorCounters();
  // Default helicity delay to two patterns.
  fHelicityDelay = 2;
  // Default the EventType flags to HelPlus=1 and HelMinus=4
  // These are only used in Moller decoding mode.
  kEventTypeHelPlus  = 4;
  kEventTypeHelMinus = 1;
  //
  fEventNumberOld=-1; fEventNumber=-1;
  fPatternPhaseNumberOld=-1; fPatternPhaseNumber=-1;
  fPatternNumberOld=-1;  fPatternNumber=-1;
  kUserbit=-1;
  fActualPatternPolarity=kUndefinedHelicity;
  fDelayedPatternPolarity=kUndefinedHelicity;
  fHelicityReported=kUndefinedHelicity;
  fHelicityActual=kUndefinedHelicity;
  fHelicityDelayed=kUndefinedHelicity;
  fHelicityBitPlus=kFALSE;
  fHelicityBitMinus=kFALSE;
  fGoodHelicity=kFALSE;
  fGoodPattern=kFALSE;
  fHelicityDecodingMode=-1;
 
  this->fWord.resize(source.fWord.size());
  for(size_t i=0;i<this->fWord.size();i++)
    {
      this->fWord[i].fWordName=source.fWord[i].fWordName;
      this->fWord[i].fModuleType=source.fWord[i].fModuleType;
      this->fWord[i].fWordType=source.fWord[i].fWordType;
    }
  fNumMissedGates = source.fNumMissedGates;
  fNumMissedEventBlocks = source.fNumMissedEventBlocks;
  fNumMultSyncErrors = source.fNumMultSyncErrors;
  fNumHelicityErrors = source.fNumHelicityErrors;
  fEventNumberFirst = source.fEventNumberFirst;
  fPatternNumberFirst = source.fPatternNumberFirst;
  fEventType = source.fEventType;
  fIgnoreHelicity = source.fIgnoreHelicity;
  fRandBits = source.fRandBits;
  fUsePredictor = source.fUsePredictor;
  fHelicityInfoOK = source.fHelicityInfoOK;
  fPatternPhaseOffset = source.fPatternPhaseOffset;
  fMinPatternPhase = source.fMinPatternPhase;
  fMaxPatternPhase = source.fMaxPatternPhase;
  fHelicityDelay = source.fHelicityDelay;
  iseed_Delayed = source.iseed_Delayed;
  iseed_Actual = source.iseed_Actual;
  n_ranbits = source.n_ranbits;
  fEventNumber = source.fEventNumber;
  fEventNumberOld = source.fEventNumberOld;
  fPatternPhaseNumber = source.fPatternPhaseNumber;
  fPatternPhaseNumberOld = source.fPatternPhaseNumberOld;
  fPatternNumber = source.fPatternNumber;
  fPatternNumberOld = source.fPatternNumberOld;
 
  this->kUserbit = source.kUserbit;
  this->fIgnoreHelicity = source.fIgnoreHelicity;
}

Here is the call graph for this function:

◆ ~QwHelicity()

virtual QwHelicity::~QwHelicity ( )

inlineoverridevirtual

Virtual destructor.

Definition at line 47 of file QwHelicity.h.

47{ }

Member Function Documentation

◆ ApplySingleEventCuts()

Bool_t QwHelicity::ApplySingleEventCuts ( )

overridevirtual

Apply the single event cuts.

Implements VQwSubsystemParity.

Definition at line 253 of file QwHelicity.cc.

                                       {
  //impose single event cuts //Paul's modifications
 
  return kTRUE;
}

◆ CheckForBurpFail()

Bool_t QwHelicity::CheckForBurpFail ( const VQwSubsystem * subsys )

inlineoverridevirtual

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

Implements VQwSubsystemParity.

Definition at line 57 of file QwHelicity.h.

                                                                 {
    return kFALSE;
  };

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ CheckIORegisterMask()

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

inlineprotected

Definition at line 88 of file QwHelicity.h.

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

Referenced by ProcessEventInputRegisterMode().

Here is the caller graph for this function:

◆ ClearEventData()

void QwHelicity::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

Set the new event number and pattern number to -1. If we are not reading these correctly from the data stream, -1 will allow us to identify that.

Reimplemented from QwHelicityBase.

Definition at line 202 of file QwHelicity.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;
 
  //fIgnoreHelicity = kFALSE;
 
  /**Clear out helicity variables */
  fHelicityReported = kUndefinedHelicity;
  fHelicityActual = kUndefinedHelicity;
  fHelicityDelayed= kUndefinedHelicity;
  fHelicityBitPlus = kFALSE;
  fHelicityBitMinus = kFALSE;
  // be careful: it is not that I forgot to reset fActualPatternPolarity
  // or fDelayedPatternPolarity. One doesn't want to do that here.
  /** Set the new event number and pattern number to -1. If we are not reading these correctly
      from the data stream, -1 will allow us to identify that.*/
  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, QwHelicityBase::kUndefinedHelicity, and VQwSubsystem::SetDataLoaded().

Referenced by ClearEventData().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructBranchAndVector() [1/2]

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

inlinevirtual

Construct the branch and tree vector.

Reimplemented from VQwSubsystem.

Definition at line 303 of file VQwSubsystem.h.

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

◆ ConstructBranchAndVector() [2/2]

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

virtual

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.

Implements VQwSubsystem.

◆ ConstructHistograms() [1/4]

virtual void VQwSubsystem::ConstructHistograms ( )

inlinevirtual

Construct the histograms for this subsystem.

Reimplemented from VQwSubsystem.

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

Definition at line 275 of file VQwSubsystem.h.

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

◆ ConstructHistograms() [3/4]

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

overridevirtual

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

Implements VQwSubsystem.

Definition at line 897 of file QwHelicity.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 << "QwHelicity::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 QwHelicityBase::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 VQwSubsystem.

Definition at line 280 of file VQwSubsystem.h.

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

◆ DefineOptions()

void QwHelicity::DefineOptions ( QwOptions & options )

static

Definition at line 115 of file QwHelicity.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 QwHelicity::EncodeEventData ( std::vector< UInt_t > & buffer )

overridevirtual

Reimplemented from VQwSubsystem.

Definition at line 583 of file QwHelicity.cc.

{
  std::vector<UInt_t> localbuffer;
  localbuffer.clear();
 
  // Userbit mode
  switch (fHelicityDecodingMode) {
  case kHelUserbitMode: {
    UInt_t userbit = 0x0;
    if (fPatternPhaseNumber == fMinPatternPhase) userbit |= 0x80000000;
    if (fHelicityDelayed == 1)    userbit |= 0x40000000;
 
    // Write the words to the buffer
    localbuffer.push_back(0x1); // cleandata
    localbuffer.push_back(0xa); // scandata1
    localbuffer.push_back(0xa); // scandata2
    localbuffer.push_back(0x0); // scalerheader
    localbuffer.push_back(0x20); // scalercounter (32)
    localbuffer.push_back(userbit); // userbit
 
    for (int i = 0; i < 64; i++) localbuffer.push_back(0x0); // (not used)
    break;
  }
  case kHelInputRegisterMode: {
    UInt_t input_register = 0x0;
    if (fHelicityDelayed == 1) input_register |= fInputReg_HelPlus;
    if (fHelicityDelayed == 0) input_register |= fInputReg_HelMinus;
    if (fPatternPhaseNumber == fMinPatternPhase) input_register |= fInputReg_PatternSync;
 
    // Write the words to the buffer
    localbuffer.push_back(input_register); // input_register
    localbuffer.push_back(0x0); // output_register
    localbuffer.push_back(fEventNumber); // mps_counter
    localbuffer.push_back(fPatternNumber); // pat_counter
    localbuffer.push_back(fPatternPhaseNumber - fMinPatternPhase + fPatternPhaseOffset); // pat_phase
 
    for (int i = 0; i < 17; i++) localbuffer.push_back(0x0); // (not used)
    break;
  }
  default:
    QwWarning << "QwHelicity::EncodeEventData: Unsupported helicity encoding!" << QwLog::endl;
    break;
  }
 
  // If there is element data, generate the subbank header
  std::vector<UInt_t> subbankheader;
  std::vector<UInt_t> rocheader;
  if (localbuffer.size() > 0) {
 
    // Form CODA subbank header
    subbankheader.clear();
    subbankheader.push_back(localbuffer.size() + 1);    // subbank size
    subbankheader.push_back((fCurrentBank_ID << 16) | (0x01 << 8) | (1 & 0xff));
        // subbank tag | subbank type | event number
 
    // Form CODA bank/roc header
    rocheader.clear();
    rocheader.push_back(subbankheader.size() + localbuffer.size() + 1); // bank/roc size
    rocheader.push_back((fCurrentROC_ID << 16) | (0x10 << 8) | (1 & 0xff));
        // bank tag == ROC | bank type | event number
 
    // Add bank header, subbank header and element data to output buffer
    buffer.insert(buffer.end(), rocheader.begin(), rocheader.end());
    buffer.insert(buffer.end(), subbankheader.begin(), subbankheader.end());
    buffer.insert(buffer.end(), localbuffer.begin(), localbuffer.end());
  }
}

References QwLog::endl(), VQwSubsystem::fCurrentBank_ID, VQwSubsystem::fCurrentROC_ID, QwHelicityBase::fEventNumber, QwHelicityBase::fHelicityDecodingMode, QwHelicityBase::fHelicityDelayed, fInputReg_HelMinus, fInputReg_HelPlus, fInputReg_PatternSync, QwHelicityBase::fMinPatternPhase, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternPhaseOffset, kHelInputRegisterMode, kHelUserbitMode, and QwWarning.

Here is the call graph for this function:

◆ GetRandomSeedActual()

UInt_t QwHelicity::GetRandomSeedActual ( )

inline

Definition at line 77 of file QwHelicity.h.

77{ return iseed_Actual; };

References QwHelicityBase::iseed_Actual.

Referenced by main().

Here is the caller graph for this function:

◆ GetRandomSeedDelayed()

UInt_t QwHelicity::GetRandomSeedDelayed ( )

inline

Definition at line 78 of file QwHelicity.h.

78{ return iseed_Delayed; };

References QwHelicityBase::iseed_Delayed.

Referenced by main().

Here is the caller graph for this function:

◆ LoadChannelMap()

Int_t QwHelicity::LoadChannelMap ( TString mapfile )

overridevirtual

Mandatory map file definition.

Implements VQwSubsystem.

Definition at line 651 of file QwHelicity.cc.

{
  Bool_t ldebug=kFALSE;
 
  Int_t wordsofar=0;
  Int_t bankindex=-1;
 
  fPatternPhaseOffset=1;//Phase number offset is set to 1 by default and will be set to 0 if phase number starts from 0
 
 
  // Default value for random seed is 30 bits
  fRandBits = 30;
 
 
  QwParameterFile mapstr(mapfile.Data());  //Open the file
  fDetectorMaps.insert(mapstr.GetParamFileNameContents());
  mapstr.EnableGreediness();
  mapstr.SetCommentChars("!");
 
  UInt_t value = 0;
  TString valuestr;
 
  while (mapstr.ReadNextLine()){
    RegisterRocBankMarker(mapstr);
 
    if (mapstr.PopValue("patternphase",value)) {
      fMaxPatternPhase=value;
      BuildHelicityBitPattern(fMaxPatternPhase);
    }
    if (mapstr.PopValue("patternbits",valuestr)) {
      SetHelicityBitPattern(valuestr);
    }
    if (mapstr.PopValue("inputregmask_fakemps",value)) {
      fInputReg_FakeMPS = value;
    }
    if (mapstr.PopValue("inputregmask_helicity",value)) {
      fInputReg_HelPlus  = value;
      fInputReg_HelMinus = 0;
    }
    if (mapstr.PopValue("inputregmask_helplus",value)) {
      fInputReg_HelPlus = value;
    }
    if (mapstr.PopValue("inputregmask_helminus",value)) {
      fInputReg_HelMinus = value;
    }
    if (mapstr.PopValue("inputregmask_pattsync",value)) {
      fInputReg_PatternSync = value;
    }
    if (mapstr.PopValue("inputregmask_pairsync",value)) {
      fInputReg_PairSync = value;
    }
    if (mapstr.PopValue("fakempsbit",value)) {
      fInputReg_FakeMPS = value;
      QwWarning << " fInputReg_FakeMPS 0x" << std::hex << fInputReg_FakeMPS << std::dec << QwLog::endl;
    }
    if (mapstr.PopValue("numberpatternsdelayed",value)) {
      SetHelicityDelay(value);
    }
    if (mapstr.PopValue("randseedbits",value)) {
      if (value==24 || value==30)
    fRandBits = value;
    }
    if (mapstr.PopValue("patternphaseoffset",value)) {
      fPatternPhaseOffset=value;
    }
    if (mapstr.PopValue("helpluseventtype",value)) {
      kEventTypeHelPlus = value;
    }
    if (mapstr.PopValue("helminuseventtype",value)) {
      kEventTypeHelMinus = value;
    }
    if (mapstr.PopValue("helicitydecodingmode",valuestr)) {
      if (valuestr=="InputRegisterMode") {
    QwMessage << " **** Input Register Mode **** " << QwLog::endl;
    fHelicityDecodingMode=kHelInputRegisterMode;
      } else if (valuestr=="UserbitMode"){
    QwMessage << " **** Userbit Mode **** " << QwLog::endl;
    fHelicityDecodingMode=kHelUserbitMode;
      } else if (valuestr=="HelLocalyMadeUp"){
    QwMessage << "**** Helicity Locally Made Up ****" << QwLog::endl;
    fHelicityDecodingMode=kHelLocalyMadeUp;
      } else if (valuestr=="InputMollerMode") {
    QwMessage << "**** Input Moller Mode ****" << QwLog::endl;
    fHelicityDecodingMode=kHelInputMollerMode;
      } else {
    QwError  << "The helicity decoding mode read in file " << mapfile
         << " is not recognized in function QwHelicity::LoadChannelMap \n"
         << " Quitting this execution." << QwLog::endl;
      }
    }
 
    if(bankindex!=GetSubbankIndex(fCurrentROC_ID,fCurrentBank_ID)) {
      bankindex=GetSubbankIndex(fCurrentROC_ID,fCurrentBank_ID);
      if ((bankindex+1)>0){
    UInt_t numbanks = UInt_t(bankindex+1);
    if (fWordsPerSubbank.size()<numbanks){
      fWordsPerSubbank.resize(numbanks,
                  std::pair<Int_t, Int_t>(fWord.size(),fWord.size()));
    }
      }
      wordsofar=0;
    }
    mapstr.TrimWhitespace();   // Get rid of leading and trailing spaces.
    if (mapstr.LineIsEmpty())  continue;
 
    //  Break this line into tokens to process it.
    TString modtype = mapstr.GetTypedNextToken<TString>();  // module type
    Int_t modnum = mapstr.GetTypedNextToken<Int_t>();   //slot number
    /* Int_t channum = */ mapstr.GetTypedNextToken<Int_t>();    //channel number /* unused */
    TString dettype = mapstr.GetTypedNextToken<TString>();  //type-purpose of the detector
    dettype.ToLower();
    TString namech  = mapstr.GetTypedNextToken<TString>();  //name of the detector
    namech.ToLower();
    TString keyword = mapstr.GetTypedNextToken<TString>();
    keyword.ToLower();
    // Notice that "namech" and "keyword" are now forced to lower-case.
 
    if(modtype=="SKIP"){
      if (modnum<=0) wordsofar+=1;
      else           wordsofar+=modnum;
    } else if(modtype!="WORD"|| dettype!="helicitydata") {
      QwError << "QwHelicity::LoadChannelMap:  Unknown detector type: "
          << dettype  << ", the detector " << namech << " will not be decoded "
          << QwLog::endl;
      continue;
    } else {
      QwWord localword;
      localword.fSubbankIndex=bankindex;
      localword.fWordInSubbank=wordsofar;
      wordsofar+=1;
      // I assume that one data = one word here. But it is not always the case, for
      // example the triumf adc gives 6 words per channel
      localword.fModuleType=modtype;
      localword.fWordName=namech;
      localword.fWordType=dettype;
      fWord.push_back(localword);
      fWordsPerSubbank.at(bankindex).second = fWord.size();
 
      // Notice that "namech" is in lower-case, so these checks
      // should all be in lower-case
      switch (fHelicityDecodingMode)
    {
    case kHelUserbitMode :
      if(namech.Contains("userbit")) kUserbit=fWord.size()-1;
      if(namech.Contains("scalercounter")) kScalerCounter=fWord.size()-1;
      break;
    case kHelInputRegisterMode :
      if(namech.Contains("input_register")) kInputRegister= fWord.size()-1;
      if(namech.Contains("mps_counter")) kMpsCounter= fWord.size()-1;
      if(namech.Contains("pat_counter")) kPatternCounter= fWord.size()-1;
      if(namech.Contains("pat_phase")) kPatternPhase= fWord.size()-1;
      break;
    case kHelInputMollerMode :
      if(namech.Contains("mps_counter")) {
        kMpsCounter= fWord.size()-1;
      }
      if(namech.Contains("pat_counter")) {
        kPatternCounter = fWord.size()-1;
      }
      break;
    }
    }
  }
 
 
  if(ldebug) {
    std::cout << "Done with Load map channel \n";
    for(size_t i=0;i<fWord.size();i++)
      fWord[i].PrintID();
    std::cout << " kUserbit=" << kUserbit << "\n";
  }
  ldebug=kFALSE;
 
  if (fHelicityDecodingMode==kHelInputMollerMode){
    // Check to be sure kEventTypeHelPlus and kEventTypeHelMinus are both defined and not equal
    if (kEventTypeHelPlus != kEventTypeHelMinus
    && kEventTypeHelPlus>0 && kEventTypeHelPlus<15
    && kEventTypeHelMinus>0 && kEventTypeHelMinus<15) {
      // Everything is okay
      QwDebug << "QwHelicity::LoadChannelMap:"
          << "  We are in Moller Helicity Mode, with HelPlusEventType = "
          << kEventTypeHelPlus
          << "and HelMinusEventType = " << kEventTypeHelMinus
          << QwLog::endl;
    } else {
      QwError << "QwHelicity::LoadChannelMap:"
          << "  We are in Moller Helicity Mode, and the HelPlus and HelMinus event types are not set properly."
          << "  HelPlusEventType = "  << kEventTypeHelPlus
          << ", HelMinusEventType = " << kEventTypeHelMinus
          << ".  Please correct the helicity map file!"
          << QwLog::endl;
      exit(65);
    }
  }
 
std::cout << fHelicityBitPattern.size() << std::endl;
 
  mapstr.Close(); // Close the file (ifstream)
  return 0;
}

References QwHelicityBase::BuildHelicityBitPattern(), QwParameterFile::Close(), QwParameterFile::EnableGreediness(), QwLog::endl(), VQwSubsystem::fCurrentBank_ID, VQwSubsystem::fCurrentROC_ID, VQwSubsystem::fDetectorMaps, QwHelicityBase::fHelicityBitPattern, QwHelicityBase::fHelicityDecodingMode, fInputReg_FakeMPS, fInputReg_HelMinus, fInputReg_HelPlus, fInputReg_PairSync, fInputReg_PatternSync, QwHelicityBase::fMaxPatternPhase, QwWord::fModuleType, QwHelicityBase::fPatternPhaseOffset, QwHelicityBase::fRandBits, QwWord::fSubbankIndex, QwHelicityBase::fWord, QwWord::fWordInSubbank, QwWord::fWordName, QwHelicityBase::fWordsPerSubbank, QwWord::fWordType, QwParameterFile::GetParamFileNameContents(), VQwSubsystem::GetSubbankIndex(), QwParameterFile::GetTypedNextToken(), QwHelicityBase::kEventTypeHelMinus, QwHelicityBase::kEventTypeHelPlus, kHelInputMollerMode, kHelInputRegisterMode, kHelLocalyMadeUp, kHelUserbitMode, QwHelicityBase::kInputRegister, QwHelicityBase::kMpsCounter, QwHelicityBase::kPatternCounter, QwHelicityBase::kPatternPhase, QwHelicityBase::kScalerCounter, QwHelicityBase::kUserbit, QwParameterFile::LineIsEmpty(), QwParameterFile::PopValue(), QwDebug, QwError, QwMessage, QwWarning, QwParameterFile::ReadNextLine(), VQwSubsystem::RegisterRocBankMarker(), QwParameterFile::SetCommentChars(), QwHelicityBase::SetHelicityBitPattern(), QwHelicityBase::SetHelicityDelay(), and QwParameterFile::TrimWhitespace().

Here is the call graph for this function:

◆ LoadEventCuts()

Int_t QwHelicity::LoadEventCuts ( TString )

overridevirtual

Optional event cut file.

Reimplemented from VQwSubsystem.

Definition at line 853 of file QwHelicity.cc.

                                               {
  return 0;
}

◆ LoadInputParameters()

Int_t QwHelicity::LoadInputParameters ( TString mapfile )

overridevirtual

Mandatory parameter file definition.

Implements VQwSubsystem.

Definition at line 247 of file QwHelicity.cc.

{
  return 0;
}

◆ operator=()

VQwSubsystem & QwHelicityBase::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)

Implements VQwSubsystemParity.

Definition at line 120 of file QwHelicityBase.cc.

{
  Bool_t ldebug = kFALSE;
  QwHelicityBase* input= dynamic_cast<QwHelicityBase*>(value);
  if (input) {
      this->VQwSubsystem::operator=(value);
      QwHelicityBase* input= dynamic_cast<QwHelicityBase*>(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->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 << "QwHelicityBase::operator = this->fPatternNumber=" << this->fPatternNumber << std::endl;
    std::cout << "input->fPatternNumber=" << input->fPatternNumber << "\n";
      }
    }
  return *this;
}

◆ ProcessConfigurationBuffer()

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

overridevirtual

Implements VQwSubsystem.

Definition at line 240 of file QwHelicity.cc.

{
  //stub function
  // QwError << " this function QwHelicity::ProcessConfigurationBuffer does nothing yet " << QwLog::endl;
  return 0;
}

◆ ProcessEvBuffer() [1/2]

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

inlineoverridevirtual

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

Implements VQwSubsystem.

Definition at line 63 of file QwHelicity.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 QwHelicity::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 VQwSubsystem.

Definition at line 857 of file QwHelicity.cc.

{
  Bool_t lkDEBUG = kFALSE;
 
  if (((0x1 << (event_type - 1)) & this->GetEventTypeMask()) == 0)
    return 0;
  fEventType = event_type;
 
  Int_t index = GetSubbankIndex(roc_id,bank_id);
  if (index >= 0 && num_words > 0) {
    SetDataLoaded(kTRUE);
    //  We want to process this ROC.  Begin loopilooping through the data.
    QwDebug << "QwHelicity::ProcessEvBuffer:  "
        << "Begin processing ROC" << roc_id
        << " and subbank " << bank_id
        << " number of words=" << num_words << QwLog::endl;
 
    for(Int_t i=fWordsPerSubbank.at(index).first; i<fWordsPerSubbank.at(index).second; i++) {
      if(fWord[i].fWordInSubbank+1<= (Int_t) num_words) {
    fWord[i].fValue=buffer[fWord[i].fWordInSubbank];
      } else {
    QwWarning << "QwHelicity::ProcessEvBuffer:  There is not enough word in the buffer to read data for "
          << fWord[i].fWordName << QwLog::endl;
    QwWarning << "QwHelicity::ProcessEvBuffer:  Words in this buffer:" << num_words
          << " trying to read word number =" << fWord[i].fWordInSubbank << QwLog::endl;
      }
    }
    if(lkDEBUG) {
      QwDebug << "QwHelicity::ProcessEvBuffer:  Done with Processing this event" << QwLog::endl;
      for(size_t i=0;i<fWord.size();i++) {
    std::cout << "QwHelicity::ProcessEvBuffer:  word number = " << i << " ";
    fWord[i].Print();
      }
    }
  }
  lkDEBUG=kFALSE;
  return 0;
}

References QwLog::endl(), QwHelicityBase::fEventType, QwHelicityBase::fWord, QwHelicityBase::fWordsPerSubbank, VQwSubsystem::GetEventTypeMask(), VQwSubsystem::GetSubbankIndex(), QwDebug, QwWarning, and VQwSubsystem::SetDataLoaded().

Here is the call graph for this function:

◆ ProcessEvent()

void QwHelicity::ProcessEvent ( )

overridevirtual

Implements VQwSubsystem.

Definition at line 528 of file QwHelicity.cc.

{
  Bool_t ldebug = kFALSE;
  fErrorFlag = 0;
 
  if (! HasDataLoaded()) return;
 
  switch (fHelicityDecodingMode)
    {
    case kHelUserbitMode :
      ProcessEventUserbitMode();
      break;
    case kHelInputRegisterMode :
      ProcessEventInputRegisterMode();
      break;
    case kHelInputMollerMode :
      ProcessEventInputMollerMode();
      break;
    default:
      QwError << "QwHelicity::ProcessEvent no instructions on how to decode the helicity !!!!" << QwLog::endl;
      abort();
      break;
    }
 
  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;
 
    if(fPatternPhaseNumber== fMinPatternPhase){
      fPreviousPatternPolarity = fActualPatternPolarity;
      fActualPatternPolarity   = fHelicityReported;
      fDelayedPatternPolarity  = fHelicityReported;
    }
 
  }
 
  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;
  }
 
  return;
}

References QwLog::endl(), QwHelicityBase::fActualPatternPolarity, QwHelicityBase::fDelayedPatternPolarity, QwHelicityBase::fErrorFlag, QwHelicityBase::fEventNumber, QwHelicityBase::fHelicityActual, QwHelicityBase::fHelicityBitMinus, QwHelicityBase::fHelicityBitPlus, QwHelicityBase::fHelicityDecodingMode, QwHelicityBase::fHelicityDelayed, QwHelicityBase::fHelicityReported, QwHelicityBase::fIgnoreHelicity, QwHelicityBase::fMaxPatternPhase, QwHelicityBase::fMinPatternPhase, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPreviousPatternPolarity, QwHelicityBase::fUsePredictor, VQwSubsystem::HasDataLoaded(), kHelInputMollerMode, kHelInputRegisterMode, kHelUserbitMode, QwHelicityBase::PredictHelicity(), ProcessEventInputMollerMode(), ProcessEventInputRegisterMode(), ProcessEventUserbitMode(), and QwError.

Here is the call graph for this function:

◆ ProcessEventInputMollerMode()

void QwHelicity::ProcessEventInputMollerMode ( )

Definition at line 483 of file QwHelicity.cc.

{
  static Bool_t firstpattern = kTRUE;
 
  if(firstpattern && fWord[kPatternCounter].fValue > fPatternNumberOld){
    firstpattern = kFALSE;
  }
 
  fEventNumber=fWord[kMpsCounter].fValue;
  if(fEventNumber!=(fEventNumberOld+1)){
    Int_t nummissed(fEventNumber - (fEventNumberOld+1));
    QwError << "QwHelicity::ProcessEvent read event# ("
        << fEventNumber << ") is not  old_event#+1; missed "
        << nummissed << " gates" << QwLog::endl;
    fNumMissedGates += nummissed;
    fNumMissedEventBlocks++;
  }
  if (firstpattern){
    fPatternNumber      = -1;
    fPatternPhaseNumber = fMinPatternPhase;
  } else {
    fPatternNumber = fWord[kPatternCounter].fValue;
    if (fPatternNumber > fPatternNumberOld){
      //  We are at a new pattern!
      fPatternPhaseNumber  = fMinPatternPhase;
    } else {
      fPatternPhaseNumber  = fPatternPhaseNumberOld + 1;
    }
  }
 
  if (fEventType == kEventTypeHelPlus)       fHelicityReported=1;
  else if (fEventType == kEventTypeHelMinus) fHelicityReported=0;
  //  fHelicityReported = (fEventType == 1 ? 0 : 1);
 
  if (fHelicityReported == 1){
    fHelicityBitPlus=kTRUE;
    fHelicityBitMinus=kFALSE;
  } else {
    fHelicityBitPlus=kFALSE;
    fHelicityBitMinus=kTRUE;
  }
  return;
}

References QwLog::endl(), QwHelicityBase::fEventNumber, QwHelicityBase::fEventNumberOld, QwHelicityBase::fEventType, QwHelicityBase::fHelicityBitMinus, QwHelicityBase::fHelicityBitPlus, QwHelicityBase::fHelicityReported, QwHelicityBase::fMinPatternPhase, QwHelicityBase::fNumMissedEventBlocks, QwHelicityBase::fNumMissedGates, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternNumberOld, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternPhaseNumberOld, QwHelicityBase::fWord, QwHelicityBase::kEventTypeHelMinus, QwHelicityBase::kEventTypeHelPlus, QwHelicityBase::kMpsCounter, QwHelicityBase::kPatternCounter, and QwError.

Referenced by ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessEventInputRegisterMode()

void QwHelicity::ProcessEventInputRegisterMode ( )

If we get junk for the mps and pattern information from the run we can enable fake counters for mps, pattern number and pattern phase to get the job done.

In the Input Register Mode, the event number is obtained straight from the wordkMPSCounter.

Extract the reported helicity from the input register for each event.

Definition at line 375 of file QwHelicity.cc.

{
  static Bool_t firstevent   = kTRUE;
  static Bool_t firstpattern = kTRUE;
  static Bool_t fake_the_counters=kFALSE;
  UInt_t thisinputregister=fWord[kInputRegister].fValue;
 
  if (firstpattern){
    //  If any of the special counters are negative or zero, setup to
    //  generate the counters internally.
    fake_the_counters |= (kPatternCounter<=0)
      || ( kMpsCounter<=0) || (kPatternPhase<=0);
  }
 
  if (CheckIORegisterMask(thisinputregister,fInputReg_FakeMPS))
    fIgnoreHelicity = kTRUE;
  else
    fIgnoreHelicity = kFALSE;
 
  /** If we get junk for the mps and pattern information from the run
      we can enable fake counters for mps, pattern number and pattern
      phase to get the job done.
  */
  if (!fake_the_counters){
    /**
       In the Input Register Mode,
       the event number is obtained straight from the wordkMPSCounter.
    */
    fEventNumber=fWord[kMpsCounter].fValue;
    // When we have the minimum phase from the pattern phase word
    // and the input register minimum phase bit is set
    // we can select the second pattern as below.
    if(fWord[kPatternPhase].fValue - fPatternPhaseOffset == 0)
      if (firstpattern && CheckIORegisterMask(thisinputregister,fInputReg_PatternSync)){
    firstpattern   = kFALSE;
      }
 
    // If firstpattern is still TRUE, we are still searching for the first
    // pattern of the data stream. So set the pattern number = 0
    if (firstpattern)
      fPatternNumber      = -1;
    else {
      fPatternNumber      = fWord[kPatternCounter].fValue;
      fPatternPhaseNumber = fWord[kPatternPhase].fValue - fPatternPhaseOffset + fMinPatternPhase;
    }
  } else {
    //  Use internal variables for all the counters.
    fEventNumber = fEventNumberOld+1;
    if (CheckIORegisterMask(thisinputregister,fInputReg_PatternSync)) {
      fPatternPhaseNumber = fMinPatternPhase;
      fPatternNumber      = fPatternNumberOld + 1;
    } else  {
      fPatternPhaseNumber = fPatternPhaseNumberOld + 1;
      fPatternNumber      = fPatternNumberOld;
    }
  }
 
 
  if (firstevent){
    firstevent = kFALSE;
  } else if(fEventNumber!=(fEventNumberOld+1)){
    Int_t nummissed(fEventNumber - (fEventNumberOld+1));
    if (!fSuppressMPSErrorMsgs){
      QwError << "QwHelicity::ProcessEvent read event# ("
          << fEventNumber << ") is not  old_event#+1; missed "
          << nummissed << " gates" << QwLog::endl;
    }
    fNumMissedGates += nummissed;
    fNumMissedEventBlocks++;
    fErrorFlag = kErrorFlag_Helicity + kGlobalCut + kEventCutMode3;
  }
 
  if (CheckIORegisterMask(thisinputregister,fInputReg_PatternSync) && fPatternPhaseNumber != fMinPatternPhase){
    //  Quartet bit is set.
    QwError << "QwHelicity::ProcessEvent:  The Multiplet Sync bit is set, but the Pattern Phase is ("
        << fPatternPhaseNumber << ") not "
        << fMinPatternPhase << "!  Please check the fPatternPhaseOffset in the helicity map file." << QwLog::endl;
    fNumMultSyncErrors++;
    fErrorFlag = kErrorFlag_Helicity + kGlobalCut + kEventCutMode3;
  }
 
  fHelicityReported=0;
 
  /**
     Extract the reported helicity from the input register for each event.
  */
 
  if (CheckIORegisterMask(thisinputregister,fInputReg_HelPlus)
      && CheckIORegisterMask(thisinputregister,fInputReg_HelMinus) ){
    //  Both helicity bits are set.
    QwError << "QwHelicity::ProcessEvent:  Both the H+ and H- bits are set: thisinputregister=="
        << thisinputregister << QwLog::endl;
    fHelicityReported = kUndefinedHelicity;
    fHelicityBitPlus  = kFALSE;
    fHelicityBitMinus = kFALSE;
  } else if (CheckIORegisterMask(thisinputregister,fInputReg_HelPlus)){ //  HelPlus bit is set.
    fHelicityReported    |= 1; // Set the InputReg HEL+ bit.
    fHelicityBitPlus  = kTRUE;
    fHelicityBitMinus = kFALSE;
  } else {
    fHelicityReported    |= 0; // Set the InputReg HEL- bit.
    fHelicityBitPlus  = kFALSE;
    fHelicityBitMinus = kTRUE;
  }
 
  return;
}

References CheckIORegisterMask(), QwLog::endl(), QwHelicityBase::fErrorFlag, QwHelicityBase::fEventNumber, QwHelicityBase::fEventNumberOld, QwHelicityBase::fHelicityBitMinus, QwHelicityBase::fHelicityBitPlus, QwHelicityBase::fHelicityReported, QwHelicityBase::fIgnoreHelicity, fInputReg_FakeMPS, fInputReg_HelMinus, fInputReg_HelPlus, fInputReg_PatternSync, QwHelicityBase::fMinPatternPhase, QwHelicityBase::fNumMissedEventBlocks, QwHelicityBase::fNumMissedGates, QwHelicityBase::fNumMultSyncErrors, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternNumberOld, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternPhaseNumberOld, QwHelicityBase::fPatternPhaseOffset, QwHelicityBase::fSuppressMPSErrorMsgs, QwHelicityBase::fWord, kErrorFlag_Helicity, kEventCutMode3, kGlobalCut, QwHelicityBase::kInputRegister, QwHelicityBase::kMpsCounter, QwHelicityBase::kPatternCounter, QwHelicityBase::kPatternPhase, QwHelicityBase::kUndefinedHelicity, and QwError.

Referenced by ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessEventUserbitMode()

void QwHelicity::ProcessEventUserbitMode ( )

Process helicity information from userbit configuration data.

This is a complex function (~80 lines) that extracts helicity information from userbit data for injector tests and special configurations. It handles:

Userbit Decoding:

Extracts 3-bit userbit pattern from bits 28-30 of userbit word
Decodes quartet synchronization bit (bit 3) for pattern timing
Decodes helicity bit (bit 2) for spin state determination
Manages scaler offset calculations for event counting

Event Counting Logic:

Increments event numbers based on scaler counter ratios
Handles missed events when scaler offset > 1 (indicates DAQ issues)
Maintains pattern phase and pattern number synchronization
Resets quartet phase on quartet sync bit assertion

Helicity State Management:

Sets fHelicityBitPlus/fHelicityBitMinus based on userbit helicity bit
Updates fHelicityReported for downstream processing
Maintains helicity predictor state for data quality monitoring

Error Recovery:

Detects missed events through scaler offset analysis
Resets helicity predictor when event sequence is uncertain
Provides debug output for missed event scenarios

Pattern Synchronization:

Manages quartet boundaries using sync bits
Handles pattern phase wraparound at maximum phase
Maintains continuous event numbering across pattern boundaries

Note: This mode is primarily used for injector testing and is not the standard helicity decoding method for production Qweak data analysis.

Warning: Missed events (scaler offset > 1) will reset the helicity predictor and may affect downstream helicity-dependent analyses.

In this version of the code, the helicity is extracted for a userbit configuration. This is not what we plan to have for Qweak but it was done for injector tests and so is useful to have as another option to get helicity information.

Definition at line 298 of file QwHelicity.cc.

{
 
  /** In this version of the code, the helicity is extracted for a userbit configuration.
      This is not what we plan to have for Qweak but it was done for injector tests and
      so is useful to have as another option to get helicity information. */
 
  Bool_t ldebug=kFALSE;
  UInt_t userbits;
  static UInt_t lastuserbits  = 0xFF;
  UInt_t scaleroffset=fWord[kScalerCounter].fValue/32;
 
  if(scaleroffset==1 || scaleroffset==0) {
    userbits = (fWord[kUserbit].fValue & 0xE0000000)>>28;
 
    //  Now fake the input register, MPS counter, QRT counter, and QRT phase.
    fEventNumber=fEventNumberOld+1;
 
    lastuserbits = userbits;
 
    if (lastuserbits==0xFF) {
      fPatternPhaseNumber    = fMinPatternPhase;
    } else {
      if ((lastuserbits & 0x8) == 0x8) {
    //  Quartet bit is set.
    fPatternPhaseNumber    = fMinPatternPhase;  // Reset the QRT phase
    fPatternNumber=fPatternNumberOld+1;     // Increment the QRT counter
      } else {
    fPatternPhaseNumber=fPatternPhaseNumberOld+1;       // Increment the QRT phase
      }
 
      fHelicityReported=0;
 
      if ((lastuserbits & 0x4) == 0x4){ //  Helicity bit is set.
    fHelicityReported    |= 1; // Set the InputReg HEL+ bit.
    fHelicityBitPlus=kTRUE;
    fHelicityBitMinus=kFALSE;
      } else {
    fHelicityReported    |= 0; // Set the InputReg HEL- bit.
    fHelicityBitPlus=kFALSE;
    fHelicityBitMinus=kTRUE;
      }
    }
  } else {
    QwError << " QwHelicity::ProcessEvent finding a missed read event in the scaler" << QwLog::endl;
    if(ldebug) {
      std::cout << " QwHelicity::ProcessEvent :" << scaleroffset << " events were missed \n";
      std::cout << " before manipulation \n";
      Print();
    }
    //there was more than one event since the last reading of the scalers
    //ie we should read only one event at the time,
    //if not something is wrong
    fEventNumber=fEventNumberOld+scaleroffset;
    Int_t localphase=fPatternPhaseNumberOld;
    Int_t localpatternnumber=fPatternNumberOld;
    for (UInt_t i=0;i<scaleroffset;i++) {
      fPatternPhaseNumber=localphase+1;
      if(fPatternPhaseNumber>fMaxPatternPhase) {
    fPatternNumber=localpatternnumber+fPatternPhaseNumber/fMaxPatternPhase;
    fPatternPhaseNumber=fPatternPhaseNumber-fMaxPatternPhase;
    localpatternnumber=fPatternNumber;
      }
      localphase=fPatternPhaseNumber;
    }
    //Reset helicity predictor because we are not sure of what we are doing
    fHelicityReported=-1;
    ResetPredictor();
    if(ldebug) {
      std::cout << " after manipulation \n";
      Print();
    }
  }
  return;
}

References QwLog::endl(), QwHelicityBase::fEventNumber, QwHelicityBase::fEventNumberOld, QwHelicityBase::fHelicityBitMinus, QwHelicityBase::fHelicityBitPlus, QwHelicityBase::fHelicityReported, QwHelicityBase::fMaxPatternPhase, QwHelicityBase::fMinPatternPhase, QwHelicityBase::fPatternNumber, QwHelicityBase::fPatternNumberOld, QwHelicityBase::fPatternPhaseNumber, QwHelicityBase::fPatternPhaseNumberOld, QwHelicityBase::fWord, QwHelicityBase::kScalerCounter, QwHelicityBase::kUserbit, QwHelicityBase::Print(), QwError, and QwHelicityBase::ResetPredictor().

Referenced by ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessOptions()

void QwHelicity::ProcessOptions ( QwOptions & )

overridevirtual

Process the command line options.

Reimplemented from VQwSubsystem.

Definition at line 139 of file QwHelicity.cc.

{
  // Read the cmd options and override channel map settings
  QwMessage << "QwHelicity::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");
    SetHelicityBitPattern(hex);
  } else {
  }
 
  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) {
  }
 
  //  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 QwLog::endl(), QwHelicityBase::fHelicityBitPattern, QwHelicityBase::fHelicityDelay, QwHelicityBase::fMaxPatternPhase, QwHelicityBase::fPatternPhaseOffset, QwHelicityBase::fRandBits, QwHelicityBase::fSuppressMPSErrorMsgs, QwHelicityBase::fUsePredictor, QwOptions::GetValue(), QwOptions::HasValue(), QwHelicityBase::kDefaultHelicityBitPattern, QwError, QwMessage, QwHelicityBase::SetHelicityBitPattern(), and QwHelicityBase::SetHelicityDelay().

Here is the call graph for this function:

Field Documentation

◆ fInputReg_FakeMPS

UInt_t QwHelicity::fInputReg_FakeMPS

protected

Definition at line 105 of file QwHelicity.h.

Referenced by LoadChannelMap(), ProcessEventInputRegisterMode(), and QwHelicity().

◆ fInputReg_HelMinus

UInt_t QwHelicity::fInputReg_HelMinus

protected

Definition at line 107 of file QwHelicity.h.

Referenced by EncodeEventData(), LoadChannelMap(), ProcessEventInputRegisterMode(), QwHelicity(), and QwHelicity().

◆ fInputReg_HelPlus

UInt_t QwHelicity::fInputReg_HelPlus

protected

Definition at line 106 of file QwHelicity.h.

Referenced by EncodeEventData(), LoadChannelMap(), ProcessEventInputRegisterMode(), QwHelicity(), and QwHelicity().

◆ fInputReg_PairSync

UInt_t QwHelicity::fInputReg_PairSync

protected

Definition at line 109 of file QwHelicity.h.

Referenced by LoadChannelMap(), QwHelicity(), and QwHelicity().

◆ fInputReg_PatternSync

UInt_t QwHelicity::fInputReg_PatternSync

protected

Definition at line 108 of file QwHelicity.h.

Referenced by EncodeEventData(), LoadChannelMap(), ProcessEventInputRegisterMode(), QwHelicity(), and QwHelicity().

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

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ HelicityEncodingType

◆ InputRegisterBits

Constructor & Destructor Documentation

◆ QwHelicity() [1/3]

◆ QwHelicity() [2/3]

◆ QwHelicity() [3/3]

◆ ~QwHelicity()

Member Function Documentation

◆ ApplySingleEventCuts()

◆ CheckForBurpFail()

◆ CheckIORegisterMask()

◆ ClearEventData()

◆ ConstructBranchAndVector() [1/2]

◆ ConstructBranchAndVector() [2/2]

◆ ConstructHistograms() [1/4]

◆ ConstructHistograms() [2/4]

◆ ConstructHistograms() [3/4]

◆ ConstructHistograms() [4/4]

◆ DefineOptions()

◆ EncodeEventData()

◆ GetRandomSeedActual()

◆ GetRandomSeedDelayed()

◆ LoadChannelMap()

◆ LoadEventCuts()

◆ LoadInputParameters()

◆ operator=()

◆ ProcessConfigurationBuffer()

◆ ProcessEvBuffer() [1/2]

◆ ProcessEvBuffer() [2/2]

◆ ProcessEvent()

◆ ProcessEventInputMollerMode()

◆ ProcessEventInputRegisterMode()

◆ ProcessEventUserbitMode()

◆ ProcessOptions()

Field Documentation

◆ fInputReg_FakeMPS

◆ fInputReg_HelMinus

◆ fInputReg_HelPlus

◆ fInputReg_PairSync

◆ fInputReg_PatternSync