Data handler that forms linear combinations of channels. More...

#include <QwCombiner.h>

Inheritance diagram for QwCombiner:

Collaboration diagram for QwCombiner:

Public Types
typedef std::vector< VQwHardwareChannel * >::iterator	Iterator_HdwChan

typedef std::vector< VQwHardwareChannel * >::const_iterator	ConstIterator_HdwChan

Public Types inherited from VQwDataHandler
enum	EQwHandleType { kHandleTypeUnknown =0 , kHandleTypeMps , kHandleTypeAsym , kHandleTypeDiff , kHandleTypeYield }

typedef std::vector< VQwHardwareChannel * >::iterator	Iterator_HdwChan

typedef std::vector< VQwHardwareChannel * >::const_iterator	ConstIterator_HdwChan

Public Member Functions
	QwCombiner (const TString &name)
	Constructor with name.

	QwCombiner (const QwCombiner &source)
	Copy constructor.

	~QwCombiner () override
	Virtual destructor.

Int_t	LoadChannelMap (const std::string &mapfile) override
	Load the channels and sensitivities.

Int_t	ConnectChannels (QwSubsystemArrayParity &event) override
	Connect to Channels (event only)

Int_t	ConnectChannels (QwSubsystemArrayParity &asym, QwSubsystemArrayParity &diff) override
	Connect to Channels (asymmetry/difference only)

void	ProcessData () override

Public Member Functions inherited from VQwDataHandler
	VQwDataHandler (const TString &name)

	VQwDataHandler (const VQwDataHandler &source)

virtual void	ParseConfigFile (QwParameterFile &file)

void	SetPointer (QwHelicityPattern *ptr)

void	SetPointer (QwSubsystemArrayParity *ptr)

virtual Int_t	ConnectChannels (QwSubsystemArrayParity &, QwSubsystemArrayParity &asym, QwSubsystemArrayParity &diff)

Int_t	ConnectChannels (QwHelicityPattern &helicitypattern)

virtual void	UpdateBurstCounter (Short_t burstcounter)

virtual void	FinishDataHandler ()

	~VQwDataHandler () override

TString	GetName ()

virtual void	ClearEventData ()

void	InitRunningSum ()

void	AccumulateRunningSum ()

virtual void	AccumulateRunningSum (VQwDataHandler &value, Int_t count=0, Int_t ErrorMask=0xFFFFFFF)

void	CalculateRunningAverage ()

void	PrintValue () const

void	WritePromptSummary (QwPromptSummary *ps, TString type)

virtual void	ConstructTreeBranches (QwRootFile *treerootfile, const std::string &treeprefix="", const std::string &branchprefix="")

virtual void	FillTreeBranches (QwRootFile *treerootfile)

virtual void	ConstructNTupleFields (QwRootFile *treerootfile, const std::string &treeprefix="", const std::string &branchprefix="")
	RNTuple methods.

virtual void	FillNTupleFields (QwRootFile *treerootfile)

virtual void	ConstructHistograms (TDirectory *, TString &)
	Construct the histograms in a folder with a prefix.

virtual void	FillHistograms ()
	Fill the histograms.

void	FillTreeVector (QwRootTreeBranchVector &values) const

void	ConstructBranchAndVector (TTree *tree, TString &prefix, QwRootTreeBranchVector &values)

void	SetRunLabel (TString x)

Int_t	LoadChannelMap ()

Bool_t	PublishInternalValues () const override
	Publish all variables of the subsystem.

Bool_t	PublishByRequest (TString device_name) override
	Try to publish an internal variable matching the submitted name.

Public Member Functions inherited from MQwPublishable_child< QwDataHandlerArray, VQwDataHandler >
	MQwPublishable_child ()
	Default constructor Initializes the child object and sets up self-reference for publishing.

	MQwPublishable_child (const MQwPublishable_child &source)
	Copy constructor.

virtual	~MQwPublishable_child ()
	Virtual destructor.

void	SetParent (QwDataHandlerArray *parent)
	Set the parent container for this child object.

QwDataHandlerArray *	GetParent () const
	Get the parent container for this child object.

Public Member Functions inherited from MQwCloneable< VQwDataHandler, QwCombiner >
	~MQwCloneable () override
	Virtual destructor.

