Base subsystem for helicity state management and pattern recognition. More...

#include <QwHelicityBase.h>

Inheritance diagram for QwHelicityBase:

Collaboration diagram for QwHelicityBase:

Public Member Functions
	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

virtual void	ClearEventData () 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	ProcessEvent ()=0

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	EncodeEventData (std::vector< UInt_t > &)

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.

Static Public Member Functions
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++)

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

Protected Member Functions
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
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
static const std::vector< UInt_t >	kDefaultHelicityBitPattern {0x69}

static const Bool_t	kDEBUG =kFALSE

static const Int_t	kUndefinedHelicity = -9999

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

Detailed Description

Base 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 52 of file QwHelicityBase.h.

Member Enumeration Documentation

◆ HelicityRootSavingType

enum QwHelicityBase::HelicityRootSavingType

protected

Enumerator
kHelSaveMPS
kHelSavePattern
kHelNoSave

Definition at line 169 of file QwHelicityBase.h.

                             {kHelSaveMPS = 0,
                  kHelSavePattern,
                  kHelNoSave};

Constructor & Destructor Documentation

◆ QwHelicityBase() [1/3]

QwHelicityBase::QwHelicityBase ( )

private

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

References QwHelicityBase().

Referenced by AccumulateRunningSum(), CheckPatternNum(), Compare(), MergeCounters(), operator=(), QwFakeHelicity::QwFakeHelicity(), QwHelicity::QwHelicity(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), QwHelicityDecoder::QwHelicityDecoder(), and QwHelicityDecoder::QwHelicityDecoder().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QwHelicityBase() [2/3]

QwHelicityBase::QwHelicityBase ( const TString & name )

Constructor with name.

Definition at line 41 of file QwHelicityBase.cc.

: VQwSubsystem(name),
  VQwSubsystemParity(name),
  fHelicityBitPattern(kDefaultHelicityBitPattern),
  kPatternCounter(-1), kMpsCounter(-1), kPatternPhase(-1),
  fMinPatternPhase(1), fUsePredictor(kTRUE), fIgnoreHelicity(kFALSE),
  fEventNumberFirst(-1),fPatternNumberFirst(-1),
  fSuppressMPSErrorMsgs(kFALSE)
{
  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;
  n_ranbits = 0;
  fGoodHelicity=kFALSE;
  fGoodPattern=kFALSE;
  fHelicityDecodingMode=-1;
 
//  fInputReg_FakeMPS = kDefaultInputReg_FakeMPS;
}

References ClearErrorCounters(), fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fEventNumberFirst, fEventNumberOld, fGoodHelicity, fGoodPattern, fHelicityActual, fHelicityBitMinus, fHelicityBitPattern, fHelicityBitPlus, fHelicityDecodingMode, fHelicityDelay, fHelicityDelayed, fHelicityReported, fIgnoreHelicity, fMinPatternPhase, fPatternNumber, fPatternNumberFirst, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, fSuppressMPSErrorMsgs, fUsePredictor, kDefaultHelicityBitPattern, kEventTypeHelMinus, kEventTypeHelPlus, kMpsCounter, kPatternCounter, kPatternPhase, kUndefinedHelicity, kUserbit, n_ranbits, VQwSubsystem::VQwSubsystem(), and VQwSubsystemParity::VQwSubsystemParity().

Here is the call graph for this function:

◆ QwHelicityBase() [3/3]

QwHelicityBase::QwHelicityBase ( const QwHelicityBase & source )

Copy constructor.

Definition at line 82 of file QwHelicityBase.cc.

: VQwSubsystem(source.GetName()),
  VQwSubsystemParity(source.GetName()),
  kPatternCounter(source.kPatternCounter),
  kMpsCounter(source.kMpsCounter),
  kPatternPhase(source.kPatternPhase),
  fMinPatternPhase(1), fUsePredictor(kTRUE), fIgnoreHelicity(kFALSE),
  fEventNumberFirst(-1),fPatternNumberFirst(-1),
  fSuppressMPSErrorMsgs(kFALSE)
{
  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;
}

References ClearErrorCounters(), fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fEventNumberFirst, fEventNumberOld, fGoodHelicity, fGoodPattern, fHelicityActual, fHelicityBitMinus, fHelicityBitPattern, fHelicityBitPlus, fHelicityDecodingMode, fHelicityDelay, fHelicityDelayed, fHelicityReported, fIgnoreHelicity, fMinPatternPhase, fPatternNumber, fPatternNumberFirst, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, fSuppressMPSErrorMsgs, fUsePredictor, fWord, VQwSubsystem::GetName(), kEventTypeHelMinus, kEventTypeHelPlus, kMpsCounter, kPatternCounter, kPatternPhase, kUndefinedHelicity, kUserbit, QwHelicityBase(), VQwSubsystem::VQwSubsystem(), and VQwSubsystemParity::VQwSubsystemParity().

Here is the call graph for this function:

◆ ~QwHelicityBase()

virtual QwHelicityBase::~QwHelicityBase ( )

inlineoverridevirtual

Virtual destructor.

Definition at line 64 of file QwHelicityBase.h.

64{ }

Member Function Documentation

◆ AccumulateRunningSum()

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

overridevirtual

Update the running sums for devices.

Implements VQwSubsystemParity.

Reimplemented in QwHelicityDecoder.

