QwBlinder Class Reference

Data blinding utilities for parity violation analysis. More...

#include <QwBlinder.h>

Collaboration diagram for QwBlinder:

Public Types
enum	EQwBlindingStrategy { kDisabled , kAdditive , kMultiplicative , kAdditiveMultiplicative }
	Available blinding strategies. More...
enum	EQwBlinderStatus { kIndeterminate = 0 , kNotBlindable , kBlindable , kBlindableFail }
	Status of the blinding process or intermediate steps of the process. More...

Public Member Functions
	QwBlinder (const EQwBlindingStrategy blinding_strategy=kAdditive)
	Default constructor with optional database.
virtual	~QwBlinder ()
	Default destructor.
void	ProcessOptions (QwOptions &options)
	Update the status with new external information.
void	Update ()
	Update the status using a random number.
void	Update (QwParityDB *db)
	Update the status with new external information.
void	Update (const QwSubsystemArrayParity &detectors)
	Update the status with new external information.
void	Update (const QwEPICSEvent &epics)
	Update the status with new external information.
void	ClearEventData ()
void	WriteFinalValuesToDB (QwParityDB *db)
void	PrintCountersValues (std::vector< Int_t > fCounters, TString counter_type)
void	PrintFinalValues (Int_t kVerbosity=1)
void	ModifyThisErrorCode (UInt_t &errorcode) const
void	BlindValue (Double_t &value) const
	Asymmetry blinding.
void	UnBlindValue (Double_t &value) const
	Asymmetry unblinding.
void	BlindValue (Double_t &value, const Double_t &yield) const
	Difference blinding.
void	UnBlindValue (Double_t &value, const Double_t &yield) const
	Difference unblinding.
void	Blind (QwSubsystemArrayParity &diff)
	Blind the asymmetry of an array of subsystems.
void	BlindPair (QwSubsystemArrayParity &diff)
void	UnBlind (QwSubsystemArrayParity &diff)
	Unblind the asymmetry of an array of subsystems.
void	Blind (QwSubsystemArrayParity &diff, const QwSubsystemArrayParity &yield)
	Blind the difference of an array of subsystems.
void	BlindPair (QwSubsystemArrayParity &diff, const QwSubsystemArrayParity &yield)
	Blind the pair difference of an array of subsystems.
void	UnBlind (QwSubsystemArrayParity &diff, const QwSubsystemArrayParity &yield)
	Unblind the difference of an array of subsystems.
const Bool_t &	IsBlinderOkay () const
void	ConstructObjects (TDirectory *folder, TString &prefix)

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

Static Public Attributes
static const TString	fStatusName [4]
static const UInt_t	kErrorFlag_BlinderFail = 0x200
	Error flag value.
static constexpr const Double_t	kValue_BlinderFail = -1.0

Private Member Functions
void	SetTargetBlindability (EQwBlinderStatus status)
	Set the current target blindability status.
void	SetWienState (EQwWienMode wienmode)
void	SetIHWPPolarity (Int_t ihwppolarity)
EQwBlinderStatus	CheckBlindability (std::vector< Int_t > &fCounters)
	QwBlinder (const QwBlinder &__attribute__((unused)) blinder)
	Private copy constructor.
const QwBlinder &	operator= (const QwBlinder &__attribute__((unused)) blinder)
	Private assignment operator.
void	InitBlinders (const UInt_t seed_id)
	Vector of test values, after unblinding.
void	InitTestValues (const int n)
	Initializes fBlindingFactor from fSeed.
Bool_t	CheckTestValues ()
Int_t	UseMD5 (const TString &barestring)
	Recomputes fBlindTestValue to check for memory errors.
Int_t	UseStringManip (const TString &barestring)
	Returns an integer from a string using MD5.
Int_t	UsePseudorandom (const TString &barestring)
Int_t	ReadSeed (QwParityDB *db, const UInt_t seed_id)
	Reads the seed with specified id from the database object.
Int_t	ReadSeed (QwParityDB *db)
	Reads the seed from the database object.
Int_t	ReadRandomSeed ()
	Read the seed string generated utilizing a random number generator.
void	WriteChecksum (QwParityDB *db)
void	WriteTestValues (QwParityDB *db)
	Writes fSeedID and fBFChecksum to DB for this analysis ID.
std::vector< UChar_t >	GenerateDigest (const TString &input) const
	Writes fTestNumber and fBlindTestValue to DB for this analysis ID.

Private Attributes
EQwBlinderStatus	fTargetBlindability_firstread
	Indicates the first value received of the blindability of the target.
EQwBlinderStatus	fTargetBlindability
Bool_t	fTargetPositionForced
EQwWienMode	fWienMode_firstread
EQwWienMode	fWienMode
Int_t	fIHWPPolarity_firstread
Int_t	fIHWPPolarity
Bool_t	fSpinDirectionForced
Int_t	fCREXTargetIndex
Int_t	kCREXTgtIndexMin = 1
Int_t	kCREXTgtIndexMax = 2
Double_t	fBeamCurrentThreshold
Bool_t	fBeamIsPresent
Bool_t	fBlinderIsOkay
EQwBlindingStrategy	fBlindingStrategy
Double_t	fBlindingOffset
	Blinding strategy.
Double_t	fBlindingOffset_Base
	The term to be added to detector asymmetries.
Double_t	fBlindingFactor
	The term to be added to detector asymmetries, before polarity correction.
Double_t	fMaximumBlindingAsymmetry
	Default maximum blinding factor (in fraction from identity)
Double_t	fMaximumBlindingFactor
	Maximum blinding asymmetry (in ppm)
UInt_t	fSeedID
	Maximum blinding factor (in fraction from identity)
TString	fSeed
	ID of seed used (seeds.seed_id)
std::vector< UChar_t >	fDigest
	Default seed.
std::string	fChecksum
	Checksum in raw hex.
std::vector< double >	fTestValues
	Checksum in ASCII hex.
std::vector< double >	fBlindTestValues
	Vector of test values, original.
std::vector< double >	fUnBlindTestValues
	Vector of test values, after blinding.
std::vector< Int_t >	fPatternCounters
	Counts the number of events in each failure mode.
std::vector< Int_t >	fPairCounters
	Counts the number of helicity pairs in each failure mode.

Static Private Attributes
static const Double_t	kDefaultMaximumBlindingAsymmetry = 0.150
	The factor to be multiplied to detector asymmetries.
static const Double_t	kDefaultMaximumBlindingFactor = 0.0
	Default maximum blinding asymmetry (in ppm)
static const TString	kDefaultSeed = "Default seed, should not be used!"
	Seed string (seeds.seed)

Detailed Description

Data blinding utilities for parity violation analysis.

Implements cryptographic data blinding to prevent bias in parity violation measurements. Supports multiple blinding strategies (additive, multiplicative, or combined) with encrypted offsets and factors. Provides both asymmetry and difference blinding schemes to maintain analysis integrity while preserving statistical properties of the data.

Definition at line 57 of file QwBlinder.h.

Member Enumeration Documentation

EQwBlinderStatus

enum QwBlinder::EQwBlinderStatus

Status of the blinding process or intermediate steps of the process.

Enumerator
kIndeterminate
kNotBlindable
kBlindable
kBlindableFail

Definition at line 69 of file QwBlinder.h.

                        {
    kIndeterminate = 0,
    kNotBlindable,
    kBlindable,
    kBlindableFail
  };

EQwBlindingStrategy

enum QwBlinder::EQwBlindingStrategy

Available blinding strategies.

Enumerator
kDisabled
kAdditive
kMultiplicative
kAdditiveMultiplicative

Definition at line 62 of file QwBlinder.h.

                           {
    kDisabled,
    kAdditive,
    kMultiplicative,
    kAdditiveMultiplicative
  };

Constructor & Destructor Documentation

QwBlinder() [1/2]

QwBlinder::QwBlinder

(

const EQwBlindingStrategy

blinding_strategy = kAdditive

)

Default constructor with optional database.

Default constructor using optional database connection and blinding strategy

Parameters

blinding_strategy

Blinding strategy