VQwDataHandler *	Clone () const override
	Concrete clone method.

const VQwFactory< VQwDataHandler > *	Factory () const override
	Factory getter.

Public Member Functions inherited from VQwCloneable< VQwDataHandler >
virtual	~VQwCloneable ()
	Virtual destructor.

std::string	GetClassName () const
	Get demangled name of this class.

Protected Member Functions
	QwCombiner ()
	Default constructor (Protected for child class access)

Protected Member Functions inherited from VQwDataHandler
	VQwDataHandler ()

void	SetEventcutErrorFlagPointer (const UInt_t *errorflagptr)

UInt_t	GetEventcutErrorFlag () const

std::pair< EQwHandleType, std::string >	ParseHandledVariable (const std::string &variable)

void	CalcOneOutput (const VQwHardwareChannel dv, VQwHardwareChannel output, std::vector< const VQwHardwareChannel * > &ivs, std::vector< Double_t > &sens)

Protected Member Functions inherited from MQwPublishable_child< QwDataHandlerArray, VQwDataHandler >
Bool_t	RequestExternalValue (const TString &name, VQwHardwareChannel *value) const
	Retrieve the variable name from other subsystem arrays Get the value corresponding to some variable name from a different data array.

const VQwHardwareChannel *	RequestExternalPointer (const TString &name) const
	Retrieve a pointer to an external variable by name Requests a direct pointer to a variable from sibling subsystems via the parent container.

Bool_t	PublishInternalValue (const TString name, const TString desc, const VQwHardwareChannel *element) const
	Publish a variable from this child into the parent container.

Protected Attributes
UInt_t	fErrorFlagMask
	Error flag mask.

const UInt_t *	fErrorFlagPointer

std::vector< std::vector< EQwHandleType > >	fIndependentType
	List of channels to use in the combiner.

std::vector< std::vector< std::string > >	fIndependentName

std::vector< std::vector< const VQwHardwareChannel * > >	fIndependentVar

std::vector< std::vector< Double_t > >	fSensitivity

Protected Attributes inherited from VQwDataHandler
Int_t	fPriority

Short_t	fBurstCounter
	When a datahandler array is processed, handlers with lower priority will be processed before handlers with higher priority.

TString	fName

std::string	fMapFile

std::string	fTreeName

std::string	fTreeComment

std::string	fPrefix

TString	run_label

const UInt_t *	fErrorFlagPtr
	Error flag pointer.

QwSubsystemArrayParity *	fSubsystemArray
	Single event pointer.

QwHelicityPattern *	fHelicityPattern
	Helicity pattern pointer.

std::vector< std::string >	fDependentFull

std::vector< EQwHandleType >	fDependentType

std::vector< std::string >	fDependentName

std::vector< const VQwHardwareChannel * >	fDependentVar

std::vector< Double_t >	fDependentValues

std::vector< VQwHardwareChannel * >	fOutputVar

std::vector< Double_t >	fOutputValues

std::vector< std::vector< TString > >	fPublishList

std::string	ParseSeparator

Bool_t	fKeepRunningSum

Bool_t	fRunningsumFillsTree

VQwDataHandler *	fRunningsum

Additional Inherited Members
Static Public Member Functions inherited from MQwCloneable< VQwDataHandler, QwCombiner >
static VQwDataHandler *	Create (const std::string &name)
	Object creation.

static QwCombiner *	Cast (QwCombiner *type)
	Object dynamic cast.

Detailed Description

Data handler that forms linear combinations of channels.

QwCombiner connects to one or more input variables (yields/asymmetries/ differences) and computes configured linear combinations using provided sensitivities. It is typically used to derive composite diagnostics or to prepare inputs for higher-level analyses.

Definition at line 23 of file QwCombiner.h.

Member Typedef Documentation

◆ ConstIterator_HdwChan

typedef std::vector<VQwHardwareChannel*>::const_iterator QwCombiner::ConstIterator_HdwChan

Definition at line 27 of file QwCombiner.h.

◆ Iterator_HdwChan

typedef std::vector<VQwHardwareChannel*>::iterator QwCombiner::Iterator_HdwChan

