QwSubsystemArrayParity.h

Go to the documentation of this file.

/**********************************************************\
* File: QwSubsystemArrayParity.h                           *
*                                                          *
* Author: P. M. King                                       *
* Time-stamp: <2009-02-04 10:30>                           *
\**********************************************************/
 
/*!
 * \file   QwSubsystemArrayParity.h
 * \brief  Subsystem array container for parity analysis with asymmetry calculations
 */
 
#pragma once
 
#include <vector>
#include <TTree.h>
 
#include "QwSubsystemArray.h"
#include "VQwSubsystemParity.h"
 
// Forward declarations
class QwBlinder;
class QwParityDB;
class QwPromptSummary;
 
/**
 * \class QwSubsystemArrayParity
 * \ingroup QwAnalysis
 * \brief Subsystem array container specialized for parity analysis with asymmetry calculations
 *
 * Extends QwSubsystemArray to provide parity-specific operations such as
 * asymmetry formation, helicity-based accumulation, blinding support, and
 * database output for parity measurements. Manages collections of
 * VQwSubsystemParity objects with coordinated event processing.
 */
class QwSubsystemArrayParity: public QwSubsystemArray {
 
  private:
 
    /// Private default constructor
    QwSubsystemArrayParity(); // not implement, will thrown linker error on use
 
  public:
 
    friend class VQwDataHandler;
    friend class QwAlarmHandler;
    friend class QwCombiner;
    friend class QwCorrelator;
    friend class LRBCorrector;
    friend class QwExtractor;
 
    /// Constructor with options
    QwSubsystemArrayParity(QwOptions& options);
    /// Copy constructor by reference
    QwSubsystemArrayParity(const QwSubsystemArrayParity& source);
    /// Default destructor
    ~QwSubsystemArrayParity() override;
 
    /// \brief Get the subsystem with the specified name
    VQwSubsystemParity* GetSubsystemByName(const TString& name) override;
    /// \brief Construct a branch and vector for this subsystem with a prefix
    void ConstructBranchAndVector(TTree *tree, TString& prefix, QwRootTreeBranchVector &values);
    /// \brief Fill the vector for this subsystem
    void FillTreeVector(QwRootTreeBranchVector &values) const;
    /// \brief Fill the histograms for this subsystem
    void FillHistograms();
 
    /// \brief Fill the database with MPS-based variables
    ///        Note that most subsystems don't need to do this.
    void FillDB_MPS(QwParityDB *db, TString type);
    /// \brief Fill the database
    void FillDB(QwParityDB *db, TString type);
    void FillErrDB(QwParityDB *db, TString type);
 
    /// \brief Assignment operator
    QwSubsystemArrayParity& operator=  (const QwSubsystemArrayParity &value);
    /// \brief Addition-assignment operator
    QwSubsystemArrayParity& operator+= (const QwSubsystemArrayParity &value);
    /// \brief Subtraction-assignment operator
    QwSubsystemArrayParity& operator-= (const QwSubsystemArrayParity &value);
    /// \brief Sum of two subsystem arrays
    void Sum(const QwSubsystemArrayParity &value1, const QwSubsystemArrayParity &value2);
    /// \brief Difference of two subsystem arrays
    void Difference(const QwSubsystemArrayParity &value1, const QwSubsystemArrayParity &value2);
    /// \brief Ratio of two subsystem arrays
    void Ratio(const QwSubsystemArrayParity &numer, const QwSubsystemArrayParity &denom);
    /// \brief Scale this subsystem array
    void Scale(Double_t factor);
 
 
    /// \brief Update the running sums for devices accumulated for the global error non-zero events/patterns
    void AccumulateRunningSum(const QwSubsystemArrayParity& value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF);
    /// \brief Update the running sums for devices check only the error flags at the channel level. Only used for stability checks
    void AccumulateAllRunningSum(const QwSubsystemArrayParity& value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF);
    /// \brief Remove the entry value from the running sums for devices
    void DeaccumulateRunningSum(const QwSubsystemArrayParity& value, Int_t ErrorMask=0xFFFFFFF);
 
    /// \brief Calculate the average for all good events
    void CalculateRunningAverage();
 
    /// \brief Blind the asymmetry of this subsystem
    void Blind(const QwBlinder* blinder);
    /// \brief Unblind the asymmetry of this subsystem
    void UnBlind(const QwBlinder* /*blinder*/)
      { /* Not yet implemented */ };
    /// \brief Blind the difference of this subsystem
    void Blind(const QwBlinder* blinder, const QwSubsystemArrayParity& yield);
    /// \brief Unblind the difference of this subsystem
    void UnBlind(const QwBlinder* /*blinder*/, const QwSubsystemArrayParity& /*yield*/)
      { /* Not yet implemented */ };
 
 
    /// \brief Apply the single event cuts
    Bool_t ApplySingleEventCuts();
    /// \brief Update the data elements' error counters based on their
    ///        internal error flags.
    void IncrementErrorCounters();
 
    Bool_t CheckForBurpFail(QwSubsystemArrayParity &event);
    Bool_t CheckBadEventRange();
    /// \brief Report the number of events failed due to HW and event cut failures
    void PrintErrorCounters() const;
    /// \brief Return the error flag to the main routine
    UInt_t GetEventcutErrorFlag() const {
      return fErrorFlag;
    };
    const UInt_t* GetEventcutErrorFlagPointer() const {
      return &fErrorFlag;
    };
 
    /// \brief Update the error flag internally from all the subsystems
    void UpdateErrorFlag();
 
    /// \brief update the error flag for each channel in the subsystem array with the corresponding value in the ev_error subsystem array
    void UpdateErrorFlag(const QwSubsystemArrayParity& ev_error);
 
    void UpdateErrorFlag(UInt_t errflag){fErrorFlag |= errflag;};
 
    /// \brief Print value of all channels
    void PrintValue() const;
 
    void WritePromptSummary(QwPromptSummary *ps, TString type);
 
    virtual Bool_t CheckForEndOfBurst() const;
 
  public:
  void LoadMockDataParameters(std::string mapfile);
  protected:
 
    /// Test whether this subsystem array can contain a particular subsystem
    static Bool_t CanContain(VQwSubsystem* subsys) {
      return (dynamic_cast<VQwSubsystemParity*>(subsys) != 0);
    };
 
    UInt_t fErrorFlag;
    Int_t  fErrorFlagTreeIndex;
 
}; // class QwSubsystemArrayParity