Definition at line 83 of file QwBlinder.cc.

                                                               :
  fTargetBlindability_firstread(kIndeterminate),
  fTargetBlindability(kIndeterminate),
  fTargetPositionForced(kFALSE),
  //
  fWienMode_firstread(kWienIndeterminate),
  fWienMode(kWienIndeterminate),
  fIHWPPolarity_firstread(0),
  fIHWPPolarity(0),
  fSpinDirectionForced(kFALSE),
  //
  fBeamCurrentThreshold(1.0),
  fBeamIsPresent(kFALSE),
  fBlindingStrategy(blinding_strategy),
  fBlindingOffset(0.0),
  fBlindingOffset_Base(0.0),
  fBlindingFactor(1.0),
  //
  fMaximumBlindingAsymmetry(kDefaultMaximumBlindingAsymmetry),
  fMaximumBlindingFactor(kDefaultMaximumBlindingFactor)
{
  // Set up the blinder with seed_id 0
  fSeed = kDefaultSeed;
  fSeedID = 0;
 
  fCREXTargetIndex  = -1;
 
  Int_t tgt_index;
 
  // Read parameter file
  QwParameterFile blinder("blinder.map");
  if (blinder.FileHasVariablePair("=", "seed", fSeed))
    QwVerbose << "Using seed from file: " << fSeed << QwLog::endl;
  if (blinder.FileHasVariablePair("=", "max_asymmetry", fMaximumBlindingAsymmetry))
    QwVerbose << "Using blinding box: " << fMaximumBlindingAsymmetry << " ppm" << QwLog::endl;
  if (blinder.FileHasVariablePair("=", "max_factor", fMaximumBlindingFactor))
    QwVerbose << "Using blinding factor: " << fMaximumBlindingFactor << QwLog::endl;
  if (blinder.FileHasVariablePair("=", "crex_target_index", tgt_index)){
    if (tgt_index>=kCREXTgtIndexMin && tgt_index<=kCREXTgtIndexMax){
      fCREXTargetIndex = tgt_index;
    } else {
      QwError << "Invalid CREX target index for blindable events!  Exiting!"
          << QwLog::endl;
      exit(100);
    }
  }
  QwMessage << "What is the blindable CREX target position (-1 means we're using the PREX positions)? " << fCREXTargetIndex << QwLog::endl;
  if (fCREXTargetIndex>=kCREXTgtIndexMin){
    fSeed.Prepend(TString("[Using CREX positions!]  "));
    QwMessage << "Updated the seed string: " << fSeed << QwLog::endl;
  }
  std::string strategy;
  if (blinder.FileHasVariablePair("=", "strategy", strategy)) {
    std::transform(strategy.begin(), strategy.end(), strategy.begin(), ::tolower);
    QwVerbose << "Using blinding strategy from file: " << strategy << QwLog::endl;
    if (strategy == "disabled") fBlindingStrategy = kDisabled;
    else if (strategy == "additive") fBlindingStrategy = kAdditive;
    else if (strategy == "multiplicative") fBlindingStrategy = kMultiplicative;
    else if (strategy == "additivemultiplicative") fBlindingStrategy = kAdditiveMultiplicative;
    else QwWarning << "Blinding strategy " << strategy << " not recognized" << QwLog::endl;
  }
 
  std::string spin_direction;
  if (blinder.FileHasVariablePair("=", "force-spin-direction", spin_direction)) {
    std::transform(spin_direction.begin(), spin_direction.end(), spin_direction.begin(), ::tolower);
    if (spin_direction == "spin-forward"){
      QwWarning << "QwBlinder::QwBlinder:  Spin direction forced with force-spin-direction==spin-forward" << QwLog::endl;
      SetWienState(kWienForward);
      SetIHWPPolarity(+1);
      fSpinDirectionForced = kTRUE;
    } else if (spin_direction == "spin-backward"){
      QwWarning << "QwBlinder::QwBlinder:  Spin direction forced with force-spin-direction==spin-backward" << QwLog::endl;
      SetWienState(kWienBackward);
      SetIHWPPolarity(+1);
      fSpinDirectionForced = kTRUE;
    } else if (spin_direction == "spin-vertical"){
      QwWarning << "QwBlinder::QwBlinder:  Spin direction forced with force-spin-direction==spin-vertical" << QwLog::endl;
      SetWienState(kWienVertTrans);
      SetIHWPPolarity(+1);
      fSpinDirectionForced = kTRUE;
    } else if (spin_direction == "spin-horizontal"){
      QwWarning << "QwBlinder::QwBlinder:  Spin direction forced with force-spin-direction==spin-horizontal" << QwLog::endl;
      SetWienState(kWienHorizTrans);
      SetIHWPPolarity(+1);
      fSpinDirectionForced = kTRUE;
    } else {
      QwError << "QwBlinder::QwBlinder:  Unrecognized option given to force-spin-direction in blinder.map; "
          << "force-spin-direction==" << spin_direction << ".  Exit and correct the file."
          << QwLog::endl;
      exit(10);
    }
  }
 
  std::string target_type;
  if (blinder.FileHasVariablePair("=", "force-target-type", target_type)) {
    std::transform(target_type.begin(), target_type.end(), target_type.begin(), ::tolower);
    if (target_type == "target-blindable"){
      QwWarning << "QwBlinder::QwBlinder:  Target position forced with force-target-type==target-blindable" << QwLog::endl;
      fTargetPositionForced = kTRUE;
      SetTargetBlindability(QwBlinder::kBlindable);
    } else if (target_type == "target-out"){
      QwWarning << "QwBlinder::QwBlinder:  Target position forced with force-target-type==target-out" << QwLog::endl;
      fTargetPositionForced = kTRUE;
      SetTargetBlindability(QwBlinder::kNotBlindable);
    } else {
      QwError << "QwBlinder::QwBlinder:  Unrecognized option given to force-target-type in blinder.map; "
          << "force-target-type==" << target_type << ".  Exit and correct the file."
          << QwLog::endl;
      exit(10);
    }
  }
 
  // Initialize blinder from seed
  InitBlinders(0);
  // Calculate set of test values
  InitTestValues(10);
 
  if (fSpinDirectionForced){
    if (fWienMode == kWienForward){
      fBlindingOffset = fBlindingOffset_Base;
    } else if (fWienMode == kWienBackward){
      fBlindingOffset = -1 * fBlindingOffset_Base;
    } else {
      fBlindingOffset = 0.0;
    }
  }
 
  // Resize counters
  fPatternCounters.resize(kBlinderCount_NumCounters);
  fPairCounters.resize(kBlinderCount_NumCounters);
}

References QwLog::endl(), fBeamCurrentThreshold, fBeamIsPresent, fBlindingFactor, fBlindingOffset, fBlindingOffset_Base, fBlindingStrategy, fCREXTargetIndex, fIHWPPolarity, fIHWPPolarity_firstread, QwParameterFile::FileHasVariablePair(), fMaximumBlindingAsymmetry, fMaximumBlindingFactor, fPairCounters, fPatternCounters, fSeed, fSeedID, fSpinDirectionForced, fTargetBlindability, fTargetBlindability_firstread, fTargetPositionForced, fWienMode, fWienMode_firstread, InitBlinders(), InitTestValues(), kAdditive, kAdditiveMultiplicative, kBlindable, kBlinderCount_NumCounters, kCREXTgtIndexMax, kCREXTgtIndexMin, kDefaultMaximumBlindingAsymmetry, kDefaultMaximumBlindingFactor, kDefaultSeed, kDisabled, kIndeterminate, kMultiplicative, kNotBlindable, kWienBackward, kWienForward, kWienHorizTrans, kWienIndeterminate, kWienVertTrans, QwError, QwMessage, QwVerbose, QwWarning, SetIHWPPolarity(), SetTargetBlindability(), and SetWienState().

Referenced by operator=(), and QwBlinder().

Here is the call graph for this function:

Here is the caller graph for this function:

~QwBlinder()

QwBlinder::~QwBlinder ( )

virtual

Default destructor.

Destructor checks the validity of the blinding and unblinding

Definition at line 219 of file QwBlinder.cc.

{
  // Check the blinded values
  PrintFinalValues();
}

References PrintFinalValues().

Here is the call graph for this function:

QwBlinder() [2/2]

QwBlinder::QwBlinder ( const QwBlinder &__attribute__((unused)) blinder )

inlineprivate

Private copy constructor.

Definition at line 258 of file QwBlinder.h.

: fBlindingStrategy(kDisabled) { };

References fBlindingStrategy, kDisabled, and QwBlinder().

Here is the call graph for this function:

Member Function Documentation

Blind() [1/2]

void QwBlinder::Blind ( QwSubsystemArrayParity & diff )

inline

Blind the asymmetry of an array of subsystems.

Definition at line 174 of file QwBlinder.h.

                                              {
      if (CheckBlindability(fPatternCounters)!=kNotBlindable)
    diff.Blind(this);
    };

References QwSubsystemArrayParity::Blind(), CheckBlindability(), fPatternCounters, and kNotBlindable.

Here is the call graph for this function:

Blind() [2/2]

void QwBlinder::Blind ( QwSubsystemArrayParity & diff, const QwSubsystemArrayParity & yield )

inline

Blind the difference of an array of subsystems.

Definition at line 191 of file QwBlinder.h.

                                                                                   {
      if (CheckBlindability(fPatternCounters)!=kNotBlindable)
    diff.Blind(this, yield);
    };

References QwSubsystemArrayParity::Blind(), CheckBlindability(), fPatternCounters, and kNotBlindable.

Here is the call graph for this function:

BlindPair() [1/2]

void QwBlinder::BlindPair ( QwSubsystemArrayParity & diff )

inline

Blind the pair asymmetry and only check fBlindingStrategy to avoid overcounting fPatternCounters

Definition at line 180 of file QwBlinder.h.

                                                  {
      if (CheckBlindability(fPairCounters)!=kNotBlindable)
    diff.Blind(this);
    };

References QwSubsystemArrayParity::Blind(), CheckBlindability(), fPairCounters, and kNotBlindable.

Here is the call graph for this function:

BlindPair() [2/2]