Definition at line 26 of file QwCombiner.h.

Constructor & Destructor Documentation

◆ QwCombiner() [1/3]

QwCombiner::QwCombiner ( const TString & name )

Constructor with name.

Definition at line 28 of file QwCombiner.cc.

: VQwDataHandler(name)
{
  ParseSeparator = ":";
  fKeepRunningSum = kTRUE;
  fErrorFlagMask = 0;
  fErrorFlagPointer = 0;
}

References fErrorFlagMask, fErrorFlagPointer, VQwDataHandler::fKeepRunningSum, VQwDataHandler::ParseSeparator, and VQwDataHandler::VQwDataHandler().

Referenced by QwCombiner(), QwCombinerSubsystem::QwCombinerSubsystem(), and QwCombinerSubsystem::QwCombinerSubsystem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QwCombiner() [2/3]

QwCombiner::QwCombiner ( const QwCombiner & source )

Copy constructor.

Definition at line 37 of file QwCombiner.cc.

: VQwDataHandler(source)
{
  fErrorFlagMask = 0;
  fErrorFlagPointer = 0;
}

References fErrorFlagMask, fErrorFlagPointer, QwCombiner(), and VQwDataHandler::VQwDataHandler().

Here is the call graph for this function:

◆ ~QwCombiner()

QwCombiner::~QwCombiner ( )

override

Virtual destructor.

Destructor.

Definition at line 45 of file QwCombiner.cc.

{
  Iterator_HdwChan element;
  for (element = fOutputVar.begin(); element != fOutputVar.end(); element++) {
    if (*element != NULL){
       delete *element;
    }
  }
  fOutputVar.clear();
}

References VQwDataHandler::fOutputVar.

◆ QwCombiner() [3/3]

QwCombiner::QwCombiner ( )

inlineprotected

Default constructor (Protected for child class access)

Definition at line 57 of file QwCombiner.h.

57{ };

Member Function Documentation

◆ ConnectChannels() [1/2]

Int_t QwCombiner::ConnectChannels	(	QwSubsystemArrayParity &	asym,
		QwSubsystemArrayParity &	diff )

overridevirtual

Connect to Channels (asymmetry/difference only)

Parameters

asym	Subsystem array with asymmetries
diff	Subsystem array with differences

Returns: 0 on success, non-zero on failure

Connect to the dependent and independent channels

Fill vector of pointers to the relevant data elements

Reimplemented from VQwDataHandler.

Definition at line 174 of file QwCombiner.cc.

