QwHelicity Class Reference

#include <QwHelicity.h>

Inheritance diagram for QwHelicity:

Collaboration diagram for QwHelicity:

Public Member Functions
	QwHelicity (const TString &name)
	Constructor with name. More...
	QwHelicity (const QwHelicity &source)
	Copy constructor. More...
virtual	~QwHelicity ()
	Virtual destructor. More...
void	ProcessOptions (QwOptions &options)
	Process the command line options. More...
Int_t	LoadChannelMap (TString mapfile)
	Mandatory map file definition. More...
Int_t	LoadInputParameters (TString pedestalfile)
	Mandatory parameter file definition. More...
Int_t	LoadEventCuts (TString filename)
	Load the event cuts file. More...
Bool_t	ApplySingleEventCuts ()
	Apply the single event cuts. More...
void	IncrementErrorCounters ()
	Increment the error counters. More...
void	PrintErrorCounters () const
	Report the number of events failed due to HW and event cut failures. More...
UInt_t	GetEventcutErrorFlag ()
	Return the error flag to the top level routines related to stability checks and ErrorFlag updates. More...
void	UpdateErrorFlag (const VQwSubsystem *ev_error)
	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 More...
Int_t	ProcessConfigurationBuffer (const UInt_t roc_id, const UInt_t bank_id, UInt_t *buffer, UInt_t num_words)
Int_t	ProcessEvBuffer (const UInt_t roc_id, const UInt_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. More...
Int_t	ProcessEvBuffer (UInt_t ev_type, const UInt_t roc_id, const UInt_t bank_id, UInt_t *buffer, UInt_t num_words)
void	ProcessEventUserbitMode ()
void	ProcessEventInputRegisterMode ()
void	ProcessEventInputMollerMode ()
void	EncodeEventData (std::vector< UInt_t > &buffer)
virtual void	ClearEventData ()
virtual void	ProcessEvent ()
UInt_t	GetRandomSeedActual ()
UInt_t	GetRandomSeedDelayed ()
void	PredictHelicity ()
void	RunPredictor ()
void	SetHelicityDelay (Int_t delay)
void	SetHelicityBitPattern (UInt_t bits)
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)
	Assignment Note: Must be called at the beginning of all subsystems routine call to operator=(VQwSubsystem *value) by VQwSubsystem::operator=(value) More...
VQwSubsystem &	operator+= (VQwSubsystem *value)
void	Sum (VQwSubsystem *value1, VQwSubsystem *value2)
VQwSubsystem &	operator-= (VQwSubsystem *value)
void	Scale (Double_t factor)
void	Difference (VQwSubsystem *value1, VQwSubsystem *value2)
void	Ratio (VQwSubsystem *numer, VQwSubsystem *denom)
void	AccumulateRunningSum (VQwSubsystem *value)
	Update the running sums for devices. More...
void	DeaccumulateRunningSum (VQwSubsystem *value)
	remove one entry from the running sums for devices More...
void	CalculateRunningAverage ()
	Calculate the average for all good events. More...
void	ConstructHistograms (TDirectory *folder, TString &prefix)
	Construct the histograms for this subsystem in a folder with a prefix. More...
void	FillHistograms ()
	Fill the histograms for this subsystem. More...
void	ConstructBranchAndVector (TTree *tree, TString &prefix, std::vector< Double_t > &values)
	Construct the branch and tree vector. More...
void	ConstructBranch (TTree *tree, TString &prefix)
	Construct the branch and tree vector. More...
void	ConstructBranch (TTree *tree, TString &prefix, QwParameterFile &trim_file)
	Construct the branch and tree vector based on the trim file. More...
void	FillTreeVector (std::vector< Double_t > &values) const
	Fill the tree vector. More...
void	FillDB (QwParityDB *db, TString type)
	Fill the database. More...
void	FillErrDB (QwParityDB *db, TString datatype)
void	Print () const
Bool_t	IsHelicityIgnored ()
virtual Bool_t	IsGoodHelicity ()
Public Member Functions inherited from VQwSubsystemParity
	VQwSubsystemParity (const TString &name)
	Constructor with name. More...
	VQwSubsystemParity (const VQwSubsystemParity &source)
	Copy constructor. More...
virtual	~VQwSubsystemParity ()
	Default destructor. More...
virtual void	FillDB_MPS (QwParityDB *db, TString type)
	Fill the database with MPS-based variables Note that most subsystems don't need to do this. More...
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. More...
virtual void	Blind (const QwBlinder *blinder)
	Blind the asymmetry of this subsystem. More...
virtual void	Blind (const QwBlinder *blinder, const VQwSubsystemParity *subsys)
	Blind the difference of this subsystem. More...
virtual void	PrintValue () const
	Print values of all channels. More...
virtual void	WritePromptSummary (QwPromptSummary *ps, TString type)
virtual Bool_t	CheckForEndOfBurst () const
Public Member Functions inherited from VQwSubsystem
	VQwSubsystem (const TString &name)
	Constructor with name. More...
	VQwSubsystem (const VQwSubsystem &orig)
	Copy constructor by object. More...
virtual	~VQwSubsystem ()
	Default destructor. More...
TString	GetSubsystemName () const
Bool_t	HasDataLoaded () const
void	SetParent (QwSubsystemArray *parent)
	Set the parent of this subsystem to the specified array. More...
QwSubsystemArray *	GetParent (const unsigned int parent=0) const
	Get the parent of this subsystem. More...
VQwSubsystem *	GetSibling (const std::string &name) const
	Get the sibling with specified name. More...
Bool_t	PublishInternalValue (const TString &name, const TString &desc, const VQwHardwareChannel *value) const
	Publish a variable name to the parent subsystem array. More...
virtual Bool_t	PublishInternalValues () const
	Publish all variables of the subsystem. More...
virtual Bool_t	PublishByRequest (TString device_name)
	Try to publish an internal variable matching the submitted name. More...
Bool_t	RequestExternalValue (const TString &name, VQwHardwareChannel *value) const
	Request a named value which is owned by an external subsystem; the request will be handled by the parent subsystem array. More...
virtual const VQwHardwareChannel *	ReturnInternalValue (const TString &name) const
	Return a pointer to a varialbe to the parent subsystem array to be delivered to a different subsystem. More...
virtual Bool_t	ReturnInternalValue (const TString &name, VQwHardwareChannel *value) const
	Return a named value to the parent subsystem array to be delivered to a different subsystem. More...
virtual std::vector< TString >	GetParamFileNameList ()
virtual std::map< TString, TString >	GetDetectorMaps ()
virtual Int_t	LoadDetectorMaps (QwParameterFile &file)
	Parse parameter file to find the map files. More...
virtual Int_t	LoadGeometryDefinition (TString mapfile)
	Optional geometry definition. More...
virtual Int_t	LoadCrosstalkDefinition (TString mapfile)
	Optional crosstalk definition. More...
void	SetEventTypeMask (const UInt_t mask)
	Set event type mask. More...
UInt_t	GetEventTypeMask () const
	Get event type mask. More...
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. More...
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. More...
virtual void	AtEndOfEventLoop ()
	Perform actions at the end of the event loop. More...
virtual void	RandomizeEventData (int helicity=0, double time=0.0)
virtual void	PrintInfo () const
	Print some information about the subsystem. More...
virtual void	PrintDetectorMaps (Bool_t status) const
virtual void	ConstructHistograms ()
	Construct the histograms for this subsystem. More...
virtual void	ConstructHistograms (TDirectory *folder)
	Construct the histograms for this subsystem in a folder. More...
virtual void	ConstructHistograms (TString &prefix)
	Construct the histograms for this subsystem with a prefix. More...
virtual void	ConstructBranchAndVector (TTree *tree, std::vector< Double_t > &values)
	Construct the branch and tree vector. More...
virtual void	ConstructTree ()
	Construct the tree for this subsystem. More...
virtual void	ConstructTree (TDirectory *folder)
	Construct the tree for this subsystem in a folder. More...
virtual void	ConstructTree (TString &prefix)
	Construct the tree for this subsystem with a prefix. More...
virtual void	ConstructTree (TDirectory *folder, TString &prefix)
	Construct the tree for this subsystem in a folder with a prefix. More...
virtual void	FillTree ()
	Fill the tree for this subsystem. More...
virtual void	DeleteTree ()
	Delete the tree for this subsystem. More...
Public Member Functions inherited from MQwHistograms
void	ShareHistograms (const MQwHistograms *source)
	Share histogram pointers between objects. More...
Public Member Functions inherited from MQwCloneable< VQwSubsystem, QwHelicity >
virtual	~MQwCloneable ()
	Virtual destructor. More...
virtual VQwSubsystem *	Clone () const
	Concrete clone method. More...
const VQwFactory< VQwSubsystem > *	Factory () const
	Factory getter. More...
Public Member Functions inherited from VQwCloneable< VQwSubsystem >
virtual	~VQwCloneable ()
	Virtual destructor. More...
std::string	GetClassName () const
	Get demangled name of this class. More...

Static Public Member Functions
static void	DefineOptions (QwOptions &options)
	Define options function. More...
Static Public Member Functions inherited from VQwSubsystem
static void	DefineOptions ()
	Define options function (note: no virtual static functions in C++) More...
Static Public Member Functions inherited from MQwCloneable< VQwSubsystem, QwHelicity >
static VQwSubsystem *	Create (const std::string &name)
	Object creation. More...
static QwHelicity *	Cast (QwHelicity *type)
	Object dynamic cast. More...

Protected Types
enum	HelicityRootSavingType { kHelSaveMPS = 0, kHelSavePattern, kHelNoSave }
enum	HelicityEncodingType { kHelUserbitMode =0, kHelInputRegisterMode, kHelLocalyMadeUp, kHelInputMollerMode }
enum	InputRegisterBits { kInputReg_HelPlus = 0x1, kInputReg_HelMinus = 0x2, kInputReg_PatternSync = 0x4 }