Definition at line 1640 of file QwHelicityBase.cc.

                                                                                           {
  if (Compare(value)) {
    MergeCounters(value);
    QwHelicityBase* input = dynamic_cast<QwHelicityBase*>(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(), fNumHelicityErrors, fNumMissedEventBlocks, fNumMissedGates, fNumMultSyncErrors, fPatternNumber, MergeCounters(), QwHelicityBase(), and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ ApplySingleEventCuts()

Bool_t QwHelicityBase::ApplySingleEventCuts ( )

overridevirtual

Apply the single event cuts.

Implements VQwSubsystemParity.

Reimplemented in QwHelicityDecoder.

Definition at line 407 of file QwHelicityBase.cc.

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

◆ BuildHelicityBitPattern()

UInt_t QwHelicityBase::BuildHelicityBitPattern ( Int_t patternsize )

protected

Definition at line 1669 of file QwHelicityBase.cc.

                                                               {
  UInt_t bitpattern = 0;
  //  Standard helicity board patterns (last to first):
  //  Pair, quad, octet: -++-+--+ : 0x69
  //  Hexo-quad:         -++--++--++-+--++--++--+ : 0x666999
  //  Octo-quad:         -++--++--++--++-+--++--++--++--+ : 0x66669999
  //
  //std::cout << fHelicityBitPattern.size() << std::endl;
  fHelicityBitPattern.clear();
  if (patternsize<8){
    fHelicityBitPattern = kDefaultHelicityBitPattern;
  } else if (patternsize%2==0 && patternsize>0 && patternsize < 129){
    int num_int = TMath::CeilNint(patternsize/32.);
    //std::cout << num_int << " " << patternsize << " " << TMath::Ceil(patternsize/32.) << std::endl;
    fHelicityBitPattern.resize(num_int);
    bitpattern = 0x69969669;
    fHelicityBitPattern[0] = bitpattern;
    for (int i = 1; i<num_int; i++){
      fHelicityBitPattern[i] = ~fHelicityBitPattern[i-1];
    }
    /*if (patternsize%8==0){
    Int_t halfshift = patternsize/2;
    for (Int_t i=0; i<(patternsize/8); i++){
      bitpattern += (0x9<<(i*4));
      bitpattern += (0x6<<(halfshift+i*4));
    }
    */
  } else {
    QwError << "QwHelicityBase::BuildHelicityBitPattern: "
        << "Unable to build standard bit pattern for pattern size of "
        << patternsize << ".  Try a pattern of 0x69."
        << QwLog::endl;
    fHelicityBitPattern = kDefaultHelicityBitPattern;
  }
  //std::cout << fHelicityBitPattern.size() << std::endl;
  /*QwMessage << "QwHelicityBase::BuildHelicityBitPattern: "
      << "Built pattern 0x" << std::hex << bitpattern
      << std::dec << " for pattern size "
      << patternsize << "." << QwLog::endl;
    */
  QwMessage << "QwHelicityBase::BuildHelicityBitPattern: "
          << "Built pattern 0x";
  for (int i = fHelicityBitPattern.size()-1;i>=0; i--){
    QwMessage << std::hex << fHelicityBitPattern[i] << " ";
  }
  QwMessage << std::dec << "for pattern size "
          << patternsize << "." << QwLog::endl;
  //  Now set the bit pattern.
  //  SetHelicityBitPattern(bitpattern);
  return fHelicityBitPattern[0];
}

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

Referenced by QwHelicity::LoadChannelMap(), LoadChannelMap(), ProcessOptions(), and QwHelicityDecoder::ProcessOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateRunningAverage()

void QwHelicityBase::CalculateRunningAverage ( )

inlineoverridevirtual

Calculate the average for all good events.

Implements VQwSubsystemParity.

Definition at line 132 of file QwHelicityBase.h.

132{ };

◆ CheckForBurpFail()

Bool_t QwHelicityBase::CheckForBurpFail ( const VQwSubsystem * subsys )

inlineoverridevirtual

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

Implements VQwSubsystemParity.

Reimplemented in QwHelicityDecoder.

Definition at line 77 of file QwHelicityBase.h.

                                                                 {
    return kFALSE;
  };

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ CheckPatternNum()

void QwHelicityBase::CheckPatternNum ( VQwSubsystem * value )

protected

Definition at line 1596 of file QwHelicityBase.cc.

{
  //  Bool_t localdebug=kFALSE;
  if(Compare(value)) {
    QwHelicityBase* input= dynamic_cast<QwHelicityBase*>(value);
    QwDebug << "QwHelicityBase::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(), fActualPatternPolarity, fErrorFlag, fPatternNumber, kErrorFlag_Helicity, kEventCutMode3, kGlobalCut, QwDebug, QwHelicityBase(), and VQwSubsystem::VQwSubsystem().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearErrorCounters()

void QwHelicityBase::ClearErrorCounters ( )

inlineprotected

Definition at line 275 of file QwHelicityBase.h.

                           {
    fNumMissedGates       = 0;
    fNumMissedEventBlocks = 0;
    fNumMultSyncErrors    = 0;
    fNumHelicityErrors    = 0;
  };

References fNumHelicityErrors, fNumMissedEventBlocks, fNumMissedGates, and fNumMultSyncErrors.

Referenced by QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

Here is the caller graph for this function:

◆ ClearEventData()

void QwHelicityBase::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.

Implements VQwSubsystem.

Reimplemented in QwFakeHelicity, QwHelicity, and QwHelicityDecoder.

Definition at line 356 of file QwHelicityBase.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(), fEventNumber, fEventNumberFirst, fEventNumberOld, fHelicityActual, fHelicityBitMinus, fHelicityBitPlus, fHelicityDelayed, fHelicityReported, fPatternNumber, fPatternNumberFirst, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, fWord, kUndefinedHelicity, and VQwSubsystem::SetDataLoaded().

Referenced by ClearEventData().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CollectRandBits()

Bool_t QwHelicityBase::CollectRandBits ( )

protectedvirtual

Reimplemented in QwFakeHelicity.

Definition at line 1276 of file QwHelicityBase.cc.

{
  Bool_t status = false;
 
  if (fRandBits == 24)
    status = CollectRandBits24();
  if (fRandBits == 30)
    status = CollectRandBits30();
 
  return status;
}

References CollectRandBits24(), CollectRandBits30(), and fRandBits.

Referenced by PredictHelicity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CollectRandBits24()

Bool_t QwHelicityBase::CollectRandBits24 ( )

protected

Definition at line 1290 of file QwHelicityBase.cc.

{
    //routine to collect 24 random bits before getting the randseed for prediction
    Bool_t  ldebug = kFALSE;
    const UInt_t ranbit_goal = 24;
 
  QwDebug << "QwHelicityBase::Entering CollectRandBits24...." << QwLog::endl;
 
 
  if (n_ranbits==ranbit_goal)    return kTRUE;
 
  if(n_ranbits<ranbit_goal&&fPatternPhaseNumber==fMinPatternPhase)
    {
      QwMessage << "Collecting information from event #" << fEventNumber << " to generate helicity seed"
                << "(need 24 bit, so far got " << n_ranbits << " bits )" << QwLog::endl;
    }
 
 
  static UShort_t first24bits[25]; //array to store the first 24 bits
 
  fGoodHelicity = kFALSE; //reset before prediction begins
  if(IsContinuous())
    {
      if((fPatternPhaseNumber==fMinPatternPhase)&& (fPatternNumber>=0))
    {
      first24bits[n_ranbits+1] = fHelicityReported;
      n_ranbits ++;
      if(ldebug)
        {
          std::cout << " event number" << fEventNumber << ", fPatternNumber"
                << fPatternNumber << ", n_ranbit" << n_ranbits
                << ", fHelicityReported" << fHelicityReported << "\n";
        }
 
      if(n_ranbits == ranbit_goal ) //If its the 24th consecative random bit,
        {
           if(ldebug)
         {
           std::cout << "Collected 24 random bits. Get the random seed for the predictor." << "\n";
           for(UInt_t i=0;i<ranbit_goal;i++) std::cout << " i:bit =" << i << ":" << first24bits[i] << "\n";
         }
          iseed_Delayed = GetRandomSeed(first24bits);
          //This random seed will predict the helicity of the event (24+fHelicityDelay) patterns  before;
          // run GetRandBit 24 times to get the delayed helicity for this event
           QwDebug << "The reported seed 24 patterns ago = " << iseed_Delayed << "\n";
 
          for(UInt_t i=0;i<ranbit_goal;i++) fDelayedPatternPolarity =GetRandbit(iseed_Delayed);
          fHelicityDelayed = fDelayedPatternPolarity;
          //The helicity of the first phase in a pattern is
          //equal to the polarity of the pattern
 
          //Check whether the reported helicity is the same as the helicity predicted by the random seed
 
          if(fHelicityDelay >=0){
        iseed_Actual = iseed_Delayed;
        for(Int_t i=0; i<fHelicityDelay; i++)
          {
            QwDebug << "Delaying helicity " << QwLog::endl;
            fPreviousPatternPolarity = fActualPatternPolarity;
            fActualPatternPolarity = GetRandbit(iseed_Actual);
          }
          }
          else
        {
          QwError << "QwHelicityBase::CollectRandBits  We cannot handle negative delay(prediction) in the reported helicity. Exiting." << QwLog::endl;
          ResetPredictor();
        }
 
          fHelicityActual =  fActualPatternPolarity;
        }
    }
    }
  else // while collecting the seed, we encounter non continuous events.
    {
      ResetPredictor();
      QwError << "QwHelicityBase::CollectRandBits, while collecting the seed, we encountered non continuous events: need to reset the seed collecting " << QwLog::endl
          << " event number=" << fEventNumber << ", fPatternNumber="
          << fPatternNumber << ",  fPatternPhaseNumber=" << fPatternPhaseNumber << QwLog::endl;
    }
 
      //else n randbits have been set to zero in the error checking routine
      //start over from the next pattern
  QwDebug << "QwHelicityBase::CollectRandBits24 => Done collecting ..." << QwLog::endl;
 
  return kFALSE;
 
}

References QwLog::endl(), fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fGoodHelicity, fHelicityActual, fHelicityDelay, fHelicityDelayed, fHelicityReported, fMinPatternPhase, fPatternNumber, fPatternPhaseNumber, fPreviousPatternPolarity, GetRandbit(), GetRandomSeed(), IsContinuous(), iseed_Actual, iseed_Delayed, n_ranbits, QwDebug, QwError, QwMessage, and ResetPredictor().

Referenced by CollectRandBits().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CollectRandBits30()

Bool_t QwHelicityBase::CollectRandBits30 ( )

protected

Starting to collect 30 bits/helicity state to get the random seed for the 30 bit helicity predictor. These bits (1/0) are the reported helicity states of the first event of each new pattern ot the so called pattern polarity.

If we have finished collecting the bits then ignore the rest of this funciton and return true. No need to recollect!

If we are still collecting the bits, make sure we collect them from only the events with the minimum pattern phase.

If the events are continuous, start to make the ranseed for the helicity pattern we are getting which is the delayed helicity.

Make sure we are at the beging of a valid pattern.

If we got the 30th bit,

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.

If we have a negative delay. Reset the predictor.

If all is well so far, set the actual pattern polarity as the actual helicity.

while collecting the seed, we encounter non continuous events.Discard bit. Reset the predition

Definition at line 1379 of file QwHelicityBase.cc.

{
  /** Starting to collect 30 bits/helicity state to get the
      random seed for the 30 bit helicity predictor.
      These bits (1/0) are the reported helicity states of the first event
      of each new pattern ot the so called pattern polarity.*/
 
  //  Bool_t  ldebug = kFALSE;
  const UInt_t ranbit_goal = 30;
 
  /** If we have finished collecting the bits then ignore the rest of this funciton and return true.
      No need to recollect!*/
  if (n_ranbits == ranbit_goal)    return kTRUE;
 
  /** If we are still collecting the bits, make sure we collect them from only the
      events with the minimum pattern phase.*/
 
  if (n_ranbits < ranbit_goal && fPatternPhaseNumber == fMinPatternPhase) {
    QwMessage << "Collecting information (";
    if (fHelicityReported == 1) QwMessage << "+";
    else                        QwMessage << "-";
    QwMessage << ") from event #" << fEventNumber << " to generate helicity seed ";
    QwMessage << "(need " << ranbit_goal << " bit, so far got " << n_ranbits << " bits )" << QwLog::endl;
  }
 
  /** If the events are continuous, start to make the ranseed for the helicity
      pattern we are getting which is the delayed helicity.*/
 
  fGoodHelicity = kFALSE; //reset before prediction begins
 
  if(IsContinuous()) {
    /**  Make sure we are at the beging of a valid pattern. */
    if((fPatternPhaseNumber==fMinPatternPhase)&& (fPatternNumber>=0)) {
      iseed_Delayed = ((iseed_Delayed << 1)&0x3FFFFFFF)|fHelicityReported;
      QwDebug << "QwHelicityBase:: CollectRandBits30:  Collecting randbit " << n_ranbits << ".." << QwLog::endl;
      n_ranbits++;
 
      /** If we got the 30th bit,*/
      if(n_ranbits == ranbit_goal){
    QwDebug << "QwHelicityBase:: CollectRandBits30:  done Collecting 30 randbits" << QwLog::endl;
 
    /** set the polarity of the current pattern to be equal to the reported helicity,*/
    fDelayedPatternPolarity = fHelicityReported;
    QwDebug << "QwHelicityBase:: 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 = GetRandbit(iseed_Actual);
      }
    } else {
      /** If we have a negative delay. Reset the predictor.*/
      QwError << "QwHelicityBase::CollectRandBits30:  We cannot handle negative delay(prediction) in the reported helicity. Exiting." << QwLog::endl;
      ResetPredictor();
    }
    /** If all is well so far, set the actual pattern polarity as the actual helicity.*/
    fHelicityActual =  fActualPatternPolarity;
      }
    }
  } else {
    /** while collecting the seed, we encounter non continuous events.Discard bit. Reset the predition*/
    ResetPredictor();
    QwWarning << "QwHelicityBase::CollectRandBits30:  While collecting the seed, we encountered non continuous events: Need to reset the seed collecting " << QwLog::endl;
    QwDebug   << " event number=" << fEventNumber << ", fPatternNumber="<< fPatternNumber << ",  fPatternPhaseNumber=" << fPatternPhaseNumber << QwLog::endl;
  }
  return kFALSE;
}

References QwLog::endl(), fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fGoodHelicity, fHelicityActual, fHelicityDelay, fHelicityDelayed, fHelicityReported, fMinPatternPhase, fPatternNumber, fPatternPhaseNumber, fPreviousPatternPolarity, GetRandbit(), IsContinuous(), iseed_Actual, iseed_Delayed, n_ranbits, QwDebug, QwError, QwMessage, QwWarning, and ResetPredictor().

Referenced by CollectRandBits().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Compare()

Bool_t QwHelicityBase::Compare ( VQwSubsystem * source )

protected

Definition at line 1655 of file QwHelicityBase.cc.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructBranch() [1/2]

void QwHelicityBase::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.

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 893 of file QwHelicityBase.cc.

{
  TString basename;
 
  SetHistoTreeSave(prefix);
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSaveMPS)
    {
      // basename = "actual_helicity";    //predicted actual helicity before being delayed.
      // tree->Branch(basename, &fHelicityActual, basename+"/I");
      //
      basename = "delayed_helicity";   //predicted delayed helicity
      tree->Branch(basename, &fHelicityDelayed, basename+"/I");
      //
      basename = "reported_helicity";  //delayed helicity reported by the input register.
      tree->Branch(basename, &fHelicityReported, basename+"/I");
      //
      basename = "pattern_phase";
      tree->Branch(basename, &fPatternPhaseNumber, basename+"/I");
      //
      basename = "pattern_number";
      tree->Branch(basename, &fPatternNumber, basename+"/I");
      //
      basename = "pattern_seed";
      tree->Branch(basename, &fPatternSeed, basename+"/I");
      //
      basename = "event_number";
      tree->Branch(basename, &fEventNumber, basename+"/I");
    }
  else if(fHistoType==kHelSavePattern)
    {
      basename = "actual_helicity";    //predicted actual helicity before being delayed.
      tree->Branch(basename, &fHelicityActual, basename+"/I");
      //
      basename = "actual_pattern_polarity";
      tree->Branch(basename, &fActualPatternPolarity, basename+"/I");
      //
      basename = "actual_previous_pattern_polarity";
      tree->Branch(basename, &fPreviousPatternPolarity, basename+"/I");
      //
      basename = "delayed_pattern_polarity";
      tree->Branch(basename, &fDelayedPatternPolarity, basename+"/I");
      //
      basename = "pattern_number";
      tree->Branch(basename, &fPatternNumber, basename+"/I");
      //
      basename = "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 fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fHelicityActual, fHelicityDelayed, fHelicityReported, fHistoType, fPatternNumber, fPatternPhaseNumber, fPatternSeed, fPreviousPatternPolarity, fWord, kHelNoSave, kHelSaveMPS, kHelSavePattern, and SetHistoTreeSave().

Here is the call graph for this function:

◆ ConstructBranch() [2/2]

void QwHelicityBase::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.

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 955 of file QwHelicityBase.cc.

{
  TString basename;
 
  SetHistoTreeSave(prefix);
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSaveMPS)
    {
      // basename = "actual_helicity";    //predicted actual helicity before being delayed.
      // tree->Branch(basename, &fHelicityActual, basename+"/I");
      //
      basename = "delayed_helicity";   //predicted delayed helicity
      tree->Branch(basename, &fHelicityDelayed, basename+"/I");
      //
      basename = "reported_helicity";  //delayed helicity reported by the input register.
      tree->Branch(basename, &fHelicityReported, basename+"/I");
      //
      basename = "pattern_phase";
      tree->Branch(basename, &fPatternPhaseNumber, basename+"/I");
      //
      basename = "pattern_number";
      tree->Branch(basename, &fPatternNumber, basename+"/I");
      //
      basename = "pattern_seed";
      tree->Branch(basename, &fPatternSeed, basename+"/I");
      //
      basename = "event_number";
      tree->Branch(basename, &fEventNumber, basename+"/I");
    }
  else if(fHistoType==kHelSavePattern)
    {
      basename = "actual_helicity";    //predicted actual helicity before being delayed.
      tree->Branch(basename, &fHelicityActual, basename+"/I");
      //
      basename = "actual_pattern_polarity";
      tree->Branch(basename, &fActualPatternPolarity, basename+"/I");
      //
      basename = "actual_previous_pattern_polarity";
      tree->Branch(basename, &fPreviousPatternPolarity, basename+"/I");
      //
      basename = "delayed_pattern_polarity";
      tree->Branch(basename, &fDelayedPatternPolarity, basename+"/I");
      //
      basename = "pattern_number";
      tree->Branch(basename, &fPatternNumber, basename+"/I");
      //
      basename = "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 fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fHelicityActual, fHelicityDelayed, fHelicityReported, fHistoType, fPatternNumber, fPatternPhaseNumber, fPatternSeed, fPreviousPatternPolarity, fWord, kHelNoSave, kHelSaveMPS, 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 VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 303 of file VQwSubsystem.h.

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

◆ ConstructBranchAndVector() [2/2]

void QwHelicityBase::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.

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 810 of file QwHelicityBase.cc.

{
  SetHistoTreeSave(prefix);
  fTreeArrayIndex  = values.size();
  TString basename;
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSaveMPS)
    {
      // basename = "actual_helicity";    //predicted actual helicity before being delayed.
      // values.push_back(basename, 'I');
      // tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "delayed_helicity";   //predicted delayed helicity
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "reported_helicity";  //delayed helicity reported by the input register.
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "pattern_phase";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "pattern_number";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "pattern_seed";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "event_number";
      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 = "actual_helicity";    //predicted actual helicity before being delayed.
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "actual_pattern_polarity";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "actual_previous_pattern_polarity";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "delayed_pattern_polarity";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "pattern_number";
      values.push_back(basename, 'I');
      tree->Branch(basename, &(values.back<Double_t>()), basename+"/I");
      //
      basename = "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");
    }
    }
 
  return;
}

References QwRootTreeBranchVector::back(), fHistoType, fTreeArrayIndex, fWord, kHelNoSave, kHelSaveMPS, 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 VQwSubsystem.

Reimplemented in QwHelicityDecoder.

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.

Reimplemented in QwHelicityDecoder.

Definition at line 275 of file VQwSubsystem.h.

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

◆ ConstructHistograms() [3/4]

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

overridevirtual

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

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 710 of file QwHelicityBase.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);
      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 << "QwHelicityBase::ConstructHistograms this prefix--" << prefix << "-- is not unknown:: no histo created" << QwLog::endl;
 
  return;
}