{
  // Return if correction is not enabled
 
  /// Fill vector of pointers to the relevant data elements
  fIndependentVar.resize(fDependentName.size());
  fDependentVar.resize(fDependentName.size());
  fOutputVar.resize(fDependentName.size());
  
  for (size_t dv = 0; dv < fDependentName.size(); dv++) {
    // Add independent variables
    for (size_t iv = 0; iv < fIndependentName.at(dv).size(); iv++) {
      // Get the independent variables
      const VQwHardwareChannel* iv_ptr = 0;
      iv_ptr = RequestExternalPointer(fIndependentName.at(dv).at(iv));
      if (iv_ptr == NULL){
        switch (fIndependentType.at(dv).at(iv)) {
        case kHandleTypeAsym:
          iv_ptr = asym.RequestExternalPointer(fIndependentName.at(dv).at(iv));
          break;
        case kHandleTypeDiff:
          iv_ptr = diff.RequestExternalPointer(fIndependentName.at(dv).at(iv));
          break;
        default:
          QwWarning << "Independent variable for combiner has unknown type."
                    << QwLog::endl;
          break;
        }
      }
      if (iv_ptr) {
        fIndependentVar[dv].push_back(iv_ptr);
      } else {
        QwWarning << "Independent variable " << fIndependentName.at(dv).at(iv) << " for combiner of "
                  << "dependent variable " << fDependentName.at(dv) << " could not be found."
                  << QwLog::endl;
      }
    }
 
    // Get the dependent variables
    const VQwHardwareChannel* dv_ptr = 0;
    VQwHardwareChannel* new_chan = NULL;
    const VQwHardwareChannel* chan = NULL;
    string name = "";
    string calc = "calc_";
    
    if (fDependentType.at(dv)==kHandleTypeMps){
      //  Quietly ignore the MPS type when we're connecting the asym & diff
      continue;
    } else if(fDependentName.at(dv).at(0) == '@' ){
        name = fDependentName.at(dv).substr(1,fDependentName.at(dv).length());
    }else{
      dv_ptr = this->RequestExternalPointer(fDependentFull.at(dv));
      if (dv_ptr==NULL){
        switch (fDependentType.at(dv)) {
        case kHandleTypeAsym:
          dv_ptr = asym.RequestExternalPointer(fDependentName.at(dv));
          break;
        case kHandleTypeDiff:
          dv_ptr = diff.RequestExternalPointer(fDependentName.at(dv));
          break;
        default:
          QwWarning << "QwCombiner::ConnectChannels(QwSubsystemArrayParity& asym, QwSubsystemArrayParity& diff):  Dependent variable, "
                        << fDependentName.at(dv)
                        << ", for asym/diff combiner does not have proper type, type=="
                        << fDependentType.at(dv) << "."<< QwLog::endl;
          break;
        }
      }
 
      name = dv_ptr->GetElementName().Data();
      name.insert(0, calc);
 
      new_chan = dv_ptr->Clone(VQwDataElement::kDerived);
      new_chan->SetElementName(name);
      new_chan->SetSubsystemName(fName);
    }
 
    // alias
    if(fDependentName.at(dv).at(0) == '@'){
      //QwMessage << "dv: " << name << QwLog::endl;
      if (fIndependentVar.at(dv).empty()) {
        // Throw exception: alias cannot be created without independent variables
        throw std::runtime_error("Cannot create alias '" + name + 
              "' for dependent variable '" + fDependentName.at(dv) + 
              "': no independent variables found to determine channel type");
      } else {
        // Preferred: use Clone() from first independent variable to preserve channel type
        new_chan = fIndependentVar.at(dv).front()->Clone(VQwDataElement::kDerived);
      }
      new_chan->SetElementName(name);
      new_chan->SetSubsystemName(fName);
    }
    // defined type
    else if(dv_ptr!=NULL){
      //QwMessage << "dv: " << fDependentName.at(dv) << QwLog::endl;
    } else {
      QwWarning << "Dependent variable " << fDependentName.at(dv) << " could not be found, "
                << "or is not a known channel type." << QwLog::endl;
      continue; 
    }
 
    // pair creation
    if(new_chan != NULL){
      fDependentVar[dv] = chan;
      fOutputVar[dv] = new_chan;
    }
  }
  
  // Store error flag pointer
  QwMessage << "Using asymmetry error flag" << QwLog::endl;
  fErrorFlagPointer = asym.GetEventcutErrorFlagPointer();
 
  return 0;
}

References VQwHardwareChannel::Clone(), QwLog::endl(), VQwDataHandler::fDependentFull, VQwDataHandler::fDependentName, VQwDataHandler::fDependentType, VQwDataHandler::fDependentVar, fErrorFlagPointer, fIndependentName, fIndependentType, fIndependentVar, VQwDataHandler::fName, VQwDataHandler::fOutputVar, VQwDataElement::GetElementName(), QwSubsystemArrayParity::GetEventcutErrorFlagPointer(), VQwDataElement::kDerived, VQwDataHandler::kHandleTypeAsym, VQwDataHandler::kHandleTypeDiff, VQwDataHandler::kHandleTypeMps, QwMessage, QwWarning, MQwPublishable< U, T >::RequestExternalPointer(), MQwPublishable_child< QwDataHandlerArray, VQwDataHandler >::RequestExternalPointer(), VQwDataElement::SetElementName(), and VQwDataElement::SetSubsystemName().

Here is the call graph for this function:

◆ ConnectChannels() [2/2]

Int_t QwCombiner::ConnectChannels ( QwSubsystemArrayParity & event )

overridevirtual

Connect to Channels (event only)

Parameters

event Subsystem array with per-MPS yields

Returns: 0 on success, non-zero on failure

Connect to the dependent and independent channels

Parameters: event Helicity event structure Returns: Zero on success

Fill vector of pointers to the relevant data elements