Protected Member Functions
Bool_t	CheckIORegisterMask (const UInt_t &ioregister, const UInt_t &mask) const
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 ()
Protected Member Functions inherited from VQwSubsystem
void	UpdatePublishedValue (const TString &name, VQwHardwareChannel *data_channel)
void	ClearAllBankRegistrations ()
	Clear all registration of ROC and Bank IDs for this subsystem. More...
virtual Int_t	RegisterROCNumber (const UInt_t roc_id, const UInt_t bank_id=0)
	Tell the object that it will decode data from this ROC and sub-bank. More...
Int_t	RegisterSubbank (const UInt_t bank_id)
	Tell the object that it will decode data from this sub-bank in the ROC currently open for registration. More...
Int_t	GetSubbankIndex () const
Int_t	GetSubbankIndex (const UInt_t roc_id, const UInt_t bank_id) const
void	SetDataLoaded (Bool_t flag)
Int_t	FindIndex (const std::vector< UInt_t > &myvec, const UInt_t value) const
Bool_t	Compare (VQwSubsystem *source)
Protected Member Functions inherited from MQwHistograms
	MQwHistograms ()
	Default constructor. More...
	MQwHistograms (const MQwHistograms &source)
	Copy constructor. More...
virtual	~MQwHistograms ()
	Virtual destructor. More...
virtual MQwHistograms &	operator= (const MQwHistograms &value)
void	Fill_Pointer (TH1_ptr hist_ptr, Double_t value)
void	AddHistogram (TH1 *h)
	Register a histogram. More...

Protected Attributes
UInt_t	fInputReg_FakeMPS
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. More...
Int_t	fDelayedPatternPolarity
	Reported polarity of the current pattern. More...
Int_t	fPreviousPatternPolarity
	True polarity of the previous pattern. More...
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
Bool_t	fSuppressMPSErrorMsgs
Protected Attributes inherited from VQwSubsystem
std::map< TString, VQwHardwareChannel * >	fPublishedInternalValues
	Map of published internal values. More...
std::vector< std::vector < TString > >	fPublishList
	List of parameters to be published (loaded at the channel map) More...
TString	fSystemName
	Name of this subsystem. More...
UInt_t	fEventTypeMask
	Mask of event types. More...
Bool_t	fIsDataLoaded
	Has this subsystem gotten data to be processed? More...
std::vector< TString >	fDetectorMapsNames
std::map< TString, TString >	fDetectorMaps
Int_t	fCurrentROC_ID
	ROC ID that is currently being processed. More...
Int_t	fCurrentBank_ID
	Bank ID that is currently being processed. More...
std::vector< UInt_t >	fROC_IDs
	Vector of ROC IDs associated with this subsystem. More...
std::vector< std::vector < UInt_t > >	fBank_IDs
	Vector of Bank IDs per ROC ID associated with this subsystem. More...
std::vector< QwSubsystemArray * >	fArrays
	Vector of pointers to subsystem arrays that contain this subsystem. More...
Protected Attributes inherited from MQwHistograms
std::vector< TH1_ptr >	fHistograms
	Histograms associated with this data element. More...

Static Protected Attributes
static const UInt_t	kInputReg_FakeMPS = 0x8000
	Default mask for fake MPS latch bit. More...
static const UInt_t	kDefaultHelicityBitPattern = 0x69
static const Bool_t	kDEBUG =kFALSE
static const Int_t	kUndefinedHelicity = -9999

Private Member Functions
	QwHelicity ()
	Private default constructor (not implemented, will throw linker error on use) More...
UInt_t	BuildHelicityBitPattern (Int_t patternsize)
unsigned int	parity (unsigned int v)

Detailed Description

Definition at line 38 of file QwHelicity.h.

Member Enumeration Documentation

enum QwHelicity::HelicityEncodingType

protected

Enumerator
kHelUserbitMode
kHelInputRegisterMode
kHelLocalyMadeUp
kHelInputMollerMode

Definition at line 155 of file QwHelicity.h.

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

enum QwHelicity::HelicityRootSavingType

protected

Enumerator
kHelSaveMPS
kHelSavePattern
kHelNoSave

Definition at line 151 of file QwHelicity.h.

                             {kHelSaveMPS = 0,
            kHelSavePattern,
            kHelNoSave};

enum QwHelicity::InputRegisterBits

protected

Enumerator
kInputReg_HelPlus
kInputReg_HelMinus
kInputReg_PatternSync

Definition at line 161 of file QwHelicity.h.

                        {kInputReg_HelPlus     = 0x1,
       kInputReg_HelMinus    = 0x2,
       kInputReg_PatternSync = 0x4};

Constructor & Destructor Documentation

QwHelicity::QwHelicity ( )

private

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

QwHelicity::QwHelicity

(

const TString &

name

)

Constructor with name.

Definition at line 40 of file QwHelicity.cc.

References ClearErrorCounters(), fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fEventNumberOld, fGoodHelicity, fGoodPattern, fHelicityActual, fHelicityBitMinus, fHelicityBitPlus, fHelicityDecodingMode, fHelicityDelay, fHelicityDelayed, fHelicityReported, fInputReg_FakeMPS, fPatternNumber, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, kEventTypeHelMinus, kEventTypeHelPlus, kInputReg_FakeMPS, kUndefinedHelicity, and kUserbit.

: VQwSubsystem(name),
  VQwSubsystemParity(name),
  fHelicityBitPattern(kDefaultHelicityBitPattern),
  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;
  fGoodHelicity=kFALSE;
  fGoodPattern=kFALSE;
  fHelicityDecodingMode=-1;

  fInputReg_FakeMPS = kInputReg_FakeMPS;
}

Here is the call graph for this function:

QwHelicity::QwHelicity

(

const QwHelicity &

source

)

Copy constructor.

Definition at line 79 of file QwHelicity.cc.

References ClearErrorCounters(), fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fEventNumberFirst, fEventNumberOld, fEventType, fGoodHelicity, fGoodPattern, fHelicityActual, fHelicityBitMinus, fHelicityBitPlus, fHelicityDecodingMode, fHelicityDelay, fHelicityDelayed, fHelicityInfoOK, fHelicityReported, fIgnoreHelicity, fInputReg_FakeMPS, fMaxPatternPhase, fMinPatternPhase, fNumHelicityErrors, fNumMissedEventBlocks, fNumMissedGates, fNumMultSyncErrors, fPatternNumber, fPatternNumberFirst, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, fPatternPhaseOffset, fRandBits, fUsePredictor, fWord, iseed_Actual, iseed_Delayed, kEventTypeHelMinus, kEventTypeHelPlus, kUndefinedHelicity, kUserbit, and n_ranbits.

: VQwSubsystem(source.GetSubsystemName()),
  VQwSubsystemParity(source.GetSubsystemName()),
  fHelicityBitPattern(kDefaultHelicityBitPattern),
  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;
  fGoodHelicity=kFALSE;
  fGoodPattern=kFALSE;
  fHelicityDecodingMode=-1;

  fInputReg_FakeMPS = source.fInputReg_FakeMPS;

  this->fWord.resize(source.fWord.size());
  for(size_t i=0;i<this->fWord.size();i++)
    {
      this->fWord[i].fWordName=source.fWord[i].fWordName;
      this->fWord[i].fModuleType=source.fWord[i].fModuleType;
      this->fWord[i].fWordType=source.fWord[i].fWordType;
    }
  fNumMissedGates = source.fNumMissedGates;
  fNumMissedEventBlocks = source.fNumMissedEventBlocks;
  fNumMultSyncErrors = source.fNumMultSyncErrors;
  fNumHelicityErrors = source.fNumHelicityErrors;
  fEventNumberFirst = source.fEventNumberFirst;
  fPatternNumberFirst = source.fPatternNumberFirst;
  fEventType = source.fEventType;
  fIgnoreHelicity = source.fIgnoreHelicity;
  fRandBits = source.fRandBits;
  fUsePredictor = source.fUsePredictor;
  fHelicityInfoOK = source.fHelicityInfoOK;
  fPatternPhaseOffset = source.fPatternPhaseOffset;
  fMinPatternPhase = source.fMinPatternPhase;
  fMaxPatternPhase = source.fMaxPatternPhase;
  fHelicityDelay = source.fHelicityDelay;
  iseed_Delayed = source.iseed_Delayed;
  iseed_Actual = source.iseed_Actual;
  n_ranbits = source.n_ranbits;
  fEventNumber = source.fEventNumber;
  fEventNumberOld = source.fEventNumberOld;
  fPatternPhaseNumber = source.fPatternPhaseNumber;
  fPatternPhaseNumberOld = source.fPatternPhaseNumberOld;
  fPatternNumber = source.fPatternNumber;
  fPatternNumberOld = source.fPatternNumberOld;

  this->kUserbit = source.kUserbit;
  this->fIgnoreHelicity = source.fIgnoreHelicity;
}

Here is the call graph for this function:

virtual QwHelicity::~QwHelicity ( )

inlinevirtual

Virtual destructor.

Definition at line 50 of file QwHelicity.h.

{ }

Member Function Documentation

void QwHelicity::AccumulateRunningSum ( VQwSubsystem *  value )

inlinevirtual

Update the running sums for devices.

Implements VQwSubsystemParity.

Definition at line 120 of file QwHelicity.h.

{ };

Bool_t QwHelicity::ApplySingleEventCuts ( )

virtual

Apply the single event cuts.

Implements VQwSubsystemParity.

Definition at line 397 of file QwHelicity.cc.

                                       {
  //impose single event cuts //Paul's modifications

  return kTRUE;
}