References QwLog::endl(), MQwHistograms::fHistograms, fHistoType, fWord, gQwHists, kHelNoSave, kHelSaveMPS, 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 VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 280 of file VQwSubsystem.h.

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

◆ DeaccumulateRunningSum()

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

inlineoverridevirtual

remove one entry from the running sums for devices

Implements VQwSubsystemParity.

Reimplemented in QwHelicityDecoder.

Definition at line 131 of file QwHelicityBase.h.

131{ };

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ DefineOptions()

void QwHelicityBase::DefineOptions ( QwOptions & options )

static

Define options function.

Definition at line 153 of file QwHelicityBase.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:

◆ FillHistograms()

void QwHelicityBase::FillHistograms ( )

overridevirtual

Fill the histograms for this subsystem.

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 760 of file QwHelicityBase.cc.

{
  //  Bool_t localdebug=kFALSE;
 
  size_t index=0;
  if(fHistoType==kHelNoSave)
    {
      //do nothing
    }
  else if(fHistoType==kHelSavePattern)
    {
      QwDebug << "QwHelicityBase::FillHistograms helicity info " << QwLog::endl;
      QwDebug << "QwHelicityBase::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 << "QwHelicityBase::FillHistograms " << fWord[i].fWordName << "=" << fWord[i].fValue << QwLog::endl;
      }
    }
  else if(fHistoType==kHelSaveMPS)
    {
      QwDebug << "QwHelicityBase::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 << "QwHelicityBase::FillHistograms " << fWord[i].fWordName << "=" << fWord[i].fValue << QwLog::endl;
      }
    }
 
  return;
}

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

Here is the call graph for this function:

◆ FillTreeVector()

void QwHelicityBase::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.

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 1019 of file QwHelicityBase.cc.