Reimplemented from VQwDataHandler.

Definition at line 296 of file QwCombiner.cc.

{
  // Return if correction is not enabled
 
  /// Fill vector of pointers to the relevant data elements
  fIndependentVar.resize(fDependentName.size());
  fDependentVar.resize(fDependentName.size());
  fOutputVar.resize(fDependentName.size());
  
  for (size_t dv = 0; dv < fDependentName.size(); dv++) {
 
    // Add independent variables
    for (size_t iv = 0; iv < fIndependentName.at(dv).size(); iv++) {
      // Get the independent variables
      const VQwHardwareChannel* iv_ptr = 0;
      if(fIndependentType.at(dv).at(iv) == kHandleTypeMps){
        iv_ptr = event.RequestExternalPointer(fIndependentName.at(dv).at(iv));
        } else {
        QwWarning << "Independent variable for MPS combiner has unknown type."
                  << QwLog::endl;
      }
      if (iv_ptr) {
        fIndependentVar[dv].push_back(iv_ptr);
      } else {
        QwWarning << "Independent variable " << fIndependentName.at(dv).at(iv) << " for combiner of "
                  << "dependent variable " << fDependentName.at(dv) << " could not be found."
                  << QwLog::endl;
      }
    }
 
    // Get the dependent variables
    const VQwHardwareChannel* dv_ptr = 0;
    VQwHardwareChannel* new_chan = NULL;
    const VQwHardwareChannel* chan = NULL;
    string name = " s";
    string calc = "calc_";
 
    if (fDependentType.at(dv)==kHandleTypeAsym || fDependentType.at(dv)==kHandleTypeDiff){
      //  Quietly skip the asymmetry or difference types.
      continue;
    } else if(fDependentType.at(dv) != kHandleTypeMps){
      QwWarning << "QwCombiner::ConnectChannels(QwSubsystemArrayParity& event):  Dependent variable, "
                << fDependentName.at(dv)
                  << ", for MPS combiner does not have MPS type, type=="
                  << fDependentType.at(dv) << "."<< QwLog::endl;
      continue;
    } else {
      if(fDependentName.at(dv).at(0) == '@' ){
        name = fDependentName.at(dv).substr(1,fDependentName.at(dv).length());
        new_chan = fIndependentVar.at(dv).front()->Clone(VQwDataElement::kDerived);
        new_chan->SetElementName(name);
        new_chan->SetSubsystemName(fName);
      } else {
        dv_ptr = event.RequestExternalPointer(fDependentName.at(dv));
 
        name = dv_ptr->GetElementName().Data();
        name.insert(0,calc);
 
        new_chan = dv_ptr->Clone(VQwDataElement::kDerived);
        new_chan->SetElementName(name);
        new_chan->SetSubsystemName(fName);
      }
    }
 
    // alias
    if(new_chan==NULL){
      QwWarning << "Dependent variable " << fDependentName.at(dv) << " could not be found, "
                << "or is not a known channel type." << QwLog::endl;
      continue; 
    } else {
      // pair creation
      fDependentVar[dv] = chan;
      fOutputVar[dv] = new_chan;
    }
  }
  
  // Store error flag pointer
  QwMessage << "Using event error flag" << QwLog::endl;
  fErrorFlagPointer = event.GetEventcutErrorFlagPointer();
 
  return 0;
}

References VQwHardwareChannel::Clone(), QwLog::endl(), VQwDataHandler::fDependentName, VQwDataHandler::fDependentType, VQwDataHandler::fDependentVar, fErrorFlagPointer, fIndependentName, fIndependentType, fIndependentVar, VQwDataHandler::fName, VQwDataHandler::fOutputVar, VQwDataElement::GetElementName(), VQwDataElement::kDerived, VQwDataHandler::kHandleTypeAsym, VQwDataHandler::kHandleTypeDiff, VQwDataHandler::kHandleTypeMps, QwMessage, QwWarning, VQwDataElement::SetElementName(), and VQwDataElement::SetSubsystemName().

Here is the call graph for this function:

◆ LoadChannelMap()

Int_t QwCombiner::LoadChannelMap ( const std::string & mapfile )

overridevirtual