void QwBlinder::BlindPair ( QwSubsystemArrayParity & diff, const QwSubsystemArrayParity & yield )

inline

Blind the pair difference of an array of subsystems.

Definition at line 196 of file QwBlinder.h.

                                                                                       {
      if (CheckBlindability(fPairCounters)!=kNotBlindable)
    diff.Blind(this, yield);
    };

References QwSubsystemArrayParity::Blind(), CheckBlindability(), fPairCounters, and kNotBlindable.

Here is the call graph for this function:

BlindValue() [1/2]

void QwBlinder::BlindValue ( Double_t & value ) const

inline

Asymmetry blinding.

Definition at line 124 of file QwBlinder.h.

                                            {
      switch (fBlindingStrategy) {
        case kAdditive:
          value += fBlindingOffset; break;
        case kMultiplicative:
          value *= fBlindingFactor; break;
        case kAdditiveMultiplicative:
          value = (value + fBlindingOffset) * fBlindingFactor; break;
        default: break;
      }
    };

References fBlindingFactor, fBlindingOffset, fBlindingStrategy, kAdditive, kAdditiveMultiplicative, and kMultiplicative.

Referenced by QwADC18_Channel::Blind(), QwADC18_Channel::Blind(), QwMollerADC_Channel::Blind(), QwMollerADC_Channel::Blind(), QwVQWK_Channel::Blind(), QwVQWK_Channel::Blind(), and InitTestValues().

Here is the caller graph for this function:

BlindValue() [2/2]

void QwBlinder::BlindValue ( Double_t & value, const Double_t & yield ) const

inline

Difference blinding.

Definition at line 149 of file QwBlinder.h.

                                                                   {
      switch (fBlindingStrategy) {
      case kAdditive:
    value += yield * fBlindingOffset; break;
      case kMultiplicative:
    value *= fBlindingFactor; break;
      case kAdditiveMultiplicative:
    value = (value + fBlindingOffset * yield) * fBlindingFactor; break;
      default: break;
      }
    };

References fBlindingFactor, fBlindingOffset, fBlindingStrategy, kAdditive, kAdditiveMultiplicative, and kMultiplicative.

CheckBlindability()

QwBlinder::EQwBlinderStatus QwBlinder::CheckBlindability ( std::vector< Int_t > & fCounters )

private

Definition at line 1298 of file QwBlinder.cc.

{
  EQwBlinderStatus status = QwBlinder::kBlindableFail;
  if (fBlindingStrategy == kDisabled) {
    status = QwBlinder::kNotBlindable;
    fCounters.at(kBlinderCount_Disabled)++;
  } else if (fTargetBlindability == QwBlinder::kIndeterminate) {
    QwDebug  << "QwBlinder::CheckBlindability:  The target blindability is not determined.  "
         << "Fail this pattern." << QwLog::endl;
    status = QwBlinder::kBlindableFail;
    fCounters.at(kBlinderCount_UnknownTarget)++;
  } else if (fTargetBlindability!=fTargetBlindability_firstread
         && !fTargetPositionForced) {
    QwDebug << "QwBlinder::CheckBlindability:  The target blindability has changed.  "
        << "Fail this pattern." << QwLog::endl;
    status = QwBlinder::kBlindableFail;
    fCounters.at(kBlinderCount_ChangedTarget)++;
  } else if (fTargetBlindability==kNotBlindable) {
    //  This isn't a blindable target, so don't do anything.
    status = QwBlinder::kNotBlindable;
    fCounters.at(kBlinderCount_NonBlindable)++;
  } else if (fTargetBlindability==kBlindable &&
         fWienMode != fWienMode_firstread) {
    //  Wien status changed.  Fail
    status = QwBlinder::kBlindableFail;
    fCounters.at(kBlinderCount_ChangedWien)++;
  } else if (fTargetBlindability==kBlindable &&
         fIHWPPolarity != fIHWPPolarity_firstread) {
    //  IHWP status changed.  Fail
    status = QwBlinder::kBlindableFail;
    fCounters.at(kBlinderCount_ChangedIHWP)++;
  } else if (fTargetBlindability==kBlindable &&
         fWienMode == kWienIndeterminate) {
    //  Wien status isn't determined.  Fail.
    status = QwBlinder::kBlindableFail;
    fCounters.at(kBlinderCount_UndefinedWien)++;
  } else if (fTargetBlindability==kBlindable &&
         fIHWPPolarity==0) {
    //  IHWP status isn't determined.  Fail.
    status = QwBlinder::kBlindableFail;
    fCounters.at(kBlinderCount_UndefinedIHWP)++;
  } else if (fTargetBlindability==kBlindable &&
        (fWienMode == kWienVertTrans || fWienMode == kWienHorizTrans)) {
    //  We don't have longitudinal beam, so don't blind.
    status = QwBlinder::kNotBlindable;
    fCounters.at(kBlinderCount_Transverse)++;
  } else if (fTargetBlindability==kBlindable
         && fBeamIsPresent) {
    //  This is a blindable target and the beam is sufficient.
    status = QwBlinder::kBlindable;
    fCounters.at(kBlinderCount_Blindable)++;
  } else if (fTargetBlindability==kBlindable
         && (! fBeamIsPresent) ) {
    //  This is a blindable target but there is insufficient beam present
    status = QwBlinder::kNotBlindable;
    fCounters.at(kBlinderCount_NoBeam)++;
  } else {
    QwError << "QwBlinder::CheckBlindability:  The pattern blindability is unclear.  "
         << "Fail this pattern." << QwLog::endl;
    status = QwBlinder::kBlindableFail;
    fCounters.at(kBlinderCount_OtherFailure)++;
  }
  //
  fBlinderIsOkay = (status != QwBlinder::kBlindableFail);
 
  return status;
}

References QwLog::endl(), fBeamIsPresent, fBlinderIsOkay, fBlindingStrategy, fIHWPPolarity, fIHWPPolarity_firstread, fTargetBlindability, fTargetBlindability_firstread, fTargetPositionForced, fWienMode, fWienMode_firstread, kBlindable, kBlindableFail, kBlinderCount_Blindable, kBlinderCount_ChangedIHWP, kBlinderCount_ChangedTarget, kBlinderCount_ChangedWien, kBlinderCount_Disabled, kBlinderCount_NoBeam, kBlinderCount_NonBlindable, kBlinderCount_OtherFailure, kBlinderCount_Transverse, kBlinderCount_UndefinedIHWP, kBlinderCount_UndefinedWien, kBlinderCount_UnknownTarget, kDisabled, kIndeterminate, kNotBlindable, kWienHorizTrans, kWienIndeterminate, kWienVertTrans, QwDebug, and QwError.

Referenced by Blind(), Blind(), BlindPair(), and BlindPair().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckTestValues()

Bool_t QwBlinder::CheckTestValues ( )

private

Initializes the test values: fTestNumber, fTestValue, fBlindTestValue, if fBlindingFactor is set.

--------------------------------------------------------—

Function to write the checksum into the analysis table

Parameters: void

Return: void

Note: This function assumes that the analysis table has already

been filled for the run.

---

---

This routines checks to see if the stored fBlindTestValues[i] match a recomputed blinded test value. The values are cast into floats, and their difference must be less than a change

of the least-significant-bit of fBlindTestValues[i].

First test: compare a blinded value with a second computation

Second test: compare the unblinded value with the original value

Definition at line 1017 of file QwBlinder.cc.

{
  Bool_t status = kTRUE;
 
  Double_t tmp_offset = fBlindingOffset;
  fBlindingOffset = fBlindingOffset_Base;
  double epsilon = std::numeric_limits<double>::epsilon();
  for (size_t i = 0; i < fTestValues.size(); i++) {
 
    /// First test: compare a blinded value with a second computation
    double checkval = fBlindTestValues[i];
    UnBlindValue(checkval);
 
    double test1 = fTestValues[i];
    double test2 = checkval;
    if ((test1 - test2) <= -epsilon || (test1 - test2) >= epsilon) {
      QwError << "QwBlinder::CheckTestValues():  Unblinded test value "
              << i
              << " does not agree with original test value, "
              << "with a difference of "
              << (test1 - test2)
          << " (epsilon==" << epsilon << ")"
          << "." << QwLog::endl;
      status = kFALSE;
    }
 
    /// Second test: compare the unblinded value with the original value
    test1 = fUnBlindTestValues[i];
    test2 = fTestValues[i];
    if ((test1 - test2) <= -epsilon || (test1 - test2) >= epsilon) {
      QwError << "QwBlinder::CheckTestValues():  Unblinded test value "
              << i
              << " does not agree with original test value, "
              << "with a difference of "
              << (test1 - test2) << "." << QwLog::endl;
      status = kFALSE;
    }
  }
  fBlindingOffset = tmp_offset;
  return status;
}

References QwLog::endl(), fBlindingOffset, fBlindingOffset_Base, fBlindTestValues, fTestValues, fUnBlindTestValues, QwError, and UnBlindValue().

Referenced by PrintFinalValues().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearEventData()

void QwBlinder::ClearEventData ( )

inline