{
 
  size_t index=fTreeArrayIndex;
  if(fHistoType==kHelSaveMPS)
    {
      // values[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);
      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 fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fHelicityActual, fHelicityDelayed, fHelicityReported, fHistoType, fPatternNumber, fPatternPhaseNumber, fPatternSeed, fPreviousPatternPolarity, fTreeArrayIndex, fWord, kHelSaveMPS, kHelSavePattern, and QwRootTreeBranchVector::SetValue().

Here is the call graph for this function:

◆ GetEventcutErrorFlag()

UInt_t QwHelicityBase::GetEventcutErrorFlag ( )

overridevirtual

Return the error flag to the top level routines related to stability checks and ErrorFlag updates.

Implements VQwSubsystemParity.

Definition at line 445 of file QwHelicityBase.cc.

                                           {//return the error flag
  return fErrorFlag;
}

References fErrorFlag.

◆ GetEventNumber()

Long_t QwHelicityBase::GetEventNumber ( )

Definition at line 669 of file QwHelicityBase.cc.

{
  return fEventNumber;
}

References fEventNumber.

Referenced by QwHelicityPattern::LoadEventData().

Here is the caller graph for this function:

◆ GetHelicityActual()

Int_t QwHelicityBase::GetHelicityActual ( )

Definition at line 654 of file QwHelicityBase.cc.

{
  return fHelicityActual;
}

References fHelicityActual.

Referenced by QwHelicityPattern::LoadEventData(), and main().

Here is the caller graph for this function:

◆ GetHelicityDelayed()

Int_t QwHelicityBase::GetHelicityDelayed ( )

Definition at line 659 of file QwHelicityBase.cc.

{
  return fHelicityDelayed;
}

References fHelicityDelayed.

Referenced by main().

Here is the caller graph for this function:

◆ GetHelicityReported()

Int_t QwHelicityBase::GetHelicityReported ( )

Definition at line 649 of file QwHelicityBase.cc.

{
  return fHelicityReported;
}

References fHelicityReported.

◆ GetMaxPatternPhase()

Int_t QwHelicityBase::GetMaxPatternPhase ( )

inline

Definition at line 111 of file QwHelicityBase.h.

                            {
    return fMaxPatternPhase;
  };

References fMaxPatternPhase.

◆ GetMinPatternPhase()

Int_t QwHelicityBase::GetMinPatternPhase ( )

inline

Definition at line 114 of file QwHelicityBase.h.

                            {
    return fMinPatternPhase;
  }

References fMinPatternPhase.

Referenced by QwHelicityPattern::LoadEventData().

Here is the caller graph for this function:

◆ GetPatternNumber()

Long_t QwHelicityBase::GetPatternNumber ( )

Definition at line 664 of file QwHelicityBase.cc.

{
  return  fPatternNumber;
}

References fPatternNumber.

Referenced by QwHelicityPattern::LoadEventData().

Here is the caller graph for this function:

◆ GetPhaseNumber()

Int_t QwHelicityBase::GetPhaseNumber ( )

Definition at line 674 of file QwHelicityBase.cc.

{
  return fPatternPhaseNumber;
}

References fPatternPhaseNumber.

Referenced by QwHelicityPattern::LoadEventData().

Here is the caller graph for this function:

◆ GetRandbit()

UInt_t QwHelicityBase::GetRandbit ( UInt_t & ranseed )

protectedvirtual

Reimplemented in QwFakeHelicity.

Definition at line 1073 of file QwHelicityBase.cc.

                                                {
  Bool_t status = false;
 
  if (fRandBits == 24)
    status = GetRandbit24(ranseed);
  if (fRandBits == 30)
    status = GetRandbit30(ranseed);
 
  return status;
}

References fRandBits, GetRandbit24(), and GetRandbit30().

Referenced by CollectRandBits24(), CollectRandBits30(), RunPredictor(), SetFirstBits(), and QwHelicityDecoder::SetFirstBits().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRandbit24()

UInt_t QwHelicityBase::GetRandbit24 ( UInt_t & ranseed )

protected

This is a 24 bit random bit generator according to the "new" algorithm described in "G0 Helicity Digital Controls" by E. Stangland, R. Flood, H. Dong.

The helicity board uses a maximum-length linear feedback shift registers for the generation of a pseudo-random sequence of bits. The length of the register (24 bits or 30 bits) defines the length before a sequence is repeated: 2^n - 1.

For a mathematical introduction to the generation of pseudo-random numbers with maximum-length linear feedback shift registers (LFSR), see the following web references: http://en.wikipedia.org/wiki/Linear_feedback_shift_register http://www.newwaveinstruments.com/resources/articles/m_sequence_linear_feedback_shift_register_lfsr.htm

In particular, the used solutions are to place XNOR taps at the bits 24 stages, 4 taps: (47 sets) [24, 23, 21, 20] 30 stages, 4 taps: (104 sets) [30, 29, 28, 7]

The 24 stage solution we use has been mirrored by transforming [m, A, B, C] into [m, m-C, m-B, m-A]. This goes through the sequence in the opposite direction.

Definition at line 1084 of file QwHelicityBase.cc.

{
  /** This is a 24 bit random bit generator according to the "new" algorithm
     described in "G0 Helicity Digital Controls" by E. Stangland, R. Flood, H. Dong.
 
 
     The helicity board uses a maximum-length linear feedback shift registers
     for the generation of a pseudo-random sequence of bits.  The length of the
     register (24 bits or 30 bits) defines the length before a sequence is
     repeated: 2^n - 1.
 
     For a mathematical introduction to the generation of pseudo-random numbers
     with maximum-length linear feedback shift registers (LFSR), see the
     following web references:
       http://en.wikipedia.org/wiki/Linear_feedback_shift_register
       http://www.newwaveinstruments.com/resources/articles/m_sequence_linear_feedback_shift_register_lfsr.htm
 
     In particular, the used solutions are to place XNOR taps at the bits
      24 stages, 4 taps:  (47 sets)
       [24, 23, 21, 20]
      30 stages, 4 taps:  (104 sets)
       [30, 29, 28, 7]
 
     The 24 stage solution we use has been mirrored by transforming [m, A, B, C]
     into [m, m-C, m-B, m-A].  This goes through the sequence in the opposite
     direction.
   */
 
  const UInt_t IB1 = 1;                     //Bit 1 of shift register 000000000000000000000001
  const UInt_t IB3 = 4;                     //Bit 3 of shift register 000000000000000000000100
  const UInt_t IB4 = 8;                     //Bit 4 of shift register 000000000000000000001000
  const UInt_t IB24 = 8388608;               //Bit 24 of shift register 100000000000000000000000
  const UInt_t MASK = IB1+IB3+IB4+IB24;     //Sum of the four feedback bits is 100000000000000000001101
 
  UInt_t result; //The generated pattern
 
  if(ranseed<=0)
    {
      QwError << "ranseed must be greater than zero!" << QwLog::endl;
      result = 0;
    }
 
  if(ranseed & IB24) // if bit 24 of ranseed = 1, then output 1
    {
      ranseed = (((ranseed^MASK) << 1)|IB1);
      result = 1;
    }
  else
    {
      ranseed <<= 1;
      result = 0;
    }
  return(result);
 
}

References QwLog::endl(), and QwError.

Referenced by QwFakeHelicity::GetRandbit(), and GetRandbit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRandbit30()

UInt_t QwHelicityBase::GetRandbit30 ( UInt_t & ranseed )

protected

Definition at line 1141 of file QwHelicityBase.cc.

{
  /* For an explanation of the algorithm, see above in GetRandbit24() */
 
  UInt_t bit7    = (ranseed & 0x00000040) != 0;
  UInt_t bit28   = (ranseed & 0x08000000) != 0;
  UInt_t bit29   = (ranseed & 0x10000000) != 0;
  UInt_t bit30   = (ranseed & 0x20000000) != 0;
 
  UInt_t result = (bit30 ^ bit29 ^ bit28 ^ bit7) & 0x1;
 
  if(ranseed<=0) {
    QwError << "ranseed must be greater than zero!" << QwLog::endl;
    result = 0;
  }
  ranseed =  ( (ranseed << 1) | result ) & 0x3FFFFFFF;
 
  return(result);
}

References QwLog::endl(), and QwError.

Referenced by GetRandbit(), and QwHelicityDecoder::RunPredictor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRandomSeed()

UInt_t QwHelicityBase::GetRandomSeed ( UShort_t * first24randbits )

protected

This the random seed generator used in G0 (L.Jianglai) Here we get the 24 random bits and derive the randome seed from that. randome seed : b24 b23 b22.....b2 b1 first 24 random bit from this seed: h1 h2 h3 ....h23 h24 we have, b23 = h1, b22 = h2,... b5 = h20, h21^b24 = b4 , h3^b24^b23 = b3 ,h23^b23^b22 = b2, h24^b22^b24 = b1. Thus by using h1,...h24, we can derive the b24,..b1 of the randseed.

assign the values in the h aray and into the sead

Definition at line 1162 of file QwHelicityBase.cc.

{
  Bool_t ldebug=0;
  QwDebug << " Entering QwHelicityBase::GetRandomSeed \n";
 
  /**  This the random seed generator used in G0 (L.Jianglai)
      Here we get the 24 random bits and derive the randome seed from that.
      randome seed                      : b24 b23 b22.....b2 b1
      first 24 random bit from this seed: h1 h2 h3 ....h23 h24
      we have,
      b23 = h1, b22 = h2,... b5 = h20,
      h21^b24 = b4 , h3^b24^b23 = b3 ,h23^b23^b22 = b2, h24^b22^b24 = b1.
      Thus by using h1,...h24, we can derive the b24,..b1 of the randseed.
  */
 
  UShort_t b[25];
  UInt_t ranseed = 0;
 
  if(ldebug)
    {
     for(size_t i=0;i<25;i++)
       std::cout << i << " : " << first24randbits[i] << "\n";
    }
 
  for(size_t i=24;i>=5;i--)   b[i]= first24randbits[24-i+1]; //fill h24..h5
 
  // fill b[4] to b[1]
  b[4] = first24randbits[21]^b[24]; //h21^b24 = b4
  b[3] = first24randbits[22]^b[24]^b[23]; //h22^b24^b23 = b3
  b[2] = first24randbits[23]^b[23]^b[22];// h23^b23^b22 = b2
  b[1] = first24randbits[24]^b[21]^b[22]^b[24];// h24^b22^b24 = b1
 
  ///assign the values in the h aray and into the sead
  for(size_t i=24;i>=1;i--)  ranseed = (ranseed << 1) | (b[i]&1);
 
  ranseed = ranseed&0xFFFFFF; //put a mask
 
  QwDebug << " seed =" << ranseed <<QwLog::endl;
  QwDebug << " Exiting QwHelicityBase::GetRandomSeed \n";
 
 
  return ranseed;
 
}

References QwLog::endl(), and QwDebug.

Referenced by CollectRandBits24(), SetFirstBits(), and QwHelicityDecoder::SetFirstBits().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetRandomSeedActual()

UInt_t QwHelicityBase::GetRandomSeedActual ( )

inline

Definition at line 97 of file QwHelicityBase.h.

97{ return iseed_Actual; };

References iseed_Actual.

◆ GetRandomSeedDelayed()

UInt_t QwHelicityBase::GetRandomSeedDelayed ( )

inline

Definition at line 98 of file QwHelicityBase.h.

98{ return iseed_Delayed; };

References iseed_Delayed.

◆ IncrementErrorCounters()

void QwHelicityBase::IncrementErrorCounters ( )

overridevirtual

Increment the error counters.

TODO: Implement QwHelicityBase::IncrementErrorCounters()

Implements VQwSubsystemParity.

Definition at line 413 of file QwHelicityBase.cc.

{
  /// TODO:  Implement  QwHelicityBase::IncrementErrorCounters()
}

◆ IsContinuous()

Bool_t QwHelicityBase::IsContinuous ( )

protected

Definition at line 243 of file QwHelicityBase.cc.

{
  Bool_t results=kFALSE;
  if(IsGoodPatternNumber()&&IsGoodEventNumber()&&IsGoodPhaseNumber()){
    results=kTRUE;
  } else {
    //  Results is already false, so just set the error flag value.
    fErrorFlag = kErrorFlag_Helicity + kGlobalCut + kEventCutMode3;
  }
  return results;
}

References fErrorFlag, IsGoodEventNumber(), IsGoodPatternNumber(), IsGoodPhaseNumber(), kErrorFlag_Helicity, kEventCutMode3, and kGlobalCut.

Referenced by CollectRandBits24(), and CollectRandBits30().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsGoodEventNumber()

Bool_t QwHelicityBase::IsGoodEventNumber ( )

protected

Definition at line 275 of file QwHelicityBase.cc.

{
  Bool_t results;
  if(fEventNumber == fEventNumberOld + 1)
    results= kTRUE;
  else
    results= kFALSE;
 
  if(!results) {
    QwWarning << "QwHelicityBase::IsGoodEventNumber: \n this is not a good event number indeed:" << QwLog::endl;
    Print();
  }
  return results;
}

References QwLog::endl(), fEventNumber, fEventNumberOld, Print(), and QwWarning.

Referenced by IsContinuous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsGoodHelicity()

Bool_t QwHelicityBase::IsGoodHelicity ( )

virtual

We are not ignoring the helicity, and the helicities do not match. Check phase number to see if its a new pattern.

Reimplemented in QwFakeHelicity.

Definition at line 322 of file QwHelicityBase.cc.

{
  fGoodHelicity = kTRUE;
  if (!fIgnoreHelicity  && fHelicityReported!=fHelicityDelayed){
    /**We are not ignoring the helicity, and the helicities do not match.
       Check phase number to see if its a new pattern.*/
    fGoodHelicity=kFALSE;
    fNumHelicityErrors++;
    fErrorFlag = kErrorFlag_Helicity + kGlobalCut + kEventCutMode3;
    if(fPatternPhaseNumber == fMinPatternPhase) {
      //first event in a new pattern
      QwError << "QwHelicityBase::IsGoodHelicity : The helicity reported in event "
          << fEventNumber
          << " is not what we expect from the randomseed. Not a good event nor pattern"
          << QwLog::endl;
    } else {
      QwError << "QwHelicityBase::IsGoodHelicity - The helicity reported in event "
          << fEventNumber
          << " is not what we expect according to pattern structure. Not a good event nor pattern"
          << QwLog::endl;
    }
  }
  if(!fGoodHelicity) {
    fHelicityReported=kUndefinedHelicity;
    fHelicityActual=kUndefinedHelicity;
    fHelicityDelayed=kUndefinedHelicity;
    //Have to start over again
    ResetPredictor();
  }
  
  return fGoodHelicity;
}

References QwLog::endl(), fErrorFlag, fEventNumber, fGoodHelicity, fHelicityActual, fHelicityDelayed, fHelicityReported, fIgnoreHelicity, fMinPatternPhase, fNumHelicityErrors, fPatternPhaseNumber, kErrorFlag_Helicity, kEventCutMode3, kGlobalCut, kUndefinedHelicity, QwError, and ResetPredictor().

Referenced by PredictHelicity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsGoodPatternNumber()

Bool_t QwHelicityBase::IsGoodPatternNumber ( )

protected

Definition at line 256 of file QwHelicityBase.cc.

{
  Bool_t results;
  
  if((fPatternNumber == fPatternNumberOld) && (fPatternPhaseNumber == fPatternPhaseNumberOld+1))//same pattern new phase
       results = kTRUE; //got same pattern
  else if((fPatternNumber == fPatternNumberOld + 1) && (fPatternPhaseNumber == fMinPatternPhase))
       results=kTRUE; //new pattern
  else results=kFALSE; //wrong pattern
 
  if(!results) {
    QwWarning << "QwHelicityBase::IsGoodPatternNumber:  This is not a good pattern number. New = "<< fPatternNumber << " Old = " <<  fPatternNumberOld << QwLog::endl;
    //Print();
  }
 
  return results;
}

References QwLog::endl(), fMinPatternPhase, fPatternNumber, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, and QwWarning.

Referenced by IsContinuous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsGoodPhaseNumber()

Bool_t QwHelicityBase::IsGoodPhaseNumber ( )

protected

Definition at line 291 of file QwHelicityBase.cc.

{
  Bool_t results;
 
  if((fPatternPhaseNumber == fMaxPatternPhase)  && (fPatternNumber == fPatternNumberOld )) //maximum phase of old pattern
     results = kTRUE;
  else if((fPatternPhaseNumber == fPatternPhaseNumberOld+1) && (fPatternNumber == fPatternNumberOld))
    results = kTRUE;
  else if((fPatternPhaseNumber == fMinPatternPhase) && (fPatternNumber == fPatternNumberOld + 1))
    results= kTRUE;
  else
    results = kFALSE;
 
  if(fPatternPhaseNumber>fMaxPatternPhase)
    results=kFALSE;
 
  if(!results) {
    QwWarning << "QwHelicityBase::IsGoodPhaseNumber:  not a good phase number \t"
          <<  "Phase: " << fPatternPhaseNumber << " out of "
          <<  fMaxPatternPhase
          <<  "(was "  << fPatternPhaseNumberOld << ")"
          <<  "\tPattern #" << fPatternNumber << "(was "
          <<  fPatternNumberOld  << ")"
          <<  QwLog::endl; //Paul's modifications
    Print();
  }
 
  return results;
}

References QwLog::endl(), fMaxPatternPhase, fMinPatternPhase, fPatternNumber, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, Print(), and QwWarning.

Referenced by IsContinuous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsHelicityIgnored()

Bool_t QwHelicityBase::IsHelicityIgnored ( )

inline

Definition at line 158 of file QwHelicityBase.h.

158{return fIgnoreHelicity;};

References fIgnoreHelicity.

Referenced by QwHelicityPattern::LoadEventData().

Here is the caller graph for this function:

◆ LoadChannelMap()

Int_t QwHelicityBase::LoadChannelMap ( TString mapfile )

overridevirtual

Mandatory map file definition.

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 471 of file QwHelicityBase.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);
      //QwMessage << " fMaxPatternPhase " << fMaxPatternPhase << QwLog::endl;
    }
    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(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 << "QwHelicityBase::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();
    }
  }
  
  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;
  
  mapstr.Close(); // Close the file (ifstream)
  return 0;
}