Load the channels and sensitivities.

Load the channel map

Parameters

mapfile Filename of map file

Returns: Zero when success

Reimplemented from VQwDataHandler.

Definition at line 71 of file QwCombiner.cc.

{
  // Open the file
  QwParameterFile map(mapfile);
 
  // Read the preamble
  std::unique_ptr<QwParameterFile> preamble = map.ReadSectionPreamble();
  TString mask;
  if (preamble->FileHasVariablePair("=", "mask", mask)) {
    fErrorFlagMask = QwParameterFile::GetUInt(mask);
  }
 
 
  // Read the sections of dependent variables
  bool keep_header = true;
  std::string section_name;
  std::unique_ptr<QwParameterFile> section = nullptr;
  std::pair<EQwHandleType,std::string> type_name;
  while ((section = map.ReadNextSection(section_name,keep_header))) {
    if(section_name=="PUBLISH") continue;
 
    // Store index to the current position in the dv vector
    size_t current_dv_start = fDependentName.size();
 
    // Add dependent variables from the section header
    section->ReadNextLine();
    if (section->LineHasSectionHeader()) {
      section->TrimSectionHeader();
      section->TrimWhitespace();
      // Parse section header into tokens separated by a comma
      std::string current_token;
      std::string previous_token;
      do {
        previous_token = current_token;
        current_token = section->GetNextToken(",");
        if (current_token.size() == 0) continue;
        // Parse current token into dependent variable type and name
        type_name = ParseHandledVariable(current_token);
        fDependentType.push_back(type_name.first);
        fDependentName.push_back(type_name.second);
        fDependentFull.push_back(current_token);
        // Resize the vectors of sensitivities and independent variables
        fSensitivity.resize(fDependentName.size());
        fIndependentType.resize(fDependentName.size());
        fIndependentName.resize(fDependentName.size());
      } while (current_token.size() != 0);
    } else QwError << "Section does not start with header." << QwLog::endl;
 
    // Add independent variables and sensitivities
    while (section->ReadNextLine()) {
      // Throw away comments, whitespace, empty lines
      section->TrimComment();
      section->TrimWhitespace();
      if (section->LineIsEmpty()) continue;
      // Get first token: independent variable
      std::string current_token = section->GetNextToken(",");
      // Parse current token into independent variable type and name
      type_name = ParseHandledVariable(current_token);
      // Loop over dependent variables to set sensitivities
      for (size_t dv = current_dv_start; dv < fDependentName.size(); dv++) {
        Double_t sensitivity = atof(section->GetNextToken(",").c_str());
        fSensitivity.at(dv).push_back(sensitivity);
        fIndependentType.at(dv).push_back(type_name.first);
        fIndependentName.at(dv).push_back(type_name.second);
      }
    }
  }
 
  TString varvalue; 
  // Now load the variables to publish
  std::vector<std::vector<TString> > fPublishList;
  map.RewindToFileStart();
  std::unique_ptr<QwParameterFile> section2;
  std::vector<TString> publishinfo;
  while ((section2=map.ReadNextSection(varvalue))) {
    if (varvalue == "PUBLISH") {
      fPublishList.clear();
      while (section2->ReadNextLine()) {
        section2->TrimComment(); // Remove everything after a comment character
        section2->TrimWhitespace(); // Get rid of leading and trailing spaces
        for (int ii = 0; ii < 4; ii++) {
          varvalue = section2->GetTypedNextToken<TString>();
          if (varvalue.Length()) {
            publishinfo.push_back(varvalue);
          }
        }
        if (publishinfo.size() == 4)
          fPublishList.push_back(publishinfo);
        publishinfo.clear();
      }
    }
  }
  // Print list of variables to publish
  if (fPublishList.size()>0){
    QwMessage << "Variables to publish:" << QwLog::endl;
    for (size_t jj = 0; jj < fPublishList.size(); jj++){
      QwMessage << fPublishList.at(jj).at(0) << " " << fPublishList.at(jj).at(1) << " " << fPublishList.at(jj).at(2) << " " << fPublishList.at(jj).at(3) << QwLog::endl;
    }
  }
  return 0;
}