UInt_t QwHelicity::BuildHelicityBitPattern ( Int_t  patternsize )

private

Definition at line 2028 of file QwHelicity.cc.

References QwLog::endl(), kDefaultHelicityBitPattern, QwDebug, QwError, and SetHelicityBitPattern().

Referenced by ProcessOptions().

                                                           {
  UInt_t bitpattern = 0;
  //  Standard helicity board patterns (last to first):
  //  Pair, quad, octet: -++-+--+ : 0x69
  //  Hexo-quad:         -++--++--++-+--++--++--+ : 0x666999
  //  Octo-quad:         -++--++--++--++-+--++--++--++--+ : 0x66669999
  //
  if (patternsize<8){
    bitpattern = kDefaultHelicityBitPattern;
  } else 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 << "QwHelicity::BuildHelicityBitPattern: "
      << "Unable to build standard bit pattern for pattern size of "
      << patternsize << ".  Try a pattern of 0x69."
      << QwLog::endl;
    bitpattern = kDefaultHelicityBitPattern;
  }
  QwDebug << "QwHelicity::BuildHelicityBitPattern: "
    << "Built pattern 0x" << std::hex << bitpattern
    << std::dec << " for pattern size "
    << patternsize << "." << QwLog::endl;
  //  Now set the bit pattern.
  SetHelicityBitPattern(bitpattern);
  return bitpattern;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::CalculateRunningAverage ( )

inlinevirtual

Calculate the average for all good events.

Implements VQwSubsystemParity.

Definition at line 124 of file QwHelicity.h.

{ };

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

inlineprotected

Definition at line 146 of file QwHelicity.h.

Referenced by ProcessEventInputRegisterMode().

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

Here is the caller graph for this function:

void QwHelicity::ClearErrorCounters ( )

inlineprotected

Definition at line 270 of file QwHelicity.h.

References fNumHelicityErrors, fNumMissedEventBlocks, fNumMissedGates, and fNumMultSyncErrors.

Referenced by QwHelicity().

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

Here is the caller graph for this function:

void QwHelicity::ClearEventData ( )

virtual

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.

Definition at line 347 of file QwHelicity.cc.

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

{
  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;
  return;
}

Here is the call graph for this function:

Bool_t QwHelicity::CollectRandBits ( )

protectedvirtual

Reimplemented in QwFakeHelicity.

Definition at line 1670 of file QwHelicity.cc.

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

Referenced by PredictHelicity().