References BuildHelicityBitPattern(), QwParameterFile::Close(), QwParameterFile::EnableGreediness(), QwLog::endl(), VQwSubsystem::fCurrentBank_ID, VQwSubsystem::fCurrentROC_ID, VQwSubsystem::fDetectorMaps, fMaxPatternPhase, QwWord::fModuleType, fPatternPhaseOffset, fRandBits, QwWord::fSubbankIndex, fWord, QwWord::fWordInSubbank, QwWord::fWordName, fWordsPerSubbank, QwWord::fWordType, QwParameterFile::GetParamFileNameContents(), VQwSubsystem::GetSubbankIndex(), QwParameterFile::GetTypedNextToken(), kEventTypeHelMinus, kEventTypeHelPlus, kUserbit, QwParameterFile::LineIsEmpty(), QwParameterFile::PopValue(), QwError, QwParameterFile::ReadNextLine(), VQwSubsystem::RegisterRocBankMarker(), QwParameterFile::SetCommentChars(), SetHelicityBitPattern(), SetHelicityDelay(), and QwParameterFile::TrimWhitespace().

Here is the call graph for this function:

◆ LoadEventCuts()

Int_t QwHelicityBase::LoadEventCuts ( TString )

overridevirtual

Optional event cut file.

Reimplemented from VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 605 of file QwHelicityBase.cc.

                                                   {
  return 0;
}

◆ LoadInputParameters()

Int_t QwHelicityBase::LoadInputParameters ( TString mapfile )

overridevirtual

Mandatory parameter file definition.

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 401 of file QwHelicityBase.cc.

{
  return 0;
}

◆ MatchActualHelicity()

Bool_t QwHelicityBase::MatchActualHelicity ( Int_t actual )

protected

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ MergeCounters()

void QwHelicityBase::MergeCounters ( VQwSubsystem * value )

protected

Definition at line 1617 of file QwHelicityBase.cc.

{
  //  Bool_t localdebug=kFALSE;
  if(Compare(value)) {
    QwHelicityBase* input= dynamic_cast<QwHelicityBase*>(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(), fEventNumber, fWord, QwHelicityBase(), 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 & QwHelicityBase::operator+= ( VQwSubsystem * value )

overridevirtual

Implements VQwSubsystemParity.

Reimplemented in QwHelicityDecoder.

Definition at line 1582 of file QwHelicityBase.cc.

{
  //  Bool_t localdebug=kFALSE;
  QwDebug << "Entering QwHelicityBase::operator+= adding " << value->GetName() << " to " << this->GetName() << " " << QwLog::endl;
 
  //this routine is most likely to be called during the computatin of assymetry
  //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-=()

virtual VQwSubsystem & QwHelicityBase::operator-= ( VQwSubsystem * value )

inlineoverridevirtual

Implements VQwSubsystemParity.

Reimplemented in QwHelicityDecoder.

Definition at line 124 of file QwHelicityBase.h.

124{return *this;};

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

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

Reimplemented in QwHelicityDecoder.

Definition at line 1540 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;
}

References fActualPatternPolarity, fDelayedPatternPolarity, fErrorFlag, fEventNumber, fEventNumberFirst, fGoodHelicity, fGoodPattern, fHelicityActual, fHelicityBitMinus, fHelicityBitPlus, fHelicityDelayed, fHelicityReported, fIgnoreHelicity, fNumHelicityErrors, fNumMissedEventBlocks, fNumMissedGates, fNumMultSyncErrors, fPatternNumber, fPatternNumberFirst, fPatternPhaseNumber, fPatternSeed, fPreviousPatternPolarity, fWord, VQwSubsystem::operator=(), QwHelicityBase(), and VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

◆ parity()

unsigned int QwHelicityBase::parity ( unsigned int v )

inlineprotected

Definition at line 298 of file QwHelicityBase.h.

                                      {
    // http://graphics.stanford.edu/~seander/bithacks.html#ParityParallel
    v ^= v >> 16;
    v ^= v >> 8;
    v ^= v >> 4;
    v &= 0xf;
    return (0x6996 >> v) & 1;
  }

◆ PredictHelicity()

void QwHelicityBase::PredictHelicity ( )

Routine to predict the true helicity from the delayed helicity. Helicities are usually delayed by 8 events or 2 quartets. This delay can now be set as a cmd line option.

After accumulating 24/30 helicity bits, iseed is up-to-date. If nothing goes wrong, n-ranbits will stay as 24/30 Reset it to zero if something goes wrong.

If not good helicity, start over again by resetting the predictor.

Definition at line 1455 of file QwHelicityBase.cc.

{
   Bool_t ldebug=kFALSE;
 
   if(ldebug)  std::cout << "Entering QwHelicityBase::PredictHelicity \n";
 
   /**Routine to predict the true helicity from the delayed helicity.
      Helicities are usually delayed by 8 events or 2 quartets. This delay
      can now be set as a cmd line option.
   */
 
   if(CollectRandBits()) {
     /**After accumulating 24/30 helicity bits, iseed is up-to-date.
    If nothing goes wrong, n-ranbits will stay as 24/30
    Reset it to zero if something goes wrong.
     */
 
     if(ldebug)  std::cout << "QwHelicityBase::PredictHelicity=>Predicting the  helicity \n";
     RunPredictor();
 
     /** If not good helicity, start over again by resetting the predictor. */
     if(!IsGoodHelicity())
       ResetPredictor();
   }
 
   if(ldebug)  std::cout << "n_ranbit exiting the function = " << n_ranbits << "\n";
 
   return;
}

References CollectRandBits(), IsGoodHelicity(), n_ranbits, ResetPredictor(), and RunPredictor().

Referenced by QwFakeHelicity::ProcessEvent(), and QwHelicity::ProcessEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Print()

void QwHelicityBase::Print ( ) const

Definition at line 449 of file QwHelicityBase.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(), fEventNumber, fEventNumberOld, fHelicityActual, fHelicityDelayed, fHelicityReported, fMaxPatternPhase, fPatternNumber, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, and QwOut.

Referenced by IsGoodEventNumber(), IsGoodPhaseNumber(), and QwHelicity::ProcessEventUserbitMode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintErrorCounters()

void QwHelicityBase::PrintErrorCounters ( ) const

overridevirtual

Implements VQwSubsystemParity.

Definition at line 418 of file QwHelicityBase.cc.

                                             {
  // report number of events failed due to HW and event cut faliure
  QwMessage << "\n*********QwHelicityBase Error Summary****************"
        << QwLog::endl;
  QwMessage << "First helicity gate counter:  "
        << fEventNumberFirst
        << "; last helicity gate counter:  "
        << fEventNumber
        << QwLog::endl;
  QwMessage << "First pattern counter:  "
        << fPatternNumberFirst
        << "; last pattern counter:  "
        << fPatternNumber
        << QwLog::endl;
  QwMessage << "Missed " << fNumMissedGates << " helicity gates in "
        << fNumMissedEventBlocks << " blocks of missed events."
        << QwLog::endl;
  QwMessage << "Number of multiplet-sync-bit errors:  "
        << fNumMultSyncErrors
        << QwLog::endl;
  QwMessage << "Number of helicity prediction errors: "
        << fNumHelicityErrors
        << QwLog::endl;
  QwMessage <<"---------------------------------------------------\n"
        << QwLog::endl;
}

References QwLog::endl(), fEventNumber, fEventNumberFirst, fNumHelicityErrors, fNumMissedEventBlocks, fNumMissedGates, fNumMultSyncErrors, fPatternNumber, fPatternNumberFirst, and QwMessage.

Here is the call graph for this function:

◆ ProcessConfigurationBuffer()

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

overridevirtual

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 394 of file QwHelicityBase.cc.

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

◆ ProcessEvBuffer() [1/2]

Int_t QwHelicityBase::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.

Implements VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 90 of file QwHelicityBase.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 QwHelicityBase::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.

Reimplemented in QwHelicityDecoder.

Definition at line 609 of file QwHelicityBase.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 << "QwHelicityBase::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 << "QwHelicityBase::ProcessEvBuffer:  There is not enough word in the buffer to read data for "
          << fWord[i].fWordName << QwLog::endl;
    QwWarning << "QwHelicityBase::ProcessEvBuffer:  Words in this buffer:" << num_words
          << " trying to read word number =" << fWord[i].fWordInSubbank << QwLog::endl;
      }
    }
    if(lkDEBUG) {
      QwDebug << "QwHelicityBase::ProcessEvBuffer:  Done with Processing this event" << QwLog::endl;
      for(size_t i=0;i<fWord.size();i++) {
    std::cout << "QwHelicityBase::ProcessEvBuffer:  word number = " << i << " ";
    fWord[i].Print();
      }
    }
  }
  lkDEBUG=kFALSE;
  return 0;
}

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