Definition at line 101 of file QwBlinder.h.

                         {
      fBeamIsPresent = kTRUE;
    };

References fBeamIsPresent.

ConstructObjects()

void QwBlinder::ConstructObjects ( TDirectory * folder, TString & prefix )

inline

Definition at line 208 of file QwBlinder.h.

                                                               {
      if (folder != NULL) folder->cd();
      const TObjString* seed = new TObjString(fSeed);
      folder->WriteTObject(seed, prefix + "seed", "WriteDelete");
      const TObjString* seedID = new TObjString(Form("%u",fSeedID));
      folder->WriteTObject(seedID, prefix + "seedID", "WriteDelete");
      const TObjString* strategy = new TObjString(Form("%u", fBlindingStrategy));
      folder->WriteTObject(strategy, prefix + "strategy", "WriteDelete");
      const TObjString* max_asymmetry = new TObjString(Form("%f",fMaximumBlindingAsymmetry));
      folder->WriteTObject(max_asymmetry, prefix + "max_asymmetry", "WriteDelete");
      const TObjString* max_factor = new TObjString(Form("%f",fMaximumBlindingFactor));
      folder->WriteTObject(max_factor, prefix + "max_factor", "WriteDelete");
      const TObjString* checksum = new TObjString(fChecksum.c_str());
      folder->WriteTObject(checksum, prefix + "checksum", "WriteDelete");
    };

References fBlindingStrategy, fChecksum, fMaximumBlindingAsymmetry, fMaximumBlindingFactor, fSeed, and fSeedID.

DefineOptions()

void QwBlinder::DefineOptions ( QwOptions & options )

static

Definition at line 69 of file QwBlinder.cc.

                                               {
  options.AddOptions("Blinder")("blinder.force-target-blindable", po::value<bool>()->default_bool_value(false),
               "Forces the blinder to interpret the target as being in a blindable position");
  options.AddOptions("Blinder")("blinder.force-target-out", po::value<bool>()->default_bool_value(false),
               "Forces the blinder to interpret the target position as target-out");
  options.AddOptions("Blinder")("blinder.beam-current-threshold", po::value<double>()->default_value(2.5),
               "Beam current in microamps below which data will not be blinded");
}

References QwOptions::AddOptions().

Referenced by QwHelicityPattern::DefineOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateDigest()

std::vector< UChar_t > QwBlinder::GenerateDigest ( const TString & input ) const

private

Writes fTestNumber and fBlindTestValue to DB for this analysis ID.

Generate an MD5 digest of the blinding parameters

Parameters

input

Input string

Returns

MD5 digest of the input string

Definition at line 1065 of file QwBlinder.cc.

{
  // Initialize MD5 checksum array
  const UInt_t length = 16;
  UChar_t value[length];
  for (UInt_t i = 0; i < length; i++)
    value[i] = 0;
 
  // Calculate MD5 checksum from input and store in md5_value
  TMD5 md5;
  md5.Update((UChar_t*) input.Data(), input.Length());
  md5.Final(value);
 
  // Copy the MD5 checksum in an STL vector
  std::vector<UChar_t> output;
  for (UInt_t i = 0; i < length; i++)
    output.push_back(value[i]);
 
  return output;
}

Referenced by InitBlinders(), and UseMD5().

Here is the caller graph for this function:

InitBlinders()

void QwBlinder::InitBlinders ( const UInt_t seed_id )

private

Vector of test values, after unblinding.

--------------------------------------------------------—

Function to read the seed in from the database.

Parameters: seed_id = ID number of seed to use (0 = most recent seed)

Return: Int_t

---

---

Initialize the blinder parameters

The blinding constants are determined in two steps.

First, the blinding asymmetry (offset) is determined. It is generated from a signed number between +/- 0.244948974 that is squared to get a number between +/- 0.06 ppm.

Secondly, the multiplicative blinding factor is determined. This number is generated from the blinding asymmetry between, say, 0.9 and 1.1 by an oscillating but uniformly distributed sawtooth function.

TODO: This section of InitBlinders doesn't calculate a reasonable fBlindingFactor but we don't use it for anything.

Definition at line 667 of file QwBlinder.cc.

{
  // If the blinding strategy is disabled
  if (fBlindingStrategy == kDisabled) {
 
      fSeed = kDefaultSeed;
      fSeedID = 0;
      fBlindingFactor = 1.0;
      fBlindingOffset = 0.0;
      fBlindingOffset_Base = 0.0;
      QwWarning << "Blinding parameters have been disabled!"<< QwLog::endl;
 
  // Else blinding is enabled
  } else {
 
    Int_t finalseed = UseMD5(fSeed);
 
    Double_t newtempout;
    if ((finalseed & 0x80000000) == 0x80000000) {
      newtempout = -1.0 * (finalseed & 0x7FFFFFFF);
    } else {
      newtempout =  1.0 * (finalseed & 0x7FFFFFFF);
    }
 
 
    /// The blinding constants are determined in two steps.
    ///
    /// First, the blinding asymmetry (offset) is determined.  It is
    /// generated from a signed number between +/- 0.244948974 that
    /// is squared to get a number between +/- 0.06 ppm.
    static Double_t maximum_asymmetry_sqrt = sqrt(fMaximumBlindingAsymmetry);
    Double_t tmp1 = maximum_asymmetry_sqrt * (newtempout / Int_t(0x7FFFFFFF));
    fBlindingOffset = tmp1 * fabs(tmp1) * 0.000001;
 
    //  Do another little calculation to round off the blinding asymmetry
    Double_t tmp2;
    tmp1 = fBlindingOffset * 4;    // Exactly shifts by two binary places
    tmp2 = tmp1 + fBlindingOffset; // Rounds 5*fBlindingOffset
    fBlindingOffset = tmp2 - tmp1; // fBlindingOffset has been rounded.
 
    //  Set the base blinding offset.
    fBlindingOffset_Base = fBlindingOffset;
 
    /// Secondly, the multiplicative blinding factor is determined.  This
    /// number is generated from the blinding asymmetry between, say, 0.9 and 1.1
    /// by an oscillating but uniformly distributed sawtooth function.
    fBlindingFactor = 1.0;
    if (fMaximumBlindingAsymmetry > 0.0) {
      /// TODO:  This section of InitBlinders doesn't calculate a reasonable fBlindingFactor but we don't use it for anything.
      fBlindingFactor  = 1.0 + fmod(30.0 * fBlindingOffset, fMaximumBlindingAsymmetry);
      fBlindingFactor /= (fMaximumBlindingAsymmetry > 0.0 ? fMaximumBlindingAsymmetry : 1.0);
    }
 
    QwMessage << "Blinding parameters have been calculated."<< QwLog::endl;
 
  }
 
  // Generate checksum
#if __cplusplus < 202002L
  ULong64_t factor_bits, offset_bits;
  memcpy(&factor_bits, &fBlindingFactor, sizeof(ULong64_t));
  memcpy(&offset_bits, &fBlindingOffset, sizeof(ULong64_t));
#else
  auto factor_bits = std::bit_cast<ULong64_t>(fBlindingFactor);
  auto offset_bits = std::bit_cast<ULong64_t>(fBlindingOffset);
#endif
  TString hex_string;
  hex_string.Form("%.16llx%.16llx", factor_bits, offset_bits);
  fDigest = GenerateDigest(hex_string);
  fChecksum = "";
  for (size_t i = 0; i < fDigest.size(); i++)
    fChecksum += string(Form("%.2x",fDigest[i]));
}

References QwLog::endl(), fBlindingFactor, fBlindingOffset, fBlindingOffset_Base, fBlindingStrategy, fChecksum, fDigest, fMaximumBlindingAsymmetry, fSeed, fSeedID, GenerateDigest(), kDefaultSeed, kDisabled, QwMessage, QwWarning, and UseMD5().