{
  Bool_t status = false;

  if (fRandBits == 24)
    status = CollectRandBits24();
  if (fRandBits == 30)
    status = CollectRandBits30();

  return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool_t QwHelicity::CollectRandBits24 ( )

protected

Definition at line 1684 of file QwHelicity.cc.

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

{
    //routine to collect 24 random bits before getting the randseed for prediction
    Bool_t  ldebug = kFALSE;
    const UInt_t ranbit_goal = 24;

  QwDebug << "QwHelicity::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 << "QwHelicity::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 << "QwHelicity::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 << "QwHelicity::CollectRandBits24 => Done collecting ..." << QwLog::endl;

  return kFALSE;

}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool_t QwHelicity::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 1773 of file QwHelicity.cc.

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

{
  /** 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 << "QwHelicity:: CollectRandBits30:  Collecting randbit " << n_ranbits << ".." << QwLog::endl;
      n_ranbits++;

      /** If we got the 30th bit,*/
      if(n_ranbits == ranbit_goal){
  QwDebug << "QwHelicity:: CollectRandBits30:  done Collecting 30 randbits" << QwLog::endl;

  /** set the polarity of the current pattern to be equal to the reported helicity,*/
  fDelayedPatternPolarity = fHelicityReported;
  QwDebug << "QwHelicity:: 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 << "QwHelicity::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 << "QwHelicity::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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool_t QwHelicity::Compare ( VQwSubsystem *  source )

protected

Definition at line 2013 of file QwHelicity.cc.

References fWord.

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

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

Here is the caller graph for this function:

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

virtual

Construct the branch and tree vector.

Implements VQwSubsystem.

Definition at line 1303 of file QwHelicity.cc.

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

{
  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_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;
}

Here is the call graph for this function:

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

virtual

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

Implements VQwSubsystem.

Definition at line 1362 of file QwHelicity.cc.

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

{
  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_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;
}

Here is the call graph for this function:

void QwHelicity::ConstructBranchAndVector ( TTree *  tree, TString &  prefix, std::vector< Double_t > &  values  )

virtual

Construct the branch and tree vector.

Implements VQwSubsystem.

Definition at line 1222 of file QwHelicity.cc.

References fHistoType, fTreeArrayIndex, fWord, kHelNoSave, kHelSaveMPS, kHelSavePattern, and SetHistoTreeSave().

{
  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(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "delayed_helicity";   //predicted delayed helicity
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "reported_helicity";  //delayed helicity reported by the input register.
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "pattern_phase";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "pattern_number";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "pattern_seed";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "event_number";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      for (size_t i=0; i<fWord.size(); i++)
  {
    basename = fWord[i].fWordName;
    values.push_back(0.0);
    tree->Branch(basename, &(values.back()), basename+"/D");
  }
    }
  else if(fHistoType==kHelSavePattern)
    {
      basename = "actual_pattern_polarity";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "actual_previous_pattern_polarity";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "delayed_pattern_polarity";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "pattern_number";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      basename = "pattern_seed";
      values.push_back(0.0);
      tree->Branch(basename, &(values.back()), basename+"/D");
      //
      for (size_t i=0; i<fWord.size(); i++)
  {
    basename = fWord[i].fWordName;
    values.push_back(0.0);
    tree->Branch(basename, &(values.back()), basename+"/D");
  }
    }

  return;
}

Here is the call graph for this function:

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

virtual

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

Implements VQwSubsystem.

Definition at line 1120 of file QwHelicity.cc.

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

{
  SetHistoTreeSave(prefix);
  if (folder != NULL) folder->cd();
  TString basename;
  size_t index=0;

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

  return;
}

Here is the call graph for this function:

void QwHelicity::DeaccumulateRunningSum ( VQwSubsystem *  value )

inlinevirtual

remove one entry from the running sums for devices

Implements VQwSubsystemParity.

Definition at line 122 of file QwHelicity.h.

                                                  {
  };

void QwHelicity::DefineOptions ( QwOptions &  options )

static

Define options function.

Definition at line 149 of file QwHelicity.cc.

References QwOptions::AddOptions(), and default_bool_value.

{
  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.");
}

Here is the call graph for this function:

void QwHelicity::Difference ( VQwSubsystem *  value1, VQwSubsystem *  value2  )

virtual

Implements VQwSubsystemParity.

Definition at line 2000 of file QwHelicity.cc.

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

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

virtual

Reimplemented from VQwSubsystem.

Definition at line 714 of file QwHelicity.cc.

References QwLog::endl(), VQwSubsystem::fCurrentBank_ID, VQwSubsystem::fCurrentROC_ID, fEventNumber, fHelicityDecodingMode, fHelicityDelayed, fMinPatternPhase, fPatternNumber, fPatternPhaseNumber, fPatternPhaseOffset, kHelInputRegisterMode, kHelUserbitMode, kInputReg_HelMinus, kInputReg_HelPlus, kInputReg_PatternSync, and QwWarning.

{
  std::vector<UInt_t> localbuffer;
  localbuffer.clear();

  // Userbit mode
  switch (fHelicityDecodingMode) {
  case kHelUserbitMode: {
    UInt_t userbit = 0x0;
    if (fPatternPhaseNumber == fMinPatternPhase) userbit |= 0x80000000;
    if (fHelicityDelayed == 1)    userbit |= 0x40000000;

    // Write the words to the buffer
    localbuffer.push_back(0x1); // cleandata
    localbuffer.push_back(0xa); // scandata1
    localbuffer.push_back(0xa); // scandata2
    localbuffer.push_back(0x0); // scalerheader
    localbuffer.push_back(0x20); // scalercounter (32)
    localbuffer.push_back(userbit); // userbit

    for (int i = 0; i < 64; i++) localbuffer.push_back(0x0); // (not used)
    break;
  }
  case kHelInputRegisterMode: {
    UInt_t input_register = 0x0;
    if (fHelicityDelayed == 1) input_register |= kInputReg_HelPlus;
    if (fHelicityDelayed == 0) input_register |= kInputReg_HelMinus; // even the mock data has balanced inputs!
    if (fPatternPhaseNumber == fMinPatternPhase) input_register |= kInputReg_PatternSync;

    // Write the words to the buffer
    localbuffer.push_back(input_register); // input_register
    localbuffer.push_back(0x0); // output_register
    localbuffer.push_back(fEventNumber); // mps_counter
    localbuffer.push_back(fPatternNumber); // pat_counter
    localbuffer.push_back(fPatternPhaseNumber - fMinPatternPhase + fPatternPhaseOffset); // pat_phase

    for (int i = 0; i < 17; i++) localbuffer.push_back(0x0); // (not used)
    break;
  }
  default:
    QwWarning << "QwHelicity::EncodeEventData: Unsupported helicity encoding!" << QwLog::endl;
    break;
  }

  // If there is element data, generate the subbank header
  std::vector<UInt_t> subbankheader;
  std::vector<UInt_t> rocheader;
  if (localbuffer.size() > 0) {

    // Form CODA subbank header
    subbankheader.clear();
    subbankheader.push_back(localbuffer.size() + 1);  // subbank size
    subbankheader.push_back((fCurrentBank_ID << 16) | (0x01 << 8) | (1 & 0xff));
    // subbank tag | subbank type | event number

    // Form CODA bank/roc header
    rocheader.clear();
    rocheader.push_back(subbankheader.size() + localbuffer.size() + 1); // bank/roc size
    rocheader.push_back((fCurrentROC_ID << 16) | (0x10 << 8) | (1 & 0xff));
    // bank tag == ROC | bank type | event number

    // Add bank header, subbank header and element data to output buffer
    buffer.insert(buffer.end(), rocheader.begin(), rocheader.end());
    buffer.insert(buffer.end(), subbankheader.begin(), subbankheader.end());
    buffer.insert(buffer.end(), localbuffer.begin(), localbuffer.end());
  }
}

Here is the call graph for this function:

void QwHelicity::FillDB ( QwParityDB *  db, TString  type  )

virtual

Fill the database.

Reimplemented from VQwSubsystemParity.

Definition at line 1454 of file QwHelicity.cc.

References QwDatabase::Connect(), QwDatabase::Disconnect(), and QwDatabase::Query().

{
  if (type=="yield" || type=="asymmetry")
    return;

  db->Connect();
  mysqlpp::Query query = db->Query();

  db->Disconnect();
}

Here is the call graph for this function:

void QwHelicity::FillErrDB ( QwParityDB *  db, TString  datatype  )

virtual

Reimplemented from VQwSubsystemParity.

Definition at line 1467 of file QwHelicity.cc.

{
  return;
}

void QwHelicity::FillHistograms ( )

virtual

Fill the histograms for this subsystem.

Implements VQwSubsystem.

Definition at line 1171 of file QwHelicity.cc.

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

{
  //  Bool_t localdebug=kFALSE;

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

  return;
}

Here is the call graph for this function:

void QwHelicity::FillTreeVector ( std::vector< Double_t > &  values ) const

virtual

Fill the tree vector.

Implements VQwSubsystem.

Definition at line 1423 of file QwHelicity.cc.

References fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fHelicityActual, fHelicityDelayed, fHelicityReported, fHistoType, fPatternNumber, fPatternPhaseNumber, fPatternSeed, fPreviousPatternPolarity, fTreeArrayIndex, fWord, kHelSaveMPS, and kHelSavePattern.

{

  size_t index=fTreeArrayIndex;
  if(fHistoType==kHelSaveMPS)
    {
      values[index++] = fHelicityActual;
      values[index++] = fHelicityDelayed;
      values[index++] = fHelicityReported;
      values[index++] = fPatternPhaseNumber;
      values[index++] = fPatternNumber;
      values[index++] = fPatternSeed;
      values[index++] = fEventNumber;
      for (size_t i=0; i<fWord.size(); i++)
  values[index++] = fWord[i].fValue;
    }
  else if(fHistoType==kHelSavePattern)
    {
      values[index++] = fActualPatternPolarity;
      values[index++] = fPreviousPatternPolarity;
      values[index++] = fDelayedPatternPolarity;
      values[index++] = fPatternNumber;
      values[index++] = fPatternSeed;
      for (size_t i=0; i<fWord.size(); i++){
  values[index++] = fWord[i].fValue;
      }
    }

  return;
}

UInt_t QwHelicity::GetEventcutErrorFlag ( )

virtual

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

Implements VQwSubsystemParity.

Definition at line 435 of file QwHelicity.cc.

                                       {//return the error flag

  return 0;

}

Long_t QwHelicity::GetEventNumber

(

)

Definition at line 1079 of file QwHelicity.cc.

References fEventNumber.

Referenced by QwHelicityPattern::LoadEventData().

{
  return fEventNumber;
}

Here is the caller graph for this function:

Int_t QwHelicity::GetHelicityActual

(

)

Definition at line 1064 of file QwHelicity.cc.

References fHelicityActual.

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

{
  return fHelicityActual;
}

Here is the caller graph for this function:

Int_t QwHelicity::GetHelicityDelayed

(

)

Definition at line 1069 of file QwHelicity.cc.

References fHelicityDelayed.

Referenced by main().

{
  return fHelicityDelayed;
}

Here is the caller graph for this function:

Int_t QwHelicity::GetHelicityReported

(

)

Definition at line 1059 of file QwHelicity.cc.

References fHelicityReported.

{
  return fHelicityReported;
}

Int_t QwHelicity::GetMaxPatternPhase ( )

inline

Definition at line 100 of file QwHelicity.h.

References fMaxPatternPhase.

Referenced by QwHelicityPattern::QwHelicityPattern().

                            {
    return fMaxPatternPhase;
  };

Here is the caller graph for this function:

Int_t QwHelicity::GetMinPatternPhase ( )

inline

Definition at line 103 of file QwHelicity.h.

References fMinPatternPhase.

Referenced by QwHelicityPattern::LoadEventData().

                            {
    return fMinPatternPhase;
  }

Here is the caller graph for this function:

Long_t QwHelicity::GetPatternNumber

(

)

Definition at line 1074 of file QwHelicity.cc.

References fPatternNumber.

Referenced by QwHelicityPattern::LoadEventData().

{
  return  fPatternNumber;
}

Here is the caller graph for this function:

Int_t QwHelicity::GetPhaseNumber

(

)

Definition at line 1084 of file QwHelicity.cc.

References fPatternPhaseNumber.

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

{
  return fPatternPhaseNumber;
}

Here is the caller graph for this function:

UInt_t QwHelicity::GetRandbit ( UInt_t &  ranseed )

protectedvirtual

Reimplemented in QwFakeHelicity.

Definition at line 1473 of file QwHelicity.cc.

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

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

                                            {
  Bool_t status = false;

  if (fRandBits == 24)
    status = GetRandbit24(ranseed);
  if (fRandBits == 30)
    status = GetRandbit30(ranseed);

  return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

UInt_t QwHelicity::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 1484 of file QwHelicity.cc.

References QwLog::endl(), and QwError.

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

{
  /** 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);

}

Here is the call graph for this function:

Here is the caller graph for this function:

UInt_t QwHelicity::GetRandbit30 ( UInt_t &  ranseed )

protected

Definition at line 1541 of file QwHelicity.cc.

References QwLog::endl(), and QwError.

Referenced by GetRandbit().

{
  /* 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

UInt_t QwHelicity::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 1562 of file QwHelicity.cc.

References QwLog::endl(), and QwDebug.

Referenced by CollectRandBits24(), and SetFirstBits().

{
  Bool_t ldebug=0;
  QwDebug << " Entering QwHelicity::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 QwHelicity::GetRandomSeed \n";


  return ranseed;

}

Here is the call graph for this function:

Here is the caller graph for this function:

UInt_t QwHelicity::GetRandomSeedActual ( )

inline

Definition at line 86 of file QwHelicity.h.

References iseed_Actual.

Referenced by main().

{ return iseed_Actual; };

Here is the caller graph for this function:

UInt_t QwHelicity::GetRandomSeedDelayed ( )

inline

Definition at line 87 of file QwHelicity.h.

References iseed_Delayed.

Referenced by main().

{ return iseed_Delayed; };

Here is the caller graph for this function:

void QwHelicity::IncrementErrorCounters ( )

virtual

Increment the error counters.

TODO: Implement QwHelicity::IncrementErrorCounters()

Implements VQwSubsystemParity.

Definition at line 403 of file QwHelicity.cc.

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

Bool_t QwHelicity::IsContinuous ( )

protected

Definition at line 239 of file QwHelicity.cc.

References IsGoodEventNumber(), IsGoodPatternNumber(), and IsGoodPhaseNumber().

Referenced by CollectRandBits24(), and CollectRandBits30().

{
  Bool_t results=kFALSE;
  if(IsGoodPatternNumber()&&IsGoodEventNumber()&&IsGoodPhaseNumber())
    results=kTRUE;
  return results;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool_t QwHelicity::IsGoodEventNumber ( )

protected

Definition at line 267 of file QwHelicity.cc.

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

Referenced by IsContinuous().

{
  Bool_t results;
  if(fEventNumber == fEventNumberOld + 1)
    results= kTRUE;
  else
    results= kFALSE;

  if(!results) {
    QwWarning << "QwHelicity::IsGoodEventNumber: \n this is not a good event number indeed:" << QwLog::endl;
    Print();
  }
  return results;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool_t QwHelicity::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 314 of file QwHelicity.cc.

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

Referenced by PredictHelicity().

{
  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++;
    if(fPatternPhaseNumber == fMinPatternPhase) {
      //first event in a new pattern
      QwError << "QwHelicity::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 << "QwHelicity::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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool_t QwHelicity::IsGoodPatternNumber ( )

protected

Definition at line 248 of file QwHelicity.cc.

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

Referenced by IsContinuous().

{
  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 << "QwHelicity::IsGoodPatternNumber:  This is not a good pattern number. New = "<< fPatternNumber << " Old = " <<  fPatternNumberOld << QwLog::endl;
    //Print();
  }

  return results;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool_t QwHelicity::IsGoodPhaseNumber ( )

protected

Definition at line 283 of file QwHelicity.cc.

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

Referenced by IsContinuous().

{
  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 << "QwHelicity::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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool_t QwHelicity::IsHelicityIgnored ( )

inline

Definition at line 140 of file QwHelicity.h.

References fIgnoreHelicity.

Referenced by QwHelicityPattern::LoadEventData().

{return fIgnoreHelicity;};

Here is the caller graph for this function:

Int_t QwHelicity::LoadChannelMap ( TString  mapfile )

virtual

Mandatory map file definition.

Implements VQwSubsystem.

Definition at line 804 of file QwHelicity.cc.

References QwLog::endl(), VQwSubsystem::fDetectorMaps, fHelicityDecodingMode, fInputReg_FakeMPS, fMaxPatternPhase, QwWord::fModuleType, fPatternPhaseOffset, fRandBits, QwWord::fSubbankIndex, fWord, QwWord::fWordInSubbank, QwWord::fWordName, fWordsPerSubbank, QwWord::fWordType, VQwSubsystem::GetSubbankIndex(), QwParameterFile::GetUInt(), kEventTypeHelMinus, kEventTypeHelPlus, kHelInputMollerMode, kHelInputRegisterMode, kHelLocalyMadeUp, kHelUserbitMode, kInputRegister, kMpsCounter, kPatternCounter, kPatternPhase, kScalerCounter, kUserbit, QwDebug, QwError, QwMessage, QwWarning, VQwSubsystem::RegisterROCNumber(), VQwSubsystem::RegisterSubbank(), SetHelicityBitPattern(), and SetHelicityDelay().

{
  Bool_t ldebug=kFALSE;

  Int_t currentrocread=0;
  Int_t currentbankread=0;
  Int_t wordsofar=0;
  Int_t currentsubbankindex=-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());

  while (mapstr.ReadNextLine()){
    mapstr.TrimComment('!');   // Remove everything after a '!' character.
    mapstr.TrimWhitespace();   // Get rid of leading and trailing spaces.
    if (mapstr.LineIsEmpty())  continue;

    TString varname, varvalue;
    if (mapstr.HasVariablePair("=",varname,varvalue)){
      //  This is a declaration line.  Decode it.
      varname.ToLower();
      UInt_t value = QwParameterFile::GetUInt(varvalue);

      if (varname=="roc")
  {
    currentrocread=value;
    RegisterROCNumber(value,0);
    fWordsPerSubbank.push_back( std::pair<Int_t, Int_t>(fWord.size(),fWord.size()));
  }
      else if (varname=="bank")
  {
    currentbankread=value;
    RegisterSubbank(value);
    fWordsPerSubbank.push_back( std::pair<Int_t, Int_t>(fWord.size(),fWord.size()));
  }
      else if (varname=="patternphase")
  {
    fMaxPatternPhase=value;
    //QwMessage << " fMaxPatternPhase " << fMaxPatternPhase << QwLog::endl;
  }
      else if (varname=="patternbits")
        {
          SetHelicityBitPattern(value);
        }
      else if (varname=="fakempsbit")
        {
          fInputReg_FakeMPS = value;
          QwWarning << " fInputReg_FakeMPS 0x" << std::hex << fInputReg_FakeMPS << std::dec << QwLog::endl;
        }
      else if (varname=="numberpatternsdelayed")
  {
    SetHelicityDelay(value);
  }
      else if (varname=="randseedbits")
  {
    if (value==24 || value==30)
      fRandBits = value;
  }
      else if (varname=="patternphaseoffset")
  {
    fPatternPhaseOffset=value;
  }
      else if(varname=="helpluseventtype")
  {
    kEventTypeHelPlus = value;
  }
      else if(varname=="helminuseventtype")
  {
    kEventTypeHelMinus = value;
  }
      else if (varname=="helicitydecodingmode")
  {
    if (varvalue=="InputRegisterMode") {
      QwMessage << " **** Input Register Mode **** " << QwLog::endl;
      fHelicityDecodingMode=kHelInputRegisterMode;
    }
    else if (varvalue=="UserbitMode"){
      QwMessage << " **** Userbit Mode **** " << QwLog::endl;
      fHelicityDecodingMode=kHelUserbitMode;
    }
    else if (varvalue=="HelLocalyMadeUp"){
      QwMessage << "**** Helicity Locally Made Up ****" << QwLog::endl;
      fHelicityDecodingMode=kHelLocalyMadeUp;
    }
    else if (varvalue=="InputMollerMode") {
      QwMessage << "**** Input Moller Mode ****" << QwLog::endl;
      fHelicityDecodingMode=kHelInputMollerMode;
    }
    else {
      QwError  << "The helicity decoding mode read in file " << mapfile
         << " is not recognized in function QwHelicity::LoadChannelMap \n"
         << " Quiting this execution." << QwLog::endl;
    }
  }
    } else {
      //  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(currentsubbankindex!=GetSubbankIndex(currentrocread,currentbankread))
  {
    currentsubbankindex=GetSubbankIndex(currentrocread,currentbankread);
    wordsofar=0;
  }

      if(modtype=="SKIP"){
  if (modnum<=0) wordsofar+=1;
  else           wordsofar+=modnum;
      }
      else if(modtype!="WORD"|| dettype!="helicitydata")
  {
    QwError << "QwHelicity::LoadChannelMap:  Unknown detector type: "
      << dettype  << ", the detector " << namech << " will not be decoded "
      << QwLog::endl;
    continue;
  }
      else
  {
    QwWord localword;
    localword.fSubbankIndex=currentsubbankindex;
    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[currentsubbankindex].second = fWord.size();
    QwDebug << "--" << namech << "--" << fWord.size()-1 << QwLog::endl;

    // Notice that "namech" is in lower-case, so these checks
    // should all be in lower-case
    switch (fHelicityDecodingMode)
      {
      case kHelUserbitMode :
        if(namech.Contains("userbit")) kUserbit=fWord.size()-1;
        if(namech.Contains("scalercounter")) kScalerCounter=fWord.size()-1;
        break;
      case kHelInputRegisterMode :
        if(namech.Contains("input_register")) kInputRegister= fWord.size()-1;
        if(namech.Contains("mps_counter")) kMpsCounter= fWord.size()-1;
        if(namech.Contains("pat_counter")) kPatternCounter= fWord.size()-1;
        if(namech.Contains("pat_phase")) kPatternPhase= fWord.size()-1;
        break;
      case kHelInputMollerMode :
        if(namech.Contains("mps_counter")) {
    kMpsCounter= fWord.size()-1;
        }
        if(namech.Contains("pat_counter")) {
    kPatternCounter = fWord.size()-1;
        }
        break;
      }
  }
    }
  }

  if(ldebug)
    {
      std::cout << "Done with Load map channel \n";
      for(size_t i=0;i<fWord.size();i++)
  fWord[i].PrintID();
      std::cout << " kUserbit=" << kUserbit << "\n";

    }
  ldebug=kFALSE;


  if (fHelicityDecodingMode==kHelInputMollerMode){
    // Check to be sure kEventTypeHelPlus and kEventTypeHelMinus are both defined and not equal
    if (kEventTypeHelPlus != kEventTypeHelMinus
  && kEventTypeHelPlus>0 && kEventTypeHelPlus<15
  && kEventTypeHelMinus>0 && kEventTypeHelMinus<15) {
      // Everything is okay
      QwDebug << "QwHelicity::LoadChannelMap:"
        << "  We are in Moller Helicity Mode, with HelPlusEventType = "
        << kEventTypeHelPlus
        << "and HelMinusEventType = " << kEventTypeHelMinus
        << QwLog::endl;
    } else {
      QwError << "QwHelicity::LoadChannelMap:"
        << "  We are in Moller Helicity Mode, and the HelPlus and HelMinus event types are not set properly."
        << "  HelPlusEventType = "  << kEventTypeHelPlus
        << ", HelMinusEventType = " << kEventTypeHelMinus
        << ".  Please correct the helicity map file!"
        << QwLog::endl;
      exit(65);
    }
  }

  mapstr.Close(); // Close the file (ifstream)
  return 0;
}

Here is the call graph for this function:

Int_t QwHelicity::LoadEventCuts ( TString  filename )

virtual

Load the event cuts file.

Implements VQwSubsystemParity.

Definition at line 1015 of file QwHelicity.cc.

                                               {
  return 0;
}

Int_t QwHelicity::LoadInputParameters ( TString  mapfile )

virtual

Mandatory parameter file definition.

Implements VQwSubsystem.

Definition at line 391 of file QwHelicity.cc.

{
  return 0;
}

Bool_t QwHelicity::MatchActualHelicity ( Int_t  actual )

protected

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

virtual

Implements VQwSubsystemParity.

Definition at line 1965 of file QwHelicity.cc.

References Compare(), QwLog::endl(), fActualPatternPolarity, fPatternNumber, VQwSubsystem::GetSubsystemName(), and QwDebug.

{
  //  Bool_t localdebug=kFALSE;
  QwDebug << "Entering QwHelicity::operator+= adding " << value->GetSubsystemName() << " to " << this->GetSubsystemName() << " " << 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.
  if(Compare(value))
    {
      QwHelicity* input= dynamic_cast<QwHelicity*>(value);
      QwDebug << "QwHelicity::operator+=: this->fPatternNumber=" << this->fPatternNumber 
        << ", input->fPatternNumber=" << input->fPatternNumber << QwLog::endl;

      if(this->fPatternNumber!=input->fPatternNumber)
  this->fPatternNumber=-999999;
      if(this->fActualPatternPolarity!=input->fActualPatternPolarity)
  this->fPatternNumber=-999999;
    }
  return *this;
}

Here is the call graph for this function:

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

inlinevirtual

Implements VQwSubsystemParity.

Definition at line 114 of file QwHelicity.h.

{return *this;};

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

virtual

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

Implements VQwSubsystemParity.

Definition at line 1927 of file QwHelicity.cc.

References Compare(), fActualPatternPolarity, fDelayedPatternPolarity, fEventNumber, fGoodHelicity, fGoodPattern, fHelicityActual, fHelicityBitMinus, fHelicityBitPlus, fHelicityDelayed, fHelicityReported, fIgnoreHelicity, fPatternNumber, fPatternPhaseNumber, fPatternSeed, fPreviousPatternPolarity, fWord, and VQwSubsystem::operator=().

{
  Bool_t ldebug = kFALSE;
  if(Compare(value))
    {

       //QwHelicity* input= (QwHelicity*)value;
      VQwSubsystem::operator=(value);
      QwHelicity* input= dynamic_cast<QwHelicity*>(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;

      if(ldebug){
  std::cout << "QwHelicity::operator = this->fPatternNumber=" << this->fPatternNumber << std::endl;
  std::cout << "input->fPatternNumber=" << input->fPatternNumber << "\n";
      }
    }

  return *this;
}

Here is the call graph for this function:

unsigned int QwHelicity::parity ( unsigned int  v )

inlineprivate

Definition at line 292 of file QwHelicity.h.

Referenced by SetHelicityBitPattern().

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

Here is the caller graph for this function:

void QwHelicity::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 1849 of file QwHelicity.cc.

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

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

{
   Bool_t ldebug=kFALSE;

   if(ldebug)  std::cout << "Entering QwHelicity::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 << "QwHelicity::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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::Print

(

)

const

Definition at line 782 of file QwHelicity.cc.

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

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

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::PrintErrorCounters ( ) const

virtual

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

Implements VQwSubsystemParity.

Definition at line 408 of file QwHelicity.cc.

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

                                         {
  // report number of events failed due to HW and event cut faliure
  QwMessage << "\n*********QwHelicity 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;
}

Here is the call graph for this function:

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

virtual

Implements VQwSubsystem.

Definition at line 384 of file QwHelicity.cc.

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

Int_t QwHelicity::ProcessEvBuffer ( const UInt_t  roc_id, const UInt_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.

Definition at line 72 of file QwHelicity.h.

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

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

virtual

Reimplemented from VQwSubsystem.

Definition at line 1019 of file QwHelicity.cc.

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

{
  Bool_t lkDEBUG = kFALSE;

  if (((0x1 << (event_type - 1)) & this->GetEventTypeMask()) == 0)
    return 0;
  fEventType = event_type;

  Int_t index = GetSubbankIndex(roc_id,bank_id);
  if (index >= 0 && num_words > 0) {
    SetDataLoaded(kTRUE);
    //  We want to process this ROC.  Begin loopilooping through the data.
    QwDebug << "QwHelicity::ProcessEvBuffer:  "
      << "Begin processing ROC" << roc_id
      << " and subbank " << bank_id
      << " number of words=" << num_words << QwLog::endl;

    for(Int_t i=fWordsPerSubbank[index].first; i<fWordsPerSubbank[index].second; i++) {
      if(fWord[i].fWordInSubbank+1<= (Int_t) num_words) {
  fWord[i].fValue=buffer[fWord[i].fWordInSubbank];
      } else {
  QwWarning << "QwHelicity::ProcessEvBuffer:  There is not enough word in the buffer to read data for "
      << fWord[i].fWordName << QwLog::endl;
  QwWarning << "QwHelicity::ProcessEvBuffer:  Words in this buffer:" << num_words
      << " trying to read word number =" << fWord[i].fWordInSubbank << QwLog::endl;
      }
    }
    if(lkDEBUG) {
      QwDebug << "QwHelicity::ProcessEvBuffer:  Done with Processing this event" << QwLog::endl;
      for(size_t i=0;i<fWord.size();i++) {
  std::cout << " word number = " << i << " ";
  fWord[i].Print();
      }
    }
  }
  lkDEBUG=kFALSE;
  return 0;
}

Here is the call graph for this function:

void QwHelicity::ProcessEvent ( )

virtual

Implements VQwSubsystem.

Reimplemented in QwFakeHelicity.

Definition at line 658 of file QwHelicity.cc.

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

{
  Bool_t ldebug = kFALSE;

  if (! HasDataLoaded()) return;

  switch (fHelicityDecodingMode)
    {
    case kHelUserbitMode :
      ProcessEventUserbitMode();
      break;
    case kHelInputRegisterMode :
      ProcessEventInputRegisterMode();
      break;
    case kHelInputMollerMode :
      ProcessEventInputMollerMode();
      break;
    default:
      QwError << "QwHelicity::ProcessEvent no instructions on how to decode the helicity !!!!" << QwLog::endl;
      abort();
      break;
    }

  if(fHelicityBitPlus==fHelicityBitMinus)
    fHelicityReported=-1;
    
  // Predict helicity if delay is non zero.
  if(fUsePredictor && !fIgnoreHelicity){
    PredictHelicity();
  } else {
    // Else use the reported helicity values.
    fHelicityActual  = fHelicityReported;
    fHelicityDelayed = fHelicityReported;

    if(fPatternPhaseNumber== fMinPatternPhase){
      fPreviousPatternPolarity = fActualPatternPolarity;
      fActualPatternPolarity   = fHelicityReported;
      fDelayedPatternPolarity  = fHelicityReported;
    } 
    
  }

  if(ldebug){
    std::cout<<"\nevent number= "<<fEventNumber<<std::endl;
    std::cout<<"pattern number = "<<fPatternNumber<<std::endl;
    std::cout<<"pattern phase = "<<fPatternPhaseNumber<<std::endl;
    std::cout<<"max pattern phase = "<<fMaxPatternPhase<<std::endl;
    std::cout<<"min pattern phase = "<<fMinPatternPhase<<std::endl;


  }

  return;
}

Here is the call graph for this function:

void QwHelicity::ProcessEventInputMollerMode

(

)

Definition at line 613 of file QwHelicity.cc.

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

Referenced by ProcessEvent().

{
  static Bool_t firstpattern = kTRUE;

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

  if (fHelicityReported == 1){
    fHelicityBitPlus=kTRUE;
    fHelicityBitMinus=kFALSE;
  } else {
    fHelicityBitPlus=kFALSE;
    fHelicityBitMinus=kTRUE;
  }
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::ProcessEventInputRegisterMode

(

)

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

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

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

Definition at line 518 of file QwHelicity.cc.

References CheckIORegisterMask(), QwLog::endl(), fEventNumber, fEventNumberOld, fHelicityBitMinus, fHelicityBitPlus, fHelicityReported, fIgnoreHelicity, fInputReg_FakeMPS, fMinPatternPhase, fNumMissedEventBlocks, fNumMissedGates, fNumMultSyncErrors, fPatternNumber, fPatternNumberOld, fPatternPhaseNumber, fPatternPhaseNumberOld, fPatternPhaseOffset, fSuppressMPSErrorMsgs, fWord, kInputReg_HelMinus, kInputReg_HelPlus, kInputReg_PatternSync, kInputRegister, kMpsCounter, kPatternCounter, kPatternPhase, kUndefinedHelicity, and QwError.

Referenced by ProcessEvent().

{
  static Bool_t firstpattern = kTRUE;
  Bool_t fake_the_counters=kFALSE;
  UInt_t thisinputregister=fWord[kInputRegister].fValue;

  /**
     In the Input Register Mode,
     the event number is obtained straight from the wordkMPSCounter.
  */
  fEventNumber=fWord[kMpsCounter].fValue;

  if (CheckIORegisterMask(thisinputregister,fInputReg_FakeMPS))
    fIgnoreHelicity = kTRUE;
  else 
    fIgnoreHelicity = kFALSE;

  // When we have the minimum phase from the pattern phase word
  // and the input register minimum phase bit is set
  // we can select the second pattern as below.
  if(fWord[kPatternPhase].fValue - fPatternPhaseOffset == 0)
    if (firstpattern && CheckIORegisterMask(thisinputregister,kInputReg_PatternSync)){
      firstpattern   = kFALSE;
    }

  // If firstpattern is still TRUE, we are still searching for the first
  // pattern of the data stream. So set the pattern number = 0
  if (firstpattern)
    fPatternNumber      = -1;
  else {
    fPatternNumber      = fWord[kPatternCounter].fValue;
    fPatternPhaseNumber = fWord[kPatternPhase].fValue - fPatternPhaseOffset + fMinPatternPhase;
  }

  /** Tf we get junk for the mps and pattern information from the run
      we can enable fake counters for mps, pattern number and pattern phase to get the job done.
  */
  if (fake_the_counters){
    fEventNumber = fEventNumberOld+1;
    if (CheckIORegisterMask(thisinputregister,kInputReg_PatternSync)) {
      fPatternPhaseNumber = fMinPatternPhase;
      fPatternNumber      = fPatternNumberOld + 1;
    } else  {
      fPatternPhaseNumber = fPatternPhaseNumberOld + 1;
      fPatternNumber      = fPatternNumberOld;
    }
  }


  if(fEventNumber!=(fEventNumberOld+1)){
    Int_t nummissed(fEventNumber - (fEventNumberOld+1));
    if (!fSuppressMPSErrorMsgs){
      QwError << "QwHelicity::ProcessEvent read event# ("
        << fEventNumber << ") is not  old_event#+1; missed "
        << nummissed << " gates" << QwLog::endl;
    }
    fNumMissedGates += nummissed;
    fNumMissedEventBlocks++;
  }

  if (CheckIORegisterMask(thisinputregister,kInputReg_PatternSync) && fPatternPhaseNumber != fMinPatternPhase){
    //  Quartet bit is set.
    QwError << "QwHelicity::ProcessEvent:  The Multiplet Sync bit is set, but the Pattern Phase is (" 
      << fPatternPhaseNumber << ") not "
      << fMinPatternPhase << "!  Please check the fPatternPhaseOffset in the helicity map file." << QwLog::endl;
    fNumMultSyncErrors++;
  }

  fHelicityReported=0;

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

  if (CheckIORegisterMask(thisinputregister,kInputReg_HelPlus)
      && CheckIORegisterMask(thisinputregister,kInputReg_HelMinus) ){
    //  Both helicity bits are set.
    QwError << "QwHelicity::ProcessEvent:  Both the H+ and H- bits are set: thisinputregister==" 
      << thisinputregister << QwLog::endl;
    fHelicityReported = kUndefinedHelicity;
    fHelicityBitPlus  = kFALSE;
    fHelicityBitMinus = kFALSE;
  } else if (CheckIORegisterMask(thisinputregister,kInputReg_HelPlus)){ //  HelPlus bit is set.
    fHelicityReported    |= 1; // Set the InputReg HEL+ bit.
    fHelicityBitPlus  = kTRUE;
    fHelicityBitMinus = kFALSE;
  } else {
    fHelicityReported    |= 0; // Set the InputReg HEL- bit.
    fHelicityBitPlus  = kFALSE;
    fHelicityBitMinus = kTRUE;
  }
  
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::ProcessEventUserbitMode

(

)

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

Definition at line 441 of file QwHelicity.cc.

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

Referenced by ProcessEvent().

{

  /** In this version of the code, the helicity is extracted for a userbit configuration.
      This is not what we plan to have for Qweak but it was done for injector tests and 
      so is usefull to have as another option to get helicity information. */
  
  Bool_t ldebug=kFALSE;
  UInt_t userbits;
  static UInt_t lastuserbits  = 0xFF;
  UInt_t scaleroffset=fWord[kScalerCounter].fValue/32;

  if(scaleroffset==1 || scaleroffset==0) {
    userbits = (fWord[kUserbit].fValue & 0xE0000000)>>28;

    //  Now fake the input register, MPS coutner, QRT counter, and QRT phase.
    fEventNumber=fEventNumberOld+1;

    lastuserbits = userbits;

    if (lastuserbits==0xFF) {
      fPatternPhaseNumber    = fMinPatternPhase;
    } else {
      if ((lastuserbits & 0x8) == 0x8) {
  //  Quartet bit is set.
  fPatternPhaseNumber    = fMinPatternPhase;  // Reset the QRT phase
  fPatternNumber=fPatternNumberOld+1;     // Increment the QRT counter
      } else {
  fPatternPhaseNumber=fPatternPhaseNumberOld+1;       // Increment the QRT phase
      }

      fHelicityReported=0;

      if ((lastuserbits & 0x4) == 0x4){ //  Helicity bit is set.
  fHelicityReported    |= 1; // Set the InputReg HEL+ bit.
  fHelicityBitPlus=kTRUE;
  fHelicityBitMinus=kFALSE;
      } else {
  fHelicityReported    |= 0; // Set the InputReg HEL- bit.
  fHelicityBitPlus=kFALSE;
  fHelicityBitMinus=kTRUE;
      }
    }
  } else {
    QwError << " QwHelicity::ProcessEvent finding a missed read event in the scaler" << QwLog::endl;
    if(ldebug) {
      std::cout << " QwHelicity::ProcessEvent :" << scaleroffset << " events were missed \n";
      std::cout << " before manipulation \n";
      Print();
    }
    //there was more than one event since the last reading of the scalers
    //ie we should read only one event at the time,
    //if not something is wrong
    fEventNumber=fEventNumberOld+scaleroffset;
    Int_t localphase=fPatternPhaseNumberOld;
    Int_t localpatternnumber=fPatternNumberOld;
    for (UInt_t i=0;i<scaleroffset;i++) {
      fPatternPhaseNumber=localphase+1;
      if(fPatternPhaseNumber>fMaxPatternPhase) {
  fPatternNumber=localpatternnumber+fPatternPhaseNumber/fMaxPatternPhase;
  fPatternPhaseNumber=fPatternPhaseNumber-fMaxPatternPhase;
  localpatternnumber=fPatternNumber;
      }
      localphase=fPatternPhaseNumber;
    }
    //Reset helicity predictor because we are not sure of what we are doing
    fHelicityReported=-1;
    ResetPredictor();
    if(ldebug) {
      std::cout << " after manipulation \n";
      Print();
    }
  }
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::ProcessOptions ( QwOptions &  options )

virtual

Process the command line options.

Reimplemented from VQwSubsystem.

Definition at line 173 of file QwHelicity.cc.

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

{
  // Read the cmd options and override channel map settings
  QwMessage << "QwHelicity::ProcessOptions" << QwLog::endl;
  if (options.HasValue("helicity.patternoffset")) {
    if (options.GetValue<int>("helicity.patternoffset") == 1
     || options.GetValue<int>("helicity.patternoffset") == 0) {
      fPatternPhaseOffset = options.GetValue<int>("helicity.patternoffset");
      QwMessage << " Pattern Phase Offset = " << fPatternPhaseOffset << QwLog::endl;
    } else QwError << "Pattern phase offset should be 0 or 1!" << QwLog::endl;
  }

  if (options.HasValue("helicity.patternphase")) {
    if (options.GetValue<int>("helicity.patternphase") % 2 == 0) {
      fMaxPatternPhase = options.GetValue<int>("helicity.patternphase");
      QwMessage << " Maximum Pattern Phase = " << fMaxPatternPhase << QwLog::endl;
    } else QwError << "Pattern phase should be an even integer!" << QwLog::endl;
  }

  if (options.HasValue("helicity.seed")) {
    if (options.GetValue<int>("helicity.seed") == 24
     || options.GetValue<int>("helicity.seed") == 30) {
      QwMessage << " Random Bits = " << options.GetValue<int>("helicity.seed") << QwLog::endl;
      fRandBits = options.GetValue<int>("helicity.seed");
    } else QwError << "Number of random seed bits should be 24 or 30!" << QwLog::endl;
  }

  if (options.HasValue("helicity.delay")) {
    QwMessage << " Helicity Delay = " << options.GetValue<int>("helicity.delay") << QwLog::endl;
    SetHelicityDelay(options.GetValue<int>("helicity.delay"));
  }

  if (options.HasValue("helicity.bitpattern")) {
    QwMessage << " Helicity Pattern =" 
        << options.GetValue<std::string>("helicity.bitpattern") 
        << QwLog::endl;
    std::string hex = options.GetValue<std::string>("helicity.bitpattern");
    UInt_t bits = QwParameterFile::GetUInt(hex);
    SetHelicityBitPattern(bits);
  } 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;
  }
}

Here is the call graph for this function:

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

virtual

Implements VQwSubsystemParity.

Definition at line 2006 of file QwHelicity.cc.

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

void QwHelicity::ResetPredictor ( )

protected

Start a new helicity prediction sequence.

Definition at line 1914 of file QwHelicity.cc.

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

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

{
  /**Start a new helicity prediction sequence.*/

  QwWarning << "QwHelicity::ResetPredictor:  Resetting helicity prediction!" << QwLog::endl;
  n_ranbits = 0;
  fGoodHelicity = kFALSE;
  fGoodPattern = kFALSE;
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::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 1608 of file QwHelicity.cc.

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

{
  Int_t ldebug = kFALSE;

  if(ldebug)  std::cout  << "Entering QwHelicity::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


  // Use the stored helicity bit pattern to calculate the helicity of this window
  if (((fHelicityBitPattern >> localphase) & 0x1) == (fHelicityBitPattern & 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 QwHelicity::RunPredictor " << QwLog::endl;

  }

  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::Scale ( Double_t  factor )

inlinevirtual

Implements VQwSubsystemParity.

Definition at line 115 of file QwHelicity.h.

{return;};

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

Definition at line 1089 of file QwHelicity.cc.

References fEventNumber, fPatternNumber, and fPatternPhaseNumber.

Referenced by main().

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

Here is the caller graph for this function:

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

Definition at line 1096 of file QwHelicity.cc.

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

Referenced by main().

{
  // 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::SetHelicityBitPattern

(

UInt_t

bits

)

Definition at line 1904 of file QwHelicity.cc.

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

Referenced by BuildHelicityBitPattern(), LoadChannelMap(), and ProcessOptions().

{
  // 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" << std::hex << fHelicityBitPattern << std::dec << QwLog::endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::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 1881 of file QwHelicity.cc.

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

Referenced by LoadChannelMap(), and ProcessOptions().

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

  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwHelicity::SetHistoTreeSave ( const TString &  prefix )

protected

Definition at line 1108 of file QwHelicity.cc.

References fHistoType, kHelNoSave, kHelSaveMPS, and kHelSavePattern.

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

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

Here is the caller graph for this function:

void QwHelicity::Sum ( VQwSubsystem *  value1, VQwSubsystem *  value2  )

virtual

Implements VQwSubsystemParity.

Definition at line 1988 of file QwHelicity.cc.

References Compare().

{
  //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 followign lines
  //are only use to put safe gards testing for example if the two instantiation indeed
  // refers to elements in the same pattern
  if(Compare(value1)&&Compare(value2)) {
    *this =  value1;
    //*this += value2;
  }
}

Here is the call graph for this function:

void QwHelicity::UpdateErrorFlag ( const VQwSubsystem *  ev_error )

inlinevirtual

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.

Definition at line 67 of file QwHelicity.h.

                                                    {
  };

Field Documentation

Int_t QwHelicity::fActualPatternPolarity

protected

True polarity of the current pattern.

Definition at line 198 of file QwHelicity.h.

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

Int_t QwHelicity::fDelayedPatternPolarity

protected

Reported polarity of the current pattern.

Definition at line 199 of file QwHelicity.h.

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

Int_t QwHelicity::fEventNumber

protected

Definition at line 194 of file QwHelicity.h.

Referenced by QwFakeHelicity::ClearEventData(), ClearEventData(), CollectRandBits24(), CollectRandBits30(), ConstructBranch(), EncodeEventData(), FillHistograms(), FillTreeVector(), GetEventNumber(), IsGoodEventNumber(), IsGoodHelicity(), operator=(), Print(), PrintErrorCounters(), QwFakeHelicity::ProcessEvent(), ProcessEvent(), ProcessEventInputMollerMode(), ProcessEventInputRegisterMode(), ProcessEventUserbitMode(), QwHelicity(), RunPredictor(), and SetEventPatternPhase().

Int_t QwHelicity::fEventNumberFirst

protected

Definition at line 267 of file QwHelicity.h.

Referenced by ClearEventData(), PrintErrorCounters(), and QwHelicity().

Int_t QwHelicity::fEventNumberOld

protected

Definition at line 194 of file QwHelicity.h.

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

UInt_t QwHelicity::fEventType

protected

Definition at line 264 of file QwHelicity.h.

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

Bool_t QwHelicity::fGoodHelicity

protected

Definition at line 209 of file QwHelicity.h.

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

Bool_t QwHelicity::fGoodPattern

protected

Definition at line 210 of file QwHelicity.h.

Referenced by operator=(), QwHelicity(), and ResetPredictor().

Int_t QwHelicity::fHelicityActual

protected

Definition at line 201 of file QwHelicity.h.

Referenced by QwFakeHelicity::ClearEventData(), ClearEventData(), QwFakeHelicity::CollectRandBits(), CollectRandBits24(), CollectRandBits30(), ConstructBranch(), FillHistograms(), FillTreeVector(), GetHelicityActual(), IsGoodHelicity(), operator=(), Print(), QwFakeHelicity::ProcessEvent(), ProcessEvent(), QwHelicity(), and RunPredictor().

Bool_t QwHelicity::fHelicityBitMinus

protected

Definition at line 208 of file QwHelicity.h.

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

UInt_t QwHelicity::fHelicityBitPattern

protected

Definition at line 170 of file QwHelicity.h.

Referenced by ProcessOptions(), RunPredictor(), and SetHelicityBitPattern().

Bool_t QwHelicity::fHelicityBitPlus

protected

Definition at line 207 of file QwHelicity.h.

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

Int_t QwHelicity::fHelicityDecodingMode

protected

Definition at line 175 of file QwHelicity.h.

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

Int_t QwHelicity::fHelicityDelay

protected

Definition at line 233 of file QwHelicity.h.

Referenced by CollectRandBits24(), CollectRandBits30(), ProcessOptions(), QwHelicity(), SetFirstBits(), and SetHelicityDelay().

Int_t QwHelicity::fHelicityDelayed

protected

Definition at line 201 of file QwHelicity.h.

Referenced by ClearEventData(), QwFakeHelicity::CollectRandBits(), CollectRandBits24(), CollectRandBits30(), ConstructBranch(), EncodeEventData(), FillTreeVector(), GetHelicityDelayed(), IsGoodHelicity(), operator=(), Print(), ProcessEvent(), QwHelicity(), and RunPredictor().

Bool_t QwHelicity::fHelicityInfoOK

protected

Definition at line 259 of file QwHelicity.h.

Referenced by QwHelicity().

Int_t QwHelicity::fHelicityReported

protected

Definition at line 201 of file QwHelicity.h.

Referenced by ClearEventData(), CollectRandBits24(), CollectRandBits30(), ConstructBranch(), FillTreeVector(), GetHelicityReported(), IsGoodHelicity(), operator=(), Print(), ProcessEvent(), ProcessEventInputMollerMode(), ProcessEventInputRegisterMode(), ProcessEventUserbitMode(), QwHelicity(), and RunPredictor().

Int_t QwHelicity::fHistoType

protected

Definition at line 212 of file QwHelicity.h.

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

Bool_t QwHelicity::fIgnoreHelicity

protected

Definition at line 262 of file QwHelicity.h.

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

UInt_t QwHelicity::fInputReg_FakeMPS

protected

Definition at line 166 of file QwHelicity.h.

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

Int_t QwHelicity::fMaxPatternPhase

protected

Definition at line 236 of file QwHelicity.h.

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

Int_t QwHelicity::fMinPatternPhase

protected

Definition at line 237 of file QwHelicity.h.

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

Int_t QwHelicity::fNumHelicityErrors

protected

Definition at line 281 of file QwHelicity.h.

Referenced by ClearErrorCounters(), IsGoodHelicity(), PrintErrorCounters(), and QwHelicity().

Int_t QwHelicity::fNumMissedEventBlocks

protected

Definition at line 279 of file QwHelicity.h.

Referenced by ClearErrorCounters(), PrintErrorCounters(), ProcessEventInputMollerMode(), ProcessEventInputRegisterMode(), and QwHelicity().

Int_t QwHelicity::fNumMissedGates

protected

Definition at line 275 of file QwHelicity.h.

Referenced by ClearErrorCounters(), PrintErrorCounters(), ProcessEventInputMollerMode(), ProcessEventInputRegisterMode(), and QwHelicity().

Int_t QwHelicity::fNumMultSyncErrors

protected

Definition at line 280 of file QwHelicity.h.

Referenced by ClearErrorCounters(), PrintErrorCounters(), ProcessEventInputRegisterMode(), and QwHelicity().

Int_t QwHelicity::fPatternNumber

protected

Definition at line 196 of file QwHelicity.h.

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

Int_t QwHelicity::fPatternNumberFirst

protected

Definition at line 268 of file QwHelicity.h.

Referenced by ClearEventData(), PrintErrorCounters(), and QwHelicity().

Int_t QwHelicity::fPatternNumberOld

protected

Definition at line 196 of file QwHelicity.h.

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

Int_t QwHelicity::fPatternPhaseNumber

protected

Definition at line 195 of file QwHelicity.h.

Referenced by QwFakeHelicity::ClearEventData(), ClearEventData(), CollectRandBits24(), CollectRandBits30(), ConstructBranch(), EncodeEventData(), FillHistograms(), FillTreeVector(), GetPhaseNumber(), IsGoodHelicity(), IsGoodPatternNumber(), IsGoodPhaseNumber(), operator=(), Print(), QwFakeHelicity::ProcessEvent(), ProcessEvent(), ProcessEventInputMollerMode(), ProcessEventInputRegisterMode(), ProcessEventUserbitMode(), QwHelicity(), RunPredictor(), and SetEventPatternPhase().

Int_t QwHelicity::fPatternPhaseNumberOld

protected

Definition at line 195 of file QwHelicity.h.

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

Int_t QwHelicity::fPatternPhaseOffset

protected

Definition at line 260 of file QwHelicity.h.

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

Int_t QwHelicity::fPatternSeed

protected

Definition at line 197 of file QwHelicity.h.

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

Int_t QwHelicity::fPreviousPatternPolarity

protected

True polarity of the previous pattern.

Definition at line 200 of file QwHelicity.h.

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

Int_t QwHelicity::fRandBits

protected

Definition at line 257 of file QwHelicity.h.

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

Bool_t QwHelicity::fSuppressMPSErrorMsgs

protected

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

Definition at line 286 of file QwHelicity.h.

Referenced by ProcessEventInputRegisterMode(), and ProcessOptions().

size_t QwHelicity::fTreeArrayIndex

protected

Definition at line 227 of file QwHelicity.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

size_t QwHelicity::fTreeArrayNumEntries

protected

Definition at line 228 of file QwHelicity.h.

Bool_t QwHelicity::fUsePredictor

protected

Definition at line 258 of file QwHelicity.h.

Referenced by ProcessEvent(), ProcessOptions(), QwHelicity(), and SetHelicityDelay().

std::vector<QwWord> QwHelicity::fWord

protected

Definition at line 172 of file QwHelicity.h.

Referenced by QwFakeHelicity::ClearEventData(), ClearEventData(), Compare(), ConstructBranch(), ConstructBranchAndVector(), ConstructHistograms(), FillHistograms(), FillTreeVector(), LoadChannelMap(), operator=(), ProcessEvBuffer(), QwFakeHelicity::ProcessEvent(), ProcessEventInputMollerMode(), ProcessEventInputRegisterMode(), ProcessEventUserbitMode(), and QwHelicity().

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

protected

Definition at line 173 of file QwHelicity.h.

Referenced by LoadChannelMap(), and ProcessEvBuffer().

UInt_t QwHelicity::iseed_Actual

protected

Definition at line 230 of file QwHelicity.h.

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

UInt_t QwHelicity::iseed_Delayed

protected

Definition at line 231 of file QwHelicity.h.

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

const Bool_t QwHelicity::kDEBUG =kFALSE

staticprotected

Definition at line 218 of file QwHelicity.h.

const UInt_t QwHelicity::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 168 of file QwHelicity.h.

Referenced by BuildHelicityBitPattern(), and ProcessOptions().

UInt_t QwHelicity::kEventTypeHelMinus

protected

Definition at line 192 of file QwHelicity.h.

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

UInt_t QwHelicity::kEventTypeHelPlus

protected

Definition at line 192 of file QwHelicity.h.

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

const UInt_t QwHelicity::kInputReg_FakeMPS = 0x8000

staticprotected

Default mask for fake MPS latch bit.

Definition at line 165 of file QwHelicity.h.

Referenced by QwHelicity().

Int_t QwHelicity::kInputRegister

protected

Definition at line 190 of file QwHelicity.h.

Referenced by LoadChannelMap(), and ProcessEventInputRegisterMode().

Int_t QwHelicity::kMpsCounter

protected

Definition at line 190 of file QwHelicity.h.

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

Int_t QwHelicity::kPatternCounter

protected

Definition at line 190 of file QwHelicity.h.

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

Int_t QwHelicity::kPatternPhase

protected

Definition at line 190 of file QwHelicity.h.

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

Int_t QwHelicity::kScalerCounter

protected

Definition at line 186 of file QwHelicity.h.

Referenced by LoadChannelMap(), and ProcessEventUserbitMode().

const Int_t QwHelicity::kUndefinedHelicity = -9999

staticprotected

Definition at line 223 of file QwHelicity.h.

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

Int_t QwHelicity::kUserbit

protected

Definition at line 182 of file QwHelicity.h.

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

UInt_t QwHelicity::n_ranbits

protected

Definition at line 229 of file QwHelicity.h.

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

---

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

• QwHelicity.h
• QwHelicity.cc