Here is the call graph for this function:

◆ ProcessOptions()

void QwHelicityBase::ProcessOptions ( QwOptions & )

overridevirtual

Process the command line options.

Reimplemented from VQwSubsystem.

Reimplemented in QwHelicityDecoder.

Definition at line 177 of file QwHelicityBase.cc.

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

Here is the call graph for this function:

◆ Ratio()

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

overridevirtual

Implements VQwSubsystemParity.

Reimplemented in QwHelicityDecoder.

Definition at line 1632 of file QwHelicityBase.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:

◆ ResetPredictor()

void QwHelicityBase::ResetPredictor ( )

protected

Start a new helicity prediction sequence.

Definition at line 1527 of file QwHelicityBase.cc.

{
  /**Start a new helicity prediction sequence.*/
 
  QwWarning << "QwHelicityBase::ResetPredictor:  Resetting helicity prediction!" << QwLog::endl;
  n_ranbits = 0;
  fGoodHelicity = kFALSE;
  fGoodPattern = kFALSE;
  return;
}

References QwLog::endl(), fGoodHelicity, fGoodPattern, n_ranbits, and QwWarning.

Referenced by CollectRandBits24(), CollectRandBits30(), IsGoodHelicity(), PredictHelicity(), QwHelicity::ProcessEventUserbitMode(), and RunPredictor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RunPredictor()

void QwHelicityBase::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.

Predict the helicity according to pattern Defined patterns: Pair: +- or -+ Quartet: +–+ or -++- Octet: +–+-++- or -++-+–+ Symmetric octet: +-+–+-+ or -+-++-+- Octo-quad: +–++–++–++–+-++–++–++–++-

Definition at line 1208 of file QwHelicityBase.cc.

{
  Int_t ldebug = kFALSE;
 
  if(ldebug)  std::cout  << "Entering QwHelicityBase::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.
    */
 
 
    for (int i = 0; i < fPatternNumber - fPatternNumberOld; i++) //got a new pattern
      {
    fPreviousPatternPolarity = fActualPatternPolarity;
    fActualPatternPolarity   = GetRandbit(iseed_Actual);
    fDelayedPatternPolarity  = GetRandbit(iseed_Delayed);
    QwDebug << "Predicting : seed actual, delayed: " <<  iseed_Actual
                << ":" << iseed_Delayed <<QwLog::endl;
      }
 
  /**Predict the helicity according to pattern
     Defined patterns:
     Pair:    +-       or -+
     Quartet: +--+     or -++-
     Octet:   +--+-++- or -++-+--+
     Symmetric octet:  +-+--+-+ or -+-++-+-
     Octo-quad: +--++--++--++--+-++--++--++--++-
  */
 
  Int_t localphase = fPatternPhaseNumber-fMinPatternPhase;//Paul's modifications
 
  UInt_t localbit;
  Int_t indexnum,shiftnum;
  indexnum = TMath::FloorNint(localphase/32.);
  shiftnum = localphase - indexnum*32;
  //std::cout << localphase << " " << indexnum << " " << shiftnum << " "<< fHelicityBitPattern.size() << std::endl;
  localbit = ((fHelicityBitPattern.at(indexnum))>>shiftnum)&0x1;
  //std::cout<< localphase << " " << indexnum << " " << shiftnum <<std::hex << fHelicityBitPattern.at(indexnum) << std::dec << " " << localbit << std::endl;
  // Use the stored helicity bit pattern to calculate the helicity of this window
  if (localbit == (fHelicityBitPattern[0] & 0x1)) {
    fHelicityActual  = fActualPatternPolarity;
    fHelicityDelayed = fDelayedPatternPolarity;
  } else {
    fHelicityActual  = fActualPatternPolarity ^ 0x1;
    fHelicityDelayed = fDelayedPatternPolarity ^ 0x1;
  }
  // Past highest pattern phase
  if (localphase > fMaxPatternPhase)
    ResetPredictor();
 
  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 QwHelicityBase::RunPredictor " << QwLog::endl;
 
  }
 
  return;
}

References QwLog::endl(), fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fHelicityActual, fHelicityBitPattern, fHelicityDelayed, fHelicityReported, fMaxPatternPhase, fMinPatternPhase, fPatternNumber, fPatternNumberOld, fPatternPhaseNumber, fPreviousPatternPolarity, GetRandbit(), iseed_Actual, iseed_Delayed, QwDebug, QwError, and ResetPredictor().

Referenced by main(), and PredictHelicity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Scale()

void QwHelicityBase::Scale ( Double_t factor )

inlineoverridevirtual

Implements VQwSubsystemParity.

Definition at line 125 of file QwHelicityBase.h.

125{return;};

◆ SetEventPatternPhase()

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

Definition at line 679 of file QwHelicityBase.cc.

{
  fEventNumber = event;
  fPatternNumber = pattern;
  fPatternPhaseNumber = phase;
}

References fEventNumber, fPatternNumber, and fPatternPhaseNumber.

Referenced by main().

Here is the caller graph for this function:

◆ SetFirstBits()

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

Definition at line 686 of file QwHelicityBase.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 fHelicityDelay, GetRandbit(), GetRandomSeed(), iseed_Actual, and iseed_Delayed.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHelicityBitPattern()

void QwHelicityBase::SetHelicityBitPattern ( TString hex )

Definition at line 1510 of file QwHelicityBase.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(), fHelicityBitPattern, kDefaultHelicityBitPattern, and QwMessage.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHelicityDelay()

void QwHelicityBase::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 1487 of file QwHelicityBase.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 << "QwHelicityBase : SetHelicityDelay ::  helicity delay is set to 0."
        << " Disabling helicity predictor and using reported helicity information." 
        << QwLog::endl;
      fUsePredictor = kFALSE;
    }
    else
      fUsePredictor = kTRUE; 
  }
  else
    QwError << "QwHelicityBase::SetHelicityDelay We cannot handle negative delay in the prediction of delayed helicity. Exiting.." << QwLog::endl;
 
  return;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHistoTreeSave()

void QwHelicityBase::SetHistoTreeSave ( const TString & prefix )

protected

Definition at line 698 of file QwHelicityBase.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 fHistoType, kHelNoSave, kHelSaveMPS, and kHelSavePattern.

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

Here is the caller graph for this function:

◆ UpdateErrorFlag()

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

Implements VQwSubsystemParity.

Reimplemented in QwHelicityDecoder.

Definition at line 85 of file QwHelicityBase.h.

85 {

86 };

References VQwSubsystem::VQwSubsystem().

Here is the call graph for this function:

Field Documentation

◆ fActualPatternPolarity

Int_t QwHelicityBase::fActualPatternPolarity

protected

◆ fDelayedPatternPolarity

Int_t QwHelicityBase::fDelayedPatternPolarity

protected

Reported polarity of the current pattern.

Definition at line 204 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::CollectRandBits(), CollectRandBits24(), CollectRandBits30(), ConstructBranch(), ConstructBranch(), QwHelicityDecoder::ConstructBranch(), QwHelicityDecoder::ConstructBranch(), FillTreeVector(), QwHelicityDecoder::FillTreeVector(), operator=(), QwHelicityDecoder::operator=(), QwHelicity::ProcessEvent(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), RunPredictor(), and QwHelicityDecoder::RunPredictor().

◆ fErrorFlag

UInt_t QwHelicityBase::fErrorFlag

protected

Definition at line 288 of file QwHelicityBase.h.

