QwMollerDetector.h

Go to the documentation of this file.

/*!
 * \file   QwMollerDetector.h
 * \brief  Moller detector analysis implementation
 * \author Andrew Kubera
 * \date   2010-06-07
 * \ingroup QwMoller
 */
 
#pragma once
 
// System headers
#include <vector>
 
// Boost multi array
#include <boost/multi_array.hpp>
 
// ROOT headers
#include "TTree.h"
#include "TFile.h"
#ifdef HAS_RNTUPLE_SUPPORT
#include "ROOT/RNTupleModel.hxx"
#include "ROOT/RField.hxx"
#endif // HAS_RNTUPLE_SUPPORT
 
// Qweak headers
#include "VQwSubsystemParity.h"
#include "QwVQWK_Channel.h"
#include "QwScaler_Channel.h"
 
/**
 * \class QwMollerChannelID
 * \ingroup QwMoller
 * \brief Mapping info for Moller detector channels
 */
class QwMollerChannelID
{
  public:
  QwMollerChannelID():fIndex(-1),fSubbankIndex(-1),fWordInSubbank(0),
    fChannelNumber(-1),fModuleType(""),fChannelName(""),fDetectorType(""){};
 
  int fIndex;  // index of this detector in the vector containing all the detector of same type
  int fSubbankIndex;
 
  int fWordInSubbank; //first word reported for this channel in the subbank
                      //(eg VQWK channel report 6 words for each event, scalers only report one word per event)
                      // The first word of the subbank gets fWordInSubbank=0
 
  UInt_t fChannelNumber;
 
  TString fModuleType;
  UInt_t  fModuleNumber;
  TString fChannelName;
  TString fDetectorType;
 
  void Print(){
    QwMessage << "***************************************" << std::endl;
    QwMessage << " QwMoller channel: " << fChannelName << std::endl;
    QwMessage << " Detector Type: " << fDetectorType << std::endl;
    QwMessage << " Channel #: " << fChannelNumber << std::endl;
    QwMessage << " Word In Sub: " << fWordInSubbank << std::endl;
    QwMessage << " Index: " << fIndex << std::endl;
  };
 
};
 
/**
 * \class QwMollerDetector
 * \ingroup QwMoller
 * \brief Subsystem for analyzing Moller detector readout
 */
class QwMollerDetector:
  public VQwSubsystemParity,
  public MQwSubsystemCloneable<QwMollerDetector> {
 
  private:
    /// Private default constructor (not implemented, will throw linker error on use)
    QwMollerDetector();
 
  public:
 
    /// Constructor with name
    QwMollerDetector(const TString& name)
    : VQwSubsystem(name), VQwSubsystemParity(name)
    { };
    /// Copy constructor
    QwMollerDetector(const QwMollerDetector& source)
    : VQwSubsystem(source),VQwSubsystemParity(source),
      fSTR7200_Channel(source.fSTR7200_Channel)
    { }
    /// Virtual destructor
    ~QwMollerDetector() override { };
 
    /* derived from VQwSubsystem */
    void ProcessOptions(QwOptions &options) override; //Handle command line options
    Int_t LoadChannelMap(TString mapfile) override;
    Int_t LoadInputParameters(TString pedestalfile) override;
    Int_t LoadEventCuts(TString & filename);
    Bool_t SingleEventCuts();
    Int_t ProcessConfigurationBuffer(const ROCID_t roc_id, const BankID_t bank_id, UInt_t* buffer, UInt_t num_words) override;
    Int_t ProcessConfigurationBuffer(UInt_t ev_type, const ROCID_t roc_id, const BankID_t bank_id, UInt_t* buffer, UInt_t num_words);
    Int_t ProcessEvBuffer(const ROCID_t roc_id, const BankID_t bank_id, UInt_t *buffer, UInt_t num_words) override;
    Int_t ProcessEvBuffer(UInt_t ev_type, const ROCID_t roc_id, const BankID_t bank_id, UInt_t* buffer, UInt_t num_words) override;
    void  ClearEventData() override;
    void  ProcessEvent() override;
 
    using VQwSubsystem::ConstructHistograms;
    void  ConstructHistograms(TDirectory *folder, TString &prefix) override;
    void  FillHistograms() override;
 
    VQwSubsystem& operator=  (VQwSubsystem *value) override;
    VQwSubsystem& operator+= (VQwSubsystem *value) override;
    VQwSubsystem& operator-= (VQwSubsystem *value) override;
    void  Ratio(VQwSubsystem  *value1, VQwSubsystem  *value2) override;
    void  Scale(Double_t) override;
    void  AccumulateRunningSum(VQwSubsystem* value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF) override;
    //remove one entry from the running sums for devices
    void DeaccumulateRunningSum(VQwSubsystem* value, Int_t ErrorMask=0xFFFFFFF) override{
    };
    void  CalculateRunningAverage() override;
    Int_t LoadEventCuts(TString filename) override;
    Bool_t  ApplySingleEventCuts() override;
    void IncrementErrorCounters() override {};
    void PrintErrorCounters() const override;
    UInt_t GetEventcutErrorFlag() override;
 
    Bool_t CheckForBurpFail(const VQwSubsystem *subsys) override{
      return kFALSE;
    };
 
    //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
    void UpdateErrorFlag(const VQwSubsystem *ev_error) override{
    };
 
    using VQwSubsystem::ConstructBranchAndVector;
    void ConstructBranchAndVector(TTree*, TString&, QwRootTreeBranchVector&) override;
    void ConstructBranch(TTree *tree, TString& prefix) override { };
    void ConstructBranch(TTree *tree, TString& prefix, QwParameterFile& trim_file) override { };
    void FillTreeVector(QwRootTreeBranchVector &values) const override;
 
    // RNTuple methods
#ifdef HAS_RNTUPLE_SUPPORT
    void ConstructNTupleAndVector(std::unique_ptr<ROOT::RNTupleModel>& model, TString& prefix, std::vector<Double_t>& values, std::vector<std::shared_ptr<Double_t>>& fieldPtrs) override;
    void FillNTupleVector(std::vector<Double_t>& values) const override;
#endif // HAS_RNTUPLE_SUPPORT
 
    Bool_t Compare(VQwSubsystem *source);
    void print();
    void PrintValue() const override;
    float* GetRawChannelArray();
 
    Int_t GetChannelIndex(TString channelName, UInt_t module_number); 
    float GetDataForChannelInModule(Int_t module_number, Int_t channel_index){
      return fSTR7200_Channel[module_number][channel_index].GetValue();
    }
      
    float GetDataForChannelInModule(Int_t module_number, TString channel_name){
      return GetDataForChannelInModule(module_number, GetChannelIndex(channel_name,module_number));
    }
 
  protected:
    //Array of ChannelIDs which contain the map file
    std::vector<QwMollerChannelID> fMollerChannelID;
    
    //the running total scaler structure
    std::vector< std::vector<QwSTR7200_Channel> > fSTR7200_Channel;
    std::vector< std::vector<QwSTR7200_Channel> > fPrevious_STR7200_Channel;
 
  private:
    Int_t fQwMollerErrorCount;
    static const Bool_t bDEBUG = kFALSE;
    UInt_t fNumberOfEvents; //! Number of triggered events
 
};