Referenced by QwBlinder(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

InitTestValues()

void QwBlinder::InitTestValues ( const int n )

private

Initializes fBlindingFactor from fSeed.

Generate a set of test values of similar size as measured asymmetries

Parameters

n	Number of test values

Definition at line 759 of file QwBlinder.cc.

{
  // Use the stored seed to get a pseudorandom number
  Int_t finalseed = UsePseudorandom(fSeed);
 
  fTestValues.clear();
  fBlindTestValues.clear();
  fUnBlindTestValues.clear();
 
  Double_t tmp_offset = fBlindingOffset;
  fBlindingOffset = fBlindingOffset_Base;
  // For each test case
  for (int i = 0; i < n; i++) {
 
    // Generate a pseudorandom number
    for (Int_t j = 0; j < 16; j++) {
      finalseed &= 0x7FFFFFFF;
      if ((finalseed & 0x800000) == 0x800000) {
        finalseed = ((finalseed ^ 0x00000d) << 1) | 0x1;
      } else {
        finalseed <<= 1;
      }
    }
 
    // Mask out the low digits of the finalseed, multiply by two,
    // divide by the mask value, subtract from 1, and divide result by
    // 1.0e6 to get a range of about -1000 to +1000 ppb.
    Int_t mask = 0xFFFFFF;
    Double_t tempval = (1.0 - 2.0*(finalseed&mask)/mask) / (1.0e6);
 
    // Store the test values
    fTestValues.push_back(tempval);
    BlindValue(tempval);
    fBlindTestValues.push_back(tempval);
    UnBlindValue(tempval);
    fUnBlindTestValues.push_back(tempval);
  }
  fBlindingOffset = tmp_offset;
  QwMessage << "QwBlinder::InitTestValues(): A total of " << fTestValues.size()
            << " test values have been calculated successfully." << QwLog::endl;
}

References BlindValue(), QwLog::endl(), fBlindingOffset, fBlindingOffset_Base, fBlindTestValues, fSeed, fTestValues, fUnBlindTestValues, QwMessage, UnBlindValue(), and UsePseudorandom().

Referenced by QwBlinder(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

IsBlinderOkay()

const Bool_t & QwBlinder::IsBlinderOkay ( ) const

inline

Definition at line 206 of file QwBlinder.h.

{return fBlinderIsOkay;};

References fBlinderIsOkay.

Referenced by QwADC18_Channel::Blind(), QwADC18_Channel::Blind(), QwMollerADC_Channel::Blind(), QwMollerADC_Channel::Blind(), QwVQWK_Channel::Blind(), and QwVQWK_Channel::Blind().

Here is the caller graph for this function:

ModifyThisErrorCode()

void QwBlinder::ModifyThisErrorCode ( UInt_t & errorcode ) const

inline

Modifies the device error code variable passed to it, if the blinder is not okay.

Definition at line 119 of file QwBlinder.h.

                                                      {
      errorcode |= kErrorFlag_BlinderFail;
    };

References kErrorFlag_BlinderFail.

Referenced by QwADC18_Channel::Blind(), QwADC18_Channel::Blind(), QwMollerADC_Channel::Blind(), QwMollerADC_Channel::Blind(), QwVQWK_Channel::Blind(), and QwVQWK_Channel::Blind().

Here is the caller graph for this function:

operator=()

const QwBlinder & QwBlinder::operator= ( const QwBlinder &__attribute__((unused)) blinder )

inlineprivate

Private assignment operator.

Definition at line 260 of file QwBlinder.h.

{ return *this; };

References QwBlinder().

Here is the call graph for this function:

PrintCountersValues()

void QwBlinder::PrintCountersValues	(	std::vector< Int_t >	fCounters,
		TString	counter_type )

Definition at line 1135 of file QwBlinder.cc.

{
  QwMessage << "Blinder Passed " << counter_type  << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with blinding disabled: " << fCounters.at(kBlinderCount_Disabled) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " on a non-blindable target: " << fCounters.at(kBlinderCount_NonBlindable) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with transverse beam: " << fCounters.at(kBlinderCount_Transverse) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " on blindable target with beam present: " << fCounters.at(kBlinderCount_Blindable) << QwLog::endl;
  QwMessage << "Blinder Failed " << counter_type  << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with unknown target position: " << fCounters.at(kBlinderCount_UnknownTarget) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with changed target position: " << fCounters.at(kBlinderCount_ChangedTarget) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with an undefined Wien setting: " << fCounters.at(kBlinderCount_UndefinedWien) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with a changed Wien setting: " << fCounters.at(kBlinderCount_ChangedWien) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with an undefined IHWP setting: " << fCounters.at(kBlinderCount_UndefinedIHWP) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with a changed IHWP setting: " << fCounters.at(kBlinderCount_ChangedIHWP) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " on blindable target with no beam: " << fCounters.at(kBlinderCount_NoBeam) << QwLog::endl;
  QwMessage << "\t" << counter_type
        << " with other blinding failure: " << fCounters.at(kBlinderCount_OtherFailure) << QwLog::endl;
 
}

References QwLog::endl(), kBlinderCount_Blindable, kBlinderCount_ChangedIHWP, kBlinderCount_ChangedTarget, kBlinderCount_ChangedWien, kBlinderCount_Disabled, kBlinderCount_NoBeam, kBlinderCount_NonBlindable, kBlinderCount_OtherFailure, kBlinderCount_Transverse, kBlinderCount_UndefinedIHWP, kBlinderCount_UndefinedWien, kBlinderCount_UnknownTarget, and QwMessage.

Referenced by PrintFinalValues().

Here is the call graph for this function:

Here is the caller graph for this function:

PrintFinalValues()

void QwBlinder::PrintFinalValues

(

Int_t

kVerbosity = 1

)

Print a summary of the blinding/unblinding test

Definition at line 1090 of file QwBlinder.cc.

{
  Int_t total_count = 0;
  for (size_t i=0; i<kBlinderCount_NumCounters; i++){
    total_count += fPatternCounters.at(i);
  }
  if (total_count<=0) return;
 
  QwMessage << "QwBlinder::PrintFinalValues():  Begin summary"    << QwLog::endl;
  QwMessage << "================================================" << QwLog::endl;
  PrintCountersValues(fPatternCounters, "Patterns");
  if(kVerbosity==1){
    QwMessage << "================================================" << QwLog::endl;
    PrintCountersValues(fPairCounters, "Pairs");
  }
  QwMessage << "================================================" << QwLog::endl;
  QwMessage << "The blinding parameters checksum for seed ID "
            << fSeedID << " is:" << QwLog::endl;
  QwMessage << fChecksum << QwLog::endl;
  QwMessage << "================================================" << QwLog::endl;
  CheckTestValues();
  double epsilon = std::numeric_limits<double>::epsilon();
  TString diff;
  QwMessage << "The test results are:" << QwLog::endl;
  QwMessage << std::setw(8)  << "Index"
            << std::setw(16) << "Original value"
            << std::setw(16) << "Blinded value"
            << std::setw(22) << "Orig.-Unblind value"
            << QwLog::endl;
  for (size_t i = 0; i < fTestValues.size(); i++) {
    if ((fTestValues[i]-fUnBlindTestValues[i]) < -epsilon
    || (fTestValues[i]-fUnBlindTestValues[i]) > epsilon )
      diff = Form("% 9g ppb", fTestValues[i]-fUnBlindTestValues[i]*1e9);
    else
      diff = "epsilon";
    QwMessage << std::setw(8)  << i
              << std::setw(16) << Form(" [CENSORED]")
          << std::setw(16) << Form("% 9.3f ppb",fBlindTestValues[i]*1e9)
              << std::setw(22) << diff
              << QwLog::endl;
  }
  QwMessage << "================================================" << QwLog::endl;
  QwMessage << "QwBlinder::PrintFinalValues():  End of summary"   << QwLog::endl;
}

References CheckTestValues(), QwLog::endl(), fBlindTestValues, fChecksum, fPairCounters, fPatternCounters, fSeedID, fTestValues, fUnBlindTestValues, kBlinderCount_NumCounters, PrintCountersValues(), and QwMessage.

Referenced by ~QwBlinder().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessOptions()

void QwBlinder::ProcessOptions

(

QwOptions &

options

)

Update the status with new external information.

Update the blinder status with new external information

Parameters

options

Qweak option handler

Definition at line 230 of file QwBlinder.cc.

{
  if (options.GetValue<bool>("blinder.force-target-out")
      && options.GetValue<bool>("blinder.force-target-blindable")){
    QwError << "QwBlinder::ProcessOptions:  Both blinder.force-target-blindable and blinder.force-target-out are set.  "
        << "Only one can be in force at one time.  Exit and choose one option."
        << QwLog::endl;
    exit(10);
  } else if (options.GetValue<bool>("blinder.force-target-blindable")){
    QwWarning << "QwBlinder::ProcessOptions:  Target position forced with blinder.force-target-blindable." << QwLog::endl;
    fTargetPositionForced = kTRUE;
    SetTargetBlindability(QwBlinder::kBlindable);
  } else if (options.GetValue<bool>("blinder.force-target-out")){
    QwWarning << "QwBlinder::ProcessOptions:  Target position forced with blinder.force-target-out." << QwLog::endl;
    fTargetPositionForced = kTRUE;
    SetTargetBlindability(QwBlinder::kNotBlindable);
  }
 
  fBeamCurrentThreshold = options.GetValue<double>("blinder.beam-current-threshold");
}

References QwLog::endl(), fBeamCurrentThreshold, fTargetPositionForced, QwOptions::GetValue(), kBlindable, kNotBlindable, QwError, QwWarning, and SetTargetBlindability().

Here is the call graph for this function:

ReadRandomSeed()

Int_t QwBlinder::ReadRandomSeed ( )

private

Read the seed string generated utilizing a random number generator.

--------------------------------------------------------—

Function to read the seed in from the database.

Parameters:

Return: Int_t

---

---

--------------------------------------------------------—

Function to read the seed string generated utilizing a random number generator

Parameters: none

Return: Int_t

---

---

Definition at line 523 of file QwBlinder.cc.

{
  static const Char_t alphanum[] =
    "0123456789"
    "!@#$%^&*"
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz";
 
  Int_t strLen = sizeof(alphanum) - 1;
  const size_t length = 20;
  Char_t randomchar[length];
  // Initialize random number generator.
  srand(time(0));
  //get  a "random" positive integer
  
  for (size_t i = 0; i < length; ++i) {
    randomchar[i] = alphanum[rand() % strLen];
  }
  fSeedID=rand();
  TString frandomSeed(randomchar, length);
  fSeed=frandomSeed;//a random string
  return fSeedID;
}

References fSeed, and fSeedID.

Referenced by Update().

Here is the caller graph for this function:

ReadSeed() [1/2]

Int_t QwBlinder::ReadSeed ( QwParityDB * db )

private

Reads the seed from the database object.

ReadSeed() [2/2]

Int_t QwBlinder::ReadSeed ( QwParityDB * db, const UInt_t seed_id )

private

Reads the seed with specified id from the database object.

Returns an integer from a string using a version of the helicity bit pseudorandom algorithm.

SetIHWPPolarity()

void QwBlinder::SetIHWPPolarity ( Int_t ihwppolarity )

private

Definition at line 1287 of file QwBlinder.cc.

{
  fIHWPPolarity = ihwppolarity;
  if (fIHWPPolarity_firstread == 0 && fIHWPPolarity != 0){
    fIHWPPolarity_firstread = fIHWPPolarity;
    QwMessage << "QwBlinder:  First set IHWP state to "
          << fIHWPPolarity << QwLog::endl;
  }
}

References QwLog::endl(), fIHWPPolarity, fIHWPPolarity_firstread, and QwMessage.

Referenced by QwBlinder(), Update(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

SetTargetBlindability()

void QwBlinder::SetTargetBlindability ( QwBlinder::EQwBlinderStatus status )

private

Set the current target blindability status.

Write the blinding parameters to the database

For each analyzed run the database contains a digest of the blinding parameters and a number of blinded test entries.

Definition at line 1265 of file QwBlinder.cc.

{
  fTargetBlindability = status;
  if (fTargetBlindability_firstread == QwBlinder::kIndeterminate
      && fTargetBlindability != QwBlinder::kIndeterminate){
    fTargetBlindability_firstread = fTargetBlindability;
    QwMessage << "QwBlinder:  First set target blindability to "
          << fStatusName[fTargetBlindability] << QwLog::endl;
  }
}

References QwLog::endl(), fStatusName, fTargetBlindability, fTargetBlindability_firstread, kIndeterminate, and QwMessage.

Referenced by ProcessOptions(), QwBlinder(), Update(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

SetWienState()

void QwBlinder::SetWienState ( EQwWienMode wienmode )

private

Definition at line 1276 of file QwBlinder.cc.

{
  fWienMode = wienmode;
  if (fWienMode_firstread == kWienIndeterminate
      && fWienMode != kWienIndeterminate){
    fWienMode_firstread = fWienMode;
    QwMessage << "QwBlinder:  First set Wien state to "
          << WienModeName(fWienMode) << QwLog::endl;
  }
}

References QwLog::endl(), fWienMode, fWienMode_firstread, kWienIndeterminate, QwMessage, and WienModeName().

Referenced by QwBlinder(), Update(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

UnBlind() [1/2]

void QwBlinder::UnBlind ( QwSubsystemArrayParity & diff )

inline

Unblind the asymmetry of an array of subsystems.

Definition at line 186 of file QwBlinder.h.

                                                {
      diff.UnBlind(this);
    };

References QwSubsystemArrayParity::UnBlind().

Here is the call graph for this function:

UnBlind() [2/2]

void QwBlinder::UnBlind ( QwSubsystemArrayParity & diff, const QwSubsystemArrayParity & yield )

inline

Unblind the difference of an array of subsystems.

Definition at line 202 of file QwBlinder.h.

                                                                                     {
      diff.UnBlind(this, yield);
    };

References QwSubsystemArrayParity::UnBlind().

Here is the call graph for this function:

UnBlindValue() [1/2]

void QwBlinder::UnBlindValue ( Double_t & value ) const

inline

Asymmetry unblinding.

Definition at line 136 of file QwBlinder.h.

                                              {
      switch (fBlindingStrategy) {
        case kAdditive:
          value -= fBlindingOffset; break;
        case kMultiplicative:
          value /= fBlindingFactor; break;
        case kAdditiveMultiplicative:
          value = value / fBlindingFactor - fBlindingOffset; break;
        default: break;
      }
    };

References fBlindingFactor, fBlindingOffset, fBlindingStrategy, kAdditive, kAdditiveMultiplicative, and kMultiplicative.

Referenced by CheckTestValues(), and InitTestValues().

Here is the caller graph for this function:

UnBlindValue() [2/2]

void QwBlinder::UnBlindValue ( Double_t & value, const Double_t & yield ) const

inline

Difference unblinding.

Definition at line 161 of file QwBlinder.h.

                                                                     {
      switch (fBlindingStrategy) {
        case kAdditive:
          value -= yield * fBlindingOffset; break;
        case kMultiplicative:
          value /= fBlindingFactor; break;
        case kAdditiveMultiplicative:
          value = value / fBlindingFactor - yield * fBlindingOffset; break;
        default: break;
      }
    };

References fBlindingFactor, fBlindingOffset, fBlindingStrategy, kAdditive, kAdditiveMultiplicative, and kMultiplicative.

Update() [1/4]

void QwBlinder::Update

(

)

Update the status using a random number.

Update the blinder status using a random number

Definition at line 276 of file QwBlinder.cc.

{
  //  Update the seed ID then tell us if it has changed.
  UInt_t old_seed_id = fSeedID;
  ReadRandomSeed();
  //  Force the target to blindable, Wien to be forward,
  //  and IHWP polarity to be +1
  SetTargetBlindability(QwBlinder::kBlindable);
  SetWienState(kWienForward);
  SetIHWPPolarity(+1);
  // If the blinding seed has changed, re-initialize the blinder
  if (fSeedID != old_seed_id ||
      (fSeedID==0 && fSeed!=kDefaultSeed) ) {
    QwWarning << "Changing blinder seed to " << fSeedID
              << " from " << old_seed_id << "." << QwLog::endl;
    InitBlinders(fSeedID);
    InitTestValues(10);
  }
}

References QwLog::endl(), fSeed, fSeedID, InitBlinders(), InitTestValues(), kBlindable, kDefaultSeed, kWienForward, QwWarning, ReadRandomSeed(), SetIHWPPolarity(), SetTargetBlindability(), and SetWienState().

Here is the call graph for this function:

Update() [2/4]

void QwBlinder::Update

(

const QwEPICSEvent &

epics

)

Update the status with new external information.

Update the blinder status with new external information

Parameters

epics

Current EPICS event

Definition at line 324 of file QwBlinder.cc.

{
  // Check for the target information
  // Position:
  //     QWtgt_name == "HYDROGEN-CELL" || QWTGTPOS > 350
  // Temperature:
  //     QWT_miA < 22.0 && QWT_moA < 22.0
  // Pressure:
  //     QW_PT3 in [20,35] && QW_PT4 in [20,35]
  if (fBlindingStrategy != kDisabled && !(fTargetPositionForced) ) {
    //TString  position  = epics.GetDataString("QWtgt_name");
    Double_t tgt_pos   = epics.GetDataValue("pcrex90BDSPOS.VAL");
    QwDebug << "Target parameters used by the blinder: "
      //      << "QWtgt_name=" << position << " "
        << "QWTGTPOS=" << tgt_pos << " "
        << QwLog::endl;
 
    //
    // ****  Target index 1:  Beginning of CREX
    if (fCREXTargetIndex==1 &&
    (tgt_pos>14.5e6 && tgt_pos<18.0e6) ){
      //  Calcium-48 target position
      SetTargetBlindability(QwBlinder::kBlindable);
 
    } else if (fCREXTargetIndex==1 &&
           ( (tgt_pos>-1.0e3 && tgt_pos<14.5e6)
         || (tgt_pos>18.0e6 && tgt_pos<61.e6) ) ){
      //  Reasonable non-calcium-48 target positions
      SetTargetBlindability(QwBlinder::kNotBlindable);
 
 
      //
      // ****  Target index 2:  After 20January change in target location
    } else if (fCREXTargetIndex==2 &&
    (tgt_pos>11.5e6 && tgt_pos<14.5e6) ){
      //  Calcium-48 target position (old Ca-40 position)
      SetTargetBlindability(QwBlinder::kBlindable);
 
    } else if (fCREXTargetIndex==2 &&
           ( (tgt_pos>-1.0e3 && tgt_pos<11.5e6)
         || (tgt_pos>14.5e6 && tgt_pos<61.e6) ) ){
      //  Reasonable non-calcium-48 target positions
      SetTargetBlindability(QwBlinder::kNotBlindable);
 
      //
      //  ****  Target index -1:  These are the PREX positions
    } else if ( fCREXTargetIndex==-1 &&
        (/*  Target positions before 1 August 2019.*/
         ( (tgt_pos > 3e6 && tgt_pos < 6.9e6)
           || (tgt_pos > 7.3e6 && tgt_pos < 7.7e6))
         /*  Target positions after 1 August 2019.*/
         ||( (tgt_pos>30.e6 && tgt_pos<69e6)
             || (tgt_pos>73e6 && tgt_pos<78e6)
             ) ) ){
      //  Lead-208 target positions
      SetTargetBlindability(QwBlinder::kBlindable);
 
    } else if  ( fCREXTargetIndex==-1 &&
         (/*  Target positions before 1 August 2019.*/
          ((tgt_pos > -1e3 && tgt_pos < 3e6)
           || (tgt_pos > 6.8e6 && tgt_pos < 7.2e6)
           || (tgt_pos > 7.7e6 && tgt_pos < 10e6))
          /*  Target positions after 1 August 2019.*/
          || ( (tgt_pos>17e6 && tgt_pos<30e6)
               || (tgt_pos>69e6 && tgt_pos<73e6)
               || (tgt_pos>78e6 && tgt_pos<90e6)
               )
          ) ){
      //  Positions are not lead-208 targets.
      SetTargetBlindability(QwBlinder::kNotBlindable);
 
    } else {
      SetTargetBlindability(QwBlinder::kIndeterminate);
      QwWarning << "Target parameters used by the blinder are indeterminate: "
    //  << "QWtgt_name=" << position << " "
        << "QWTGTPOS=" << tgt_pos << " "
        << QwLog::endl;
    } // End of tests on target positions
  }
  // Check for the beam polarity information
  //     IGL1I00DI24_24M         Beam Half-wave plate Read(off=out)
  //
  if (fBlindingStrategy != kDisabled && !(fSpinDirectionForced) &&
      (fTargetBlindability == QwBlinder::kBlindable) ) {
    //  Use the EPICS class functions to determine the
    //  Wien mode and IHWP polarity.
    SetWienState(epics.DetermineWienMode());
    SetIHWPPolarity(epics.DetermineIHWPPolarity());
 
    if (fWienMode == kWienForward){
      fBlindingOffset = fBlindingOffset_Base * fIHWPPolarity;
    } else if (fWienMode == kWienBackward){
      fBlindingOffset = -1 * fBlindingOffset_Base * fIHWPPolarity;
    } else {
      fBlindingOffset = 0.0;
    }
  }
}

References QwEPICSEvent::DetermineIHWPPolarity(), QwEPICSEvent::DetermineWienMode(), QwLog::endl(), fBlindingOffset, fBlindingOffset_Base, fBlindingStrategy, fCREXTargetIndex, fIHWPPolarity, fSpinDirectionForced, fTargetBlindability, fTargetPositionForced, fWienMode, QwEPICSEvent::GetDataValue(), kBlindable, kDisabled, kIndeterminate, kNotBlindable, kWienBackward, kWienForward, QwDebug, QwWarning, SetIHWPPolarity(), SetTargetBlindability(), and SetWienState().

Here is the call graph for this function:

Update() [3/4]

void QwBlinder::Update

(

const QwSubsystemArrayParity &

detectors

)

Update the status with new external information.

Update the blinder status with new external information

Parameters

detectors

Current subsystem array

Definition at line 301 of file QwBlinder.cc.

{
  // Check for the target blindability flag
  if (fBlindingStrategy != kDisabled && fTargetBlindability==kBlindable) {
    
    // Check that the current on target is above acceptable limit
    Bool_t tmp_beam = kFALSE;
    const VQwHardwareChannel* q_targ = detectors.RequestExternalPointer("q_targ");
    if (q_targ != nullptr) {
      if (q_targ->GetValue() > fBeamCurrentThreshold) {
        tmp_beam = kTRUE;
      }
    }
 
    fBeamIsPresent &= tmp_beam;
  }
}

References fBeamCurrentThreshold, fBeamIsPresent, fBlindingStrategy, fTargetBlindability, VQwHardwareChannel::GetValue(), kBlindable, kDisabled, and MQwPublishable< U, T >::RequestExternalPointer().

Here is the call graph for this function:

Update() [4/4]

void QwBlinder::Update

(

QwParityDB *

db

)

Update the status with new external information.

UseMD5()

Int_t QwBlinder::UseMD5 ( const TString & barestring )

private

Recomputes fBlindTestValue to check for memory errors.

Use an MD5 checksum to get a number from the seed string

Parameters

barestring

Seed string

Returns

Integer number

Definition at line 916 of file QwBlinder.cc.

{
  Int_t temp = 0;
  Int_t tempout = 0;
 
  std::vector<UChar_t> digest = GenerateDigest(barestring);
  for (size_t i = 0; i < digest.size(); i++)
    {
      Int_t j = i%4;
      if (j == 0)
        {
          temp = 0;
        }
      temp |= (digest[i])<<(24-(j*8));
      if ( (j==3) || (i==(digest.size()-1)))
        {
          tempout ^= temp;
        }
    }
 
  if ((tempout & 0x80000000) == 0x80000000) {
      tempout = -1 * (tempout & 0x7FFFFFFF);
  } else {
      tempout = (tempout & 0x7FFFFFFF);
  }
 
  return tempout;
}

References GenerateDigest().

Referenced by InitBlinders().

Here is the call graph for this function:

Here is the caller graph for this function:

UsePseudorandom()

Int_t QwBlinder::UsePseudorandom ( const TString & barestring )

private

Returns an integer from a string using a character manipulation algorithm

Use pseudo-random number generator to get a number from the seed string

Parameters

barestring

Seed string

Returns

Integer number

Definition at line 851 of file QwBlinder.cc.

{
  ULong64_t finalseed;
  Int_t bitcount;
  Int_t tempout = 0;
 
  //  This is an attempt to build a portable 64-bit constant
  ULong64_t longmask = (0x7FFFFFFF);
  longmask<<=32;
  longmask|=0xFFFFFFFF;
 
  finalseed = 0;
  bitcount  = 0;
  for (Int_t i=0; i<barestring.Length(); i++)
    {
      if ( ((barestring[i])&0xC0)!=0 && ((barestring[i])&0xC0)!=0xC0)
        {
          finalseed = ((finalseed&longmask)<<1) | (((barestring[i])&0x40)>>6);
          bitcount++;
        }
      if ( ((barestring[i])&0x30)!=0 && ((barestring[i])&0x30)!=0x30)
        {
          finalseed = ((finalseed&longmask)<<1) | (((barestring[i])&0x10)>>4);
          bitcount++;
        }
      if ( ((barestring[i])&0xC)!=0 && ((barestring[i])&0xC)!=0xC)
        {
          finalseed = ((finalseed&longmask)<<1) | (((barestring[i])&0x4)>>2);
          bitcount++;
        }
      if ( ((barestring[i])&0x3)!=0 && ((barestring[i])&0x3)!=0x3)
        {
          finalseed = ((finalseed&longmask)<<1) | ((barestring[i])&0x1);
          bitcount++;
        }
    }
  for (Int_t i=0; i<(192-bitcount); i++)
    {
      if ((finalseed & 0x800000) == 0x800000)
        {
          finalseed = ((finalseed^0x00000d)<<1) | 0x1;
        }
      else
        {
          finalseed<<=1;
        }
    }
  tempout = (finalseed&0xFFFFFFFF) ^ ((finalseed>>32)&0xFFFFFFFF);
  if ((tempout&0x80000000) == 0x80000000)
    {
      tempout = -1 * (tempout&0x7FFFFFFF);
    }
  else
    {
      tempout =  1 * (tempout&0x7FFFFFFF);
    }
  return tempout;
}

Referenced by InitTestValues().

Here is the caller graph for this function:

UseStringManip()

Int_t QwBlinder::UseStringManip ( const TString & barestring )

private

Returns an integer from a string using MD5.

Use string manipulation to get a number from the seed string

Parameters

barestring

Seed string

Returns

Integer number

Definition at line 806 of file QwBlinder.cc.

{
  std::vector<UInt_t> choppedwords;
  UInt_t tmpword = 0;
  Int_t finalseed = 0;
 
  for (Int_t i = 0; i < barestring.Length(); i++)
    {
      if (i % 4 == 0) tmpword = 0;
      tmpword |= (char(barestring[i]))<<(24-8*(i%4));
      if (i%4 == 3 || i == barestring.Length()-1)
        {
          choppedwords.push_back(tmpword);
          finalseed ^= (tmpword);
        }
    }
  for (Int_t i=0; i<64; i++)
    {
      finalseed &= 0x7FFFFFFF;
      if ((finalseed & 0x800000) == 0x800000)
        {
          finalseed = ((finalseed^0x00000d)<<1) | 0x1;
        }
      else
        {
          finalseed<<=1;
        }
    }
  if ((finalseed&0x80000000) == 0x80000000)
    {
      finalseed = -1 * (finalseed&0x7FFFFFFF);
    }
  else
    {
      finalseed = (finalseed&0x7FFFFFFF);
    }
  return finalseed;
}

WriteChecksum()

void QwBlinder::WriteChecksum ( QwParityDB * db )

private

WriteFinalValuesToDB()

void QwBlinder::WriteFinalValuesToDB

(

QwParityDB *

db

)

WriteTestValues()

void QwBlinder::WriteTestValues ( QwParityDB * db )

private

Writes fSeedID and fBFChecksum to DB for this analysis ID.

Field Documentation

fBeamCurrentThreshold

Double_t QwBlinder::fBeamCurrentThreshold

private

Definition at line 246 of file QwBlinder.h.

Referenced by ProcessOptions(), QwBlinder(), and Update().

fBeamIsPresent

Bool_t QwBlinder::fBeamIsPresent

private

Definition at line 247 of file QwBlinder.h.

Referenced by CheckBlindability(), ClearEventData(), QwBlinder(), and Update().

fBlinderIsOkay

Bool_t QwBlinder::fBlinderIsOkay

private

Definition at line 250 of file QwBlinder.h.

Referenced by CheckBlindability(), and IsBlinderOkay().

fBlindingFactor

Double_t QwBlinder::fBlindingFactor

private

The term to be added to detector asymmetries, before polarity correction.

Definition at line 266 of file QwBlinder.h.

Referenced by BlindValue(), BlindValue(), InitBlinders(), QwBlinder(), UnBlindValue(), and UnBlindValue().

fBlindingOffset

Double_t QwBlinder::fBlindingOffset

private

Blinding strategy.

Definition at line 264 of file QwBlinder.h.

Referenced by BlindValue(), BlindValue(), CheckTestValues(), InitBlinders(), InitTestValues(), QwBlinder(), UnBlindValue(), UnBlindValue(), and Update().

fBlindingOffset_Base

Double_t QwBlinder::fBlindingOffset_Base

private

The term to be added to detector asymmetries.

Definition at line 265 of file QwBlinder.h.

Referenced by CheckTestValues(), InitBlinders(), InitTestValues(), QwBlinder(), and Update().

fBlindingStrategy

EQwBlindingStrategy QwBlinder::fBlindingStrategy

private

Definition at line 263 of file QwBlinder.h.

Referenced by BlindValue(), BlindValue(), CheckBlindability(), ConstructObjects(), InitBlinders(), QwBlinder(), QwBlinder(), UnBlindValue(), UnBlindValue(), Update(), and Update().

fBlindTestValues

std::vector<double> QwBlinder::fBlindTestValues

private

Vector of test values, original.

Definition at line 283 of file QwBlinder.h.

Referenced by CheckTestValues(), InitTestValues(), and PrintFinalValues().

fChecksum

std::string QwBlinder::fChecksum

private

Checksum in raw hex.

Definition at line 280 of file QwBlinder.h.

Referenced by ConstructObjects(), InitBlinders(), and PrintFinalValues().

fCREXTargetIndex

Int_t QwBlinder::fCREXTargetIndex

private

Definition at line 242 of file QwBlinder.h.

Referenced by QwBlinder(), and Update().

fDigest

std::vector<UChar_t> QwBlinder::fDigest

private

Default seed.

Definition at line 279 of file QwBlinder.h.

Referenced by InitBlinders().

fIHWPPolarity

Int_t QwBlinder::fIHWPPolarity

private

Definition at line 232 of file QwBlinder.h.

Referenced by CheckBlindability(), QwBlinder(), SetIHWPPolarity(), and Update().

fIHWPPolarity_firstread

Int_t QwBlinder::fIHWPPolarity_firstread

private

Definition at line 231 of file QwBlinder.h.

Referenced by CheckBlindability(), QwBlinder(), and SetIHWPPolarity().

fMaximumBlindingAsymmetry

Double_t QwBlinder::fMaximumBlindingAsymmetry

private

Default maximum blinding factor (in fraction from identity)

Definition at line 272 of file QwBlinder.h.

Referenced by ConstructObjects(), InitBlinders(), and QwBlinder().

fMaximumBlindingFactor

Double_t QwBlinder::fMaximumBlindingFactor

private

Maximum blinding asymmetry (in ppm)

Definition at line 273 of file QwBlinder.h.

Referenced by ConstructObjects(), and QwBlinder().

fPairCounters

std::vector<Int_t> QwBlinder::fPairCounters

private

Counts the number of helicity pairs in each failure mode.

Definition at line 317 of file QwBlinder.h.

Referenced by BlindPair(), BlindPair(), PrintFinalValues(), and QwBlinder().

fPatternCounters

std::vector<Int_t> QwBlinder::fPatternCounters

private

Counts the number of events in each failure mode.

Definition at line 316 of file QwBlinder.h.

Referenced by Blind(), Blind(), PrintFinalValues(), and QwBlinder().

fSeed

TString QwBlinder::fSeed

private

ID of seed used (seeds.seed_id)

Definition at line 276 of file QwBlinder.h.

Referenced by ConstructObjects(), InitBlinders(), InitTestValues(), QwBlinder(), ReadRandomSeed(), and Update().

fSeedID

UInt_t QwBlinder::fSeedID

private

Maximum blinding factor (in fraction from identity)

Definition at line 275 of file QwBlinder.h.

Referenced by ConstructObjects(), InitBlinders(), PrintFinalValues(), QwBlinder(), ReadRandomSeed(), and Update().

fSpinDirectionForced

Bool_t QwBlinder::fSpinDirectionForced

private

Definition at line 233 of file QwBlinder.h.

Referenced by QwBlinder(), and Update().

fStatusName

const TString QwBlinder::fStatusName

static

Initial value:

= {"Indeterminate", "NotBlindable",
                       "Blindable", "BlindableFail"}

Definition at line 58 of file QwBlinder.h.

       :
 

Referenced by SetTargetBlindability().

fTargetBlindability

EQwBlinderStatus QwBlinder::fTargetBlindability

private

Definition at line 227 of file QwBlinder.h.

Referenced by CheckBlindability(), QwBlinder(), SetTargetBlindability(), Update(), and Update().

fTargetBlindability_firstread

EQwBlinderStatus QwBlinder::fTargetBlindability_firstread

private

Indicates the first value received of the blindability of the target.

Definition at line 226 of file QwBlinder.h.

Referenced by CheckBlindability(), QwBlinder(), and SetTargetBlindability().

fTargetPositionForced

Bool_t QwBlinder::fTargetPositionForced

private

Definition at line 228 of file QwBlinder.h.

Referenced by CheckBlindability(), ProcessOptions(), QwBlinder(), and Update().

fTestValues

std::vector<double> QwBlinder::fTestValues

private

Checksum in ASCII hex.

Definition at line 282 of file QwBlinder.h.

Referenced by CheckTestValues(), InitTestValues(), and PrintFinalValues().

fUnBlindTestValues

std::vector<double> QwBlinder::fUnBlindTestValues

private

Vector of test values, after blinding.

Definition at line 284 of file QwBlinder.h.

Referenced by CheckTestValues(), InitTestValues(), and PrintFinalValues().

fWienMode

EQwWienMode QwBlinder::fWienMode

private

Definition at line 230 of file QwBlinder.h.

Referenced by CheckBlindability(), QwBlinder(), SetWienState(), and Update().

fWienMode_firstread

EQwWienMode QwBlinder::fWienMode_firstread

private

Definition at line 229 of file QwBlinder.h.

Referenced by CheckBlindability(), QwBlinder(), and SetWienState().

kCREXTgtIndexMax

Int_t QwBlinder::kCREXTgtIndexMax = 2

private

Definition at line 244 of file QwBlinder.h.

Referenced by QwBlinder().

kCREXTgtIndexMin

Int_t QwBlinder::kCREXTgtIndexMin = 1

private

Definition at line 243 of file QwBlinder.h.

Referenced by QwBlinder().

kDefaultMaximumBlindingAsymmetry

const Double_t QwBlinder::kDefaultMaximumBlindingAsymmetry = 0.150

staticprivate

The factor to be multiplied to detector asymmetries.

Definition at line 269 of file QwBlinder.h.

Referenced by QwBlinder().

kDefaultMaximumBlindingFactor

const Double_t QwBlinder::kDefaultMaximumBlindingFactor = 0.0

staticprivate

Default maximum blinding asymmetry (in ppm)

Definition at line 270 of file QwBlinder.h.

Referenced by QwBlinder().

kDefaultSeed

const TString QwBlinder::kDefaultSeed = "Default seed, should not be used!"

staticprivate

Seed string (seeds.seed)

Definition at line 277 of file QwBlinder.h.

Referenced by InitBlinders(), QwBlinder(), and Update().

kErrorFlag_BlinderFail

const UInt_t QwBlinder::kErrorFlag_BlinderFail = 0x200

static

Error flag value.

Definition at line 78 of file QwBlinder.h.

Referenced by QwHelicityPattern::CalculateAsymmetry(), QwHelicityPattern::CalculatePairAsymmetry(), and ModifyThisErrorCode().

kValue_BlinderFail

const Double_t QwBlinder::kValue_BlinderFail = -1.0

staticconstexpr

Definition at line 79 of file QwBlinder.h.

Referenced by QwADC18_Channel::Blind(), QwADC18_Channel::Blind(), QwMollerADC_Channel::Blind(), QwMollerADC_Channel::Blind(), QwVQWK_Channel::Blind(), and QwVQWK_Channel::Blind().

---

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

• QwBlinder.h
• QwBlinder.cc