Referenced by CheckPatternNum(), QwHelicityDecoder::CheckPatternNum(), GetEventcutErrorFlag(), IsContinuous(), IsGoodHelicity(), operator=(), QwHelicityDecoder::operator=(), QwHelicity::ProcessEvent(), QwHelicityDecoder::ProcessEvent(), and QwHelicity::ProcessEventInputRegisterMode().

◆ fEventNumber

Int_t QwHelicityBase::fEventNumber

protected

Definition at line 199 of file QwHelicityBase.h.

◆ fEventNumberFirst

Int_t QwHelicityBase::fEventNumberFirst

protected

Definition at line 272 of file QwHelicityBase.h.

Referenced by QwHelicity::ClearEventData(), ClearEventData(), QwHelicityDecoder::ClearEventData(), operator=(), QwHelicityDecoder::operator=(), PrintErrorCounters(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ fEventNumberOld

Int_t QwHelicityBase::fEventNumberOld

protected

Definition at line 199 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::ClearEventData(), QwHelicity::ClearEventData(), ClearEventData(), QwHelicityDecoder::ClearEventData(), FillHistograms(), QwHelicityDecoder::FillHistograms(), IsGoodEventNumber(), Print(), QwHelicityDecoder::Print(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::ProcessEventUserbitMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ fEventType

UInt_t QwHelicityBase::fEventType

protected

Definition at line 269 of file QwHelicityBase.h.

Referenced by QwHelicity::ProcessEvBuffer(), ProcessEvBuffer(), QwHelicity::ProcessEventInputMollerMode(), and QwHelicity::QwHelicity().

◆ fGoodHelicity

Bool_t QwHelicityBase::fGoodHelicity

protected

Definition at line 214 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::CollectRandBits(), CollectRandBits24(), CollectRandBits30(), QwFakeHelicity::IsGoodHelicity(), IsGoodHelicity(), operator=(), QwHelicityDecoder::operator=(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), and ResetPredictor().

◆ fGoodPattern

Bool_t QwHelicityBase::fGoodPattern

protected

Definition at line 215 of file QwHelicityBase.h.

Referenced by operator=(), QwHelicityDecoder::operator=(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), and ResetPredictor().

◆ fHelicityActual

Int_t QwHelicityBase::fHelicityActual

protected

◆ fHelicityBitMinus

Bool_t QwHelicityBase::fHelicityBitMinus

protected

Definition at line 213 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::ClearEventData(), QwHelicity::ClearEventData(), ClearEventData(), QwHelicityDecoder::ClearEventData(), operator=(), QwHelicityDecoder::operator=(), QwFakeHelicity::ProcessEvent(), QwHelicity::ProcessEvent(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::ProcessEventUserbitMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ fHelicityBitPattern

std::vector<UInt_t> QwHelicityBase::fHelicityBitPattern

protected

Definition at line 175 of file QwHelicityBase.h.

Referenced by BuildHelicityBitPattern(), QwHelicity::LoadChannelMap(), QwHelicity::ProcessOptions(), ProcessOptions(), QwHelicityDecoder::ProcessOptions(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), RunPredictor(), SetHelicityBitPattern(), and QwHelicityDecoder::SetHelicityBitPattern().

◆ fHelicityBitPlus

Bool_t QwHelicityBase::fHelicityBitPlus

protected

Definition at line 212 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::ClearEventData(), QwHelicity::ClearEventData(), ClearEventData(), QwHelicityDecoder::ClearEventData(), operator=(), QwHelicityDecoder::operator=(), QwFakeHelicity::ProcessEvent(), QwHelicity::ProcessEvent(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::ProcessEventUserbitMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ fHelicityDecodingMode

Int_t QwHelicityBase::fHelicityDecodingMode

protected

Definition at line 180 of file QwHelicityBase.h.

Referenced by QwHelicity::EncodeEventData(), QwHelicity::LoadChannelMap(), QwHelicity::ProcessEvent(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ fHelicityDelay

Int_t QwHelicityBase::fHelicityDelay

protected

Definition at line 238 of file QwHelicityBase.h.

Referenced by CollectRandBits24(), CollectRandBits30(), QwHelicity::ProcessOptions(), ProcessOptions(), QwHelicityDecoder::ProcessOptions(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), QwHelicityDecoder::RunPredictor(), SetFirstBits(), QwHelicityDecoder::SetFirstBits(), SetHelicityDelay(), and QwHelicityDecoder::SetHelicityDelay().

◆ fHelicityDelayed

Int_t QwHelicityBase::fHelicityDelayed

protected

◆ fHelicityInfoOK

Bool_t QwHelicityBase::fHelicityInfoOK

protected

Definition at line 264 of file QwHelicityBase.h.

Referenced by QwHelicity::QwHelicity().

◆ fHelicityReported

Int_t QwHelicityBase::fHelicityReported

protected

◆ fHistoType

Int_t QwHelicityBase::fHistoType

protected

Definition at line 217 of file QwHelicityBase.h.

Referenced by ConstructBranch(), ConstructBranch(), QwHelicityDecoder::ConstructBranch(), QwHelicityDecoder::ConstructBranch(), ConstructBranchAndVector(), QwHelicityDecoder::ConstructBranchAndVector(), QwHelicity::ConstructHistograms(), ConstructHistograms(), QwHelicityDecoder::ConstructHistograms(), FillHistograms(), QwHelicityDecoder::FillHistograms(), FillTreeVector(), QwHelicityDecoder::FillTreeVector(), SetHistoTreeSave(), and QwHelicityDecoder::SetHistoTreeSave().

◆ fIgnoreHelicity

Bool_t QwHelicityBase::fIgnoreHelicity

protected

Definition at line 267 of file QwHelicityBase.h.

Referenced by IsGoodHelicity(), IsHelicityIgnored(), operator=(), QwHelicityDecoder::operator=(), QwHelicity::ProcessEvent(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ fMaxPatternPhase

Int_t QwHelicityBase::fMaxPatternPhase

protected

Definition at line 241 of file QwHelicityBase.h.

Referenced by GetMaxPatternPhase(), IsGoodPhaseNumber(), QwHelicity::LoadChannelMap(), LoadChannelMap(), QwHelicityDecoder::LoadChannelMap(), Print(), QwHelicityDecoder::Print(), QwFakeHelicity::ProcessEvent(), QwHelicity::ProcessEvent(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventUserbitMode(), QwHelicity::ProcessOptions(), ProcessOptions(), QwHelicityDecoder::ProcessOptions(), QwHelicity::QwHelicity(), and RunPredictor().

◆ fMinPatternPhase

Int_t QwHelicityBase::fMinPatternPhase

protected

Definition at line 242 of file QwHelicityBase.h.

Referenced by CollectRandBits24(), CollectRandBits30(), QwHelicity::EncodeEventData(), GetMinPatternPhase(), IsGoodHelicity(), IsGoodPatternNumber(), IsGoodPhaseNumber(), QwHelicity::ProcessEvent(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::ProcessEventUserbitMode(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), RunPredictor(), and QwHelicityDecoder::RunPredictor().

◆ fNumHelicityErrors

Int_t QwHelicityBase::fNumHelicityErrors

protected

Definition at line 286 of file QwHelicityBase.h.

Referenced by AccumulateRunningSum(), QwHelicityDecoder::AccumulateRunningSum(), ClearErrorCounters(), IsGoodHelicity(), operator=(), QwHelicityDecoder::operator=(), PrintErrorCounters(), and QwHelicity::QwHelicity().

◆ fNumMissedEventBlocks

Int_t QwHelicityBase::fNumMissedEventBlocks

protected

Definition at line 284 of file QwHelicityBase.h.

Referenced by AccumulateRunningSum(), QwHelicityDecoder::AccumulateRunningSum(), ClearErrorCounters(), operator=(), QwHelicityDecoder::operator=(), PrintErrorCounters(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), and QwHelicity::QwHelicity().

◆ fNumMissedGates

Int_t QwHelicityBase::fNumMissedGates

protected

Definition at line 283 of file QwHelicityBase.h.

Referenced by AccumulateRunningSum(), QwHelicityDecoder::AccumulateRunningSum(), ClearErrorCounters(), operator=(), QwHelicityDecoder::operator=(), PrintErrorCounters(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), and QwHelicity::QwHelicity().

◆ fNumMultSyncErrors

Int_t QwHelicityBase::fNumMultSyncErrors

protected

Definition at line 285 of file QwHelicityBase.h.

Referenced by AccumulateRunningSum(), QwHelicityDecoder::AccumulateRunningSum(), ClearErrorCounters(), operator=(), QwHelicityDecoder::operator=(), PrintErrorCounters(), QwHelicity::ProcessEventInputRegisterMode(), and QwHelicity::QwHelicity().

◆ fPatternNumber

Int_t QwHelicityBase::fPatternNumber

protected

Definition at line 201 of file QwHelicityBase.h.

Referenced by AccumulateRunningSum(), QwHelicityDecoder::AccumulateRunningSum(), CheckPatternNum(), QwHelicityDecoder::CheckPatternNum(), QwFakeHelicity::ClearEventData(), QwHelicity::ClearEventData(), ClearEventData(), QwHelicityDecoder::ClearEventData(), CollectRandBits24(), CollectRandBits30(), ConstructBranch(), ConstructBranch(), QwHelicityDecoder::ConstructBranch(), QwHelicityDecoder::ConstructBranch(), QwHelicity::EncodeEventData(), QwHelicityDecoder::FillHDVariables(), FillHistograms(), QwHelicityDecoder::FillHistograms(), FillTreeVector(), QwHelicityDecoder::FillTreeVector(), GetPatternNumber(), IsGoodPatternNumber(), IsGoodPhaseNumber(), operator=(), QwHelicityDecoder::operator=(), Print(), QwHelicityDecoder::Print(), PrintErrorCounters(), QwFakeHelicity::ProcessEvent(), QwHelicity::ProcessEvent(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::ProcessEventUserbitMode(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), RunPredictor(), QwHelicityDecoder::RunPredictor(), and SetEventPatternPhase().

◆ fPatternNumberFirst

Int_t QwHelicityBase::fPatternNumberFirst

protected

Definition at line 273 of file QwHelicityBase.h.

Referenced by QwHelicity::ClearEventData(), ClearEventData(), QwHelicityDecoder::ClearEventData(), operator=(), QwHelicityDecoder::operator=(), PrintErrorCounters(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ fPatternNumberOld

Int_t QwHelicityBase::fPatternNumberOld

protected

◆ fPatternPhaseNumber

Int_t QwHelicityBase::fPatternPhaseNumber

protected

Definition at line 200 of file QwHelicityBase.h.

◆ fPatternPhaseNumberOld

Int_t QwHelicityBase::fPatternPhaseNumberOld

protected

Definition at line 200 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::ClearEventData(), QwHelicity::ClearEventData(), ClearEventData(), QwHelicityDecoder::ClearEventData(), IsGoodPatternNumber(), IsGoodPhaseNumber(), Print(), QwHelicityDecoder::Print(), QwFakeHelicity::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::ProcessEventUserbitMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ fPatternPhaseOffset

Int_t QwHelicityBase::fPatternPhaseOffset

protected

Definition at line 265 of file QwHelicityBase.h.

Referenced by QwHelicity::EncodeEventData(), QwHelicity::LoadChannelMap(), LoadChannelMap(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::ProcessOptions(), ProcessOptions(), QwHelicityDecoder::ProcessOptions(), and QwHelicity::QwHelicity().

◆ fPatternSeed

Int_t QwHelicityBase::fPatternSeed

protected

Definition at line 202 of file QwHelicityBase.h.

Referenced by ConstructBranch(), ConstructBranch(), QwHelicityDecoder::ConstructBranch(), QwHelicityDecoder::ConstructBranch(), FillTreeVector(), QwHelicityDecoder::FillTreeVector(), operator=(), QwHelicityDecoder::operator=(), and QwHelicityDecoder::ProcessEvent().

◆ fPreviousPatternPolarity

Int_t QwHelicityBase::fPreviousPatternPolarity

protected

True polarity of the previous pattern.

Definition at line 205 of file QwHelicityBase.h.

Referenced by CollectRandBits24(), CollectRandBits30(), ConstructBranch(), ConstructBranch(), QwHelicityDecoder::ConstructBranch(), QwHelicityDecoder::ConstructBranch(), FillTreeVector(), QwHelicityDecoder::FillTreeVector(), operator=(), QwHelicityDecoder::operator=(), QwHelicity::ProcessEvent(), RunPredictor(), and QwHelicityDecoder::RunPredictor().

◆ fRandBits

Int_t QwHelicityBase::fRandBits

protected

Definition at line 262 of file QwHelicityBase.h.

Referenced by CollectRandBits(), GetRandbit(), QwHelicity::LoadChannelMap(), LoadChannelMap(), QwHelicity::ProcessOptions(), ProcessOptions(), QwHelicityDecoder::ProcessOptions(), and QwHelicity::QwHelicity().

◆ fSuppressMPSErrorMsgs

Bool_t QwHelicityBase::fSuppressMPSErrorMsgs

protected

Flag to disable the printing os missed MPS error messags during online running

Definition at line 292 of file QwHelicityBase.h.

Referenced by QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::ProcessOptions(), ProcessOptions(), QwHelicityDecoder::ProcessOptions(), QwHelicityBase(), and QwHelicityBase().

◆ fTreeArrayIndex

size_t QwHelicityBase::fTreeArrayIndex

protected

Definition at line 232 of file QwHelicityBase.h.

Referenced by ConstructBranchAndVector(), QwHelicityDecoder::ConstructBranchAndVector(), FillTreeVector(), and QwHelicityDecoder::FillTreeVector().

◆ fTreeArrayNumEntries

size_t QwHelicityBase::fTreeArrayNumEntries

protected

Definition at line 233 of file QwHelicityBase.h.

◆ fUsePredictor

Bool_t QwHelicityBase::fUsePredictor

protected

Definition at line 263 of file QwHelicityBase.h.

Referenced by QwHelicity::ProcessEvent(), QwHelicityDecoder::ProcessEvent(), QwHelicity::ProcessOptions(), ProcessOptions(), QwHelicityDecoder::ProcessOptions(), QwHelicity::QwHelicity(), QwHelicityBase(), QwHelicityBase(), SetHelicityDelay(), and QwHelicityDecoder::SetHelicityDelay().

◆ fWord

std::vector<QwWord> QwHelicityBase::fWord

protected

Definition at line 177 of file QwHelicityBase.h.

◆ fWordsPerSubbank

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

protected

Definition at line 178 of file QwHelicityBase.h.

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

◆ iseed_Actual

UInt_t QwHelicityBase::iseed_Actual

protected

Definition at line 235 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::CollectRandBits(), CollectRandBits24(), CollectRandBits30(), QwHelicity::GetRandomSeedActual(), GetRandomSeedActual(), QwHelicityDecoder::GetRandomSeedActual(), QwHelicity::QwHelicity(), RunPredictor(), QwHelicityDecoder::RunPredictor(), SetFirstBits(), and QwHelicityDecoder::SetFirstBits().

◆ iseed_Delayed

UInt_t QwHelicityBase::iseed_Delayed

protected

Definition at line 236 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::CollectRandBits(), CollectRandBits24(), CollectRandBits30(), QwHelicity::GetRandomSeedDelayed(), GetRandomSeedDelayed(), QwHelicityDecoder::GetRandomSeedDelayed(), QwHelicity::QwHelicity(), RunPredictor(), QwHelicityDecoder::RunPredictor(), SetFirstBits(), and QwHelicityDecoder::SetFirstBits().

◆ kDEBUG

const Bool_t QwHelicityBase::kDEBUG =kFALSE

staticprotected

Definition at line 223 of file QwHelicityBase.h.

◆ kDefaultHelicityBitPattern

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

staticprotected

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 37 of file QwHelicityBase.h.

Referenced by BuildHelicityBitPattern(), QwHelicity::ProcessOptions(), ProcessOptions(), QwHelicityBase(), and SetHelicityBitPattern().

◆ kEventTypeHelMinus

UInt_t QwHelicityBase::kEventTypeHelMinus

protected

Definition at line 197 of file QwHelicityBase.h.

Referenced by QwHelicity::LoadChannelMap(), LoadChannelMap(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ kEventTypeHelPlus

UInt_t QwHelicityBase::kEventTypeHelPlus

protected

Definition at line 197 of file QwHelicityBase.h.

Referenced by QwHelicity::LoadChannelMap(), LoadChannelMap(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ kInputRegister

Int_t QwHelicityBase::kInputRegister

protected

Definition at line 195 of file QwHelicityBase.h.

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

◆ kMpsCounter

Int_t QwHelicityBase::kMpsCounter

protected

Definition at line 195 of file QwHelicityBase.h.

Referenced by QwHelicity::LoadChannelMap(), QwFakeHelicity::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicityBase(), and QwHelicityBase().

◆ kPatternCounter

Int_t QwHelicityBase::kPatternCounter

protected

Definition at line 195 of file QwHelicityBase.h.

Referenced by QwHelicity::LoadChannelMap(), QwFakeHelicity::ProcessEvent(), QwHelicity::ProcessEventInputMollerMode(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicityBase(), and QwHelicityBase().

◆ kPatternPhase

Int_t QwHelicityBase::kPatternPhase

protected

Definition at line 195 of file QwHelicityBase.h.

Referenced by QwHelicity::LoadChannelMap(), QwFakeHelicity::ProcessEvent(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicityBase(), and QwHelicityBase().

◆ kScalerCounter

Int_t QwHelicityBase::kScalerCounter

protected

Definition at line 191 of file QwHelicityBase.h.

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

◆ kUndefinedHelicity

const Int_t QwHelicityBase::kUndefinedHelicity = -9999

staticprotected

Definition at line 228 of file QwHelicityBase.h.

Referenced by QwFakeHelicity::ClearEventData(), QwHelicity::ClearEventData(), ClearEventData(), IsGoodHelicity(), QwHelicity::ProcessEventInputRegisterMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ kUserbit

Int_t QwHelicityBase::kUserbit

protected

Definition at line 187 of file QwHelicityBase.h.

Referenced by QwHelicity::LoadChannelMap(), LoadChannelMap(), QwHelicity::ProcessEventUserbitMode(), QwHelicity::QwHelicity(), QwHelicityBase(), and QwHelicityBase().

◆ n_ranbits

UInt_t QwHelicityBase::n_ranbits

protected

Definition at line 234 of file QwHelicityBase.h.

Referenced by CollectRandBits24(), CollectRandBits30(), PredictHelicity(), QwHelicityDecoder::PredictHelicity(), QwHelicity::QwHelicity(), QwHelicityBase(), and ResetPredictor().

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

Static Protected Attributes

Private Member Functions

Detailed Description

Member Enumeration Documentation

◆ HelicityRootSavingType

Constructor & Destructor Documentation

◆ QwHelicityBase() [1/3]

◆ QwHelicityBase() [2/3]

◆ QwHelicityBase() [3/3]

◆ ~QwHelicityBase()

Member Function Documentation

◆ AccumulateRunningSum()

◆ ApplySingleEventCuts()

◆ BuildHelicityBitPattern()

◆ CalculateRunningAverage()

◆ CheckForBurpFail()

◆ CheckPatternNum()

◆ ClearErrorCounters()

◆ ClearEventData()

◆ CollectRandBits()

◆ CollectRandBits24()

◆ CollectRandBits30()

◆ 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()

◆ FillHistograms()

◆ FillTreeVector()

◆ GetEventcutErrorFlag()

◆ GetEventNumber()

◆ GetHelicityActual()

◆ GetHelicityDelayed()

◆ GetHelicityReported()

◆ GetMaxPatternPhase()

◆ GetMinPatternPhase()

◆ GetPatternNumber()

◆ GetPhaseNumber()

◆ GetRandbit()

◆ GetRandbit24()

◆ GetRandbit30()

◆ GetRandomSeed()

◆ GetRandomSeedActual()

◆ GetRandomSeedDelayed()

◆ IncrementErrorCounters()

◆ IsContinuous()

◆ IsGoodEventNumber()

◆ IsGoodHelicity()

◆ IsGoodPatternNumber()

◆ IsGoodPhaseNumber()

◆ IsHelicityIgnored()

◆ LoadChannelMap()

◆ LoadEventCuts()

◆ LoadInputParameters()

◆ MatchActualHelicity()

◆ MergeCounters()

◆ operator+=()

◆ operator-=()

◆ operator=()

◆ parity()

◆ PredictHelicity()

◆ Print()

◆ PrintErrorCounters()

◆ ProcessConfigurationBuffer()

◆ ProcessEvBuffer() [1/2]

◆ ProcessEvBuffer() [2/2]

◆ ProcessOptions()

◆ Ratio()

◆ ResetPredictor()