References QwLog::endl(), VQwDataHandler::fDependentFull, VQwDataHandler::fDependentName, VQwDataHandler::fDependentType, fErrorFlagMask, fIndependentName, fIndependentType, VQwDataHandler::fPublishList, fSensitivity, QwParameterFile::GetUInt(), VQwDataHandler::ParseHandledVariable(), QwError, QwMessage, QwParameterFile::ReadNextSection(), QwParameterFile::ReadSectionPreamble(), and QwParameterFile::RewindToFileStart().

Here is the call graph for this function:

◆ ProcessData()

void QwCombiner::ProcessData ( )

overridevirtual

Copy dependent variables to output variables (default processing).

Reimplemented from VQwDataHandler.

Reimplemented in QwCombinerSubsystem.

Definition at line 379 of file QwCombiner.cc.

{
  if (fErrorFlagMask!=0 && fErrorFlagPointer!=NULL) {
    if ((*fErrorFlagPointer & fErrorFlagMask)!=0) {
      //QwMessage << "0x" << std::hex << *fErrorFlagPointer << " passed mask " << "0x" << fErrorFlagMask << std::dec << QwLog::endl;
      for (size_t i = 0; i < fDependentVar.size(); ++i) {
        CalcOneOutput(fDependentVar[i], fOutputVar[i], fIndependentVar[i], fSensitivity[i]);
      }
    //} else {
      //QwMessage << "0x" << std::hex << *fErrorFlagPointer << " failed mask " << "0x" << fErrorFlagMask << std::dec << QwLog::endl;
    }
  }
  else{
    for (size_t i = 0; i < fDependentVar.size(); ++i) {
      CalcOneOutput(fDependentVar[i], fOutputVar[i], fIndependentVar[i], fSensitivity[i]);
    }
  }
}

References VQwDataHandler::CalcOneOutput(), VQwDataHandler::fDependentVar, fErrorFlagMask, fErrorFlagPointer, fIndependentVar, VQwDataHandler::fOutputVar, and fSensitivity.

Referenced by QwCombinerSubsystem::ProcessData().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ fErrorFlagMask

UInt_t QwCombiner::fErrorFlagMask

protected

Error flag mask.

Definition at line 60 of file QwCombiner.h.

Referenced by LoadChannelMap(), ProcessData(), QwCombiner(), and QwCombiner().

◆ fErrorFlagPointer

const UInt_t* QwCombiner::fErrorFlagPointer

protected

Definition at line 61 of file QwCombiner.h.

Referenced by ConnectChannels(), ConnectChannels(), ProcessData(), QwCombiner(), and QwCombiner().

◆ fIndependentName

std::vector< std::vector< std::string > > QwCombiner::fIndependentName

protected

Definition at line 65 of file QwCombiner.h.

Referenced by ConnectChannels(), ConnectChannels(), and LoadChannelMap().

◆ fIndependentType

std::vector< std::vector< EQwHandleType > > QwCombiner::fIndependentType

protected

List of channels to use in the combiner.

Definition at line 64 of file QwCombiner.h.

Referenced by ConnectChannels(), ConnectChannels(), and LoadChannelMap().

◆ fIndependentVar

std::vector< std::vector< const VQwHardwareChannel* > > QwCombiner::fIndependentVar

protected

Definition at line 66 of file QwCombiner.h.

Referenced by ConnectChannels(), ConnectChannels(), and ProcessData().

◆ fSensitivity

std::vector< std::vector< Double_t > > QwCombiner::fSensitivity

protected

Definition at line 67 of file QwCombiner.h.

Referenced by LoadChannelMap(), and ProcessData().

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ConstIterator_HdwChan

◆ Iterator_HdwChan

Constructor & Destructor Documentation

◆ QwCombiner() [1/3]

◆ QwCombiner() [2/3]

◆ ~QwCombiner()

◆ QwCombiner() [3/3]

Member Function Documentation

◆ ConnectChannels() [1/2]

◆ ConnectChannels() [2/2]

◆ LoadChannelMap()

◆ ProcessData()

Field Documentation

◆ fErrorFlagMask

◆ fErrorFlagPointer

◆ fIndependentName

◆ fIndependentType

◆ fIndependentVar

◆ fSensitivity