QwEPICSEvent Class Reference

#include <QwEPICSEvent.h>

Data Structures
struct	EPICSCumulativeRecord
struct	EPICSVariableRecord

Public Types
enum	EQwEPICSDataType { kEPICSString, kEPICSFloat, kEPICSInt }
	EPICS data types. More...

Public Member Functions
	QwEPICSEvent ()
	Default constructor. More...
virtual	~QwEPICSEvent ()
	Virtual destructor. More...
void	ProcessOptions (QwOptions &options)
	Process the configuration options. More...
Int_t	AddEPICSTag (const string &tag, const string &table="", EQwEPICSDataType datatype=kEPICSFloat)
Int_t	LoadChannelMap (TString mapfile)
std::vector< Double_t >	ReportAutogains (std::vector< std::string > tag_list=fDefaultAutogainList)
void	ExtractEPICSValues (const string &data, int event)
Int_t	FindIndex (const string &tag) const
	Find the index of an EPICS variable, or return error. More...
Double_t	GetDataValue (const string &tag) const
TString	GetDataString (const string &tag) const
int	SetDataValue (const string &tag, const double value, const int event)
int	SetDataValue (const string &tag, const string &value, const int event)
int	SetDataValue (int index, const double value, const int event)
int	SetDataValue (int index, const string &value, const int event)
Bool_t	HasDataLoaded () const
Int_t	DetermineIHWPPolarity () const
EQwWienMode	DetermineWienMode () const
void	CalculateRunningValues ()
void	PrintAverages () const
void	PrintVariableList () const
void	ReportEPICSData () const
void	ResetCounters ()
void	FillDB (QwParityDB *db)
void	FillSlowControlsData (QwParityDB *db)
void	FillSlowControlsStrigs (QwParityDB *db)
void	FillSlowControlsSettings (QwParityDB *db)
void	ConstructBranchAndVector (TTree *tree, TString &prefix, std::vector< Double_t > &values)
	Construct the branch and tree vector. More...
void	FillTreeVector (std::vector< Double_t > &values) const
	Fill the tree vector. More...
void	WriteEPICSStringValues ()

Static Public Member Functions
static void	DefineOptions (QwOptions &options)
	Define the configuration options. More...
static std::vector< std::string >	GetDefaultAutogainList ()
static void	SetDefaultAutogainList (std::vector< std::string > &input_list)

Private Member Functions
void	SetDataLoaded (Bool_t flag)
Bool_t	IsNumber (const string &word)
TList *	GetEPICSStringValues ()

Static Private Member Functions
static void	InitDefaultAutogainList ()
	Initialize the default autogain list. More...

Private Attributes
size_t	fTreeArrayIndex
size_t	fTreeArrayNumEntries
Bool_t	fIsDataLoaded
bool	fDisableDatabase
std::vector< EPICSVariableRecord >	fEPICSDataEvent
std::vector < EPICSCumulativeRecord >	fEPICSCumulativeData
Int_t	fNumberEPICSEvents
Int_t	fNumberEPICSVariables
std::vector< std::string >	fEPICSVariableList
std::vector< std::string >	fEPICSTableList
std::vector< EQwEPICSDataType >	fEPICSVariableType
std::map< std::string, Int_t >	fEPICSVariableMap
Bool_t	fBlinderReversalForRunTwo
Bool_t	fPrecessionReversal
Double_t	fNominalWienAngle
Int_t	fExtraHelicityReversal

Static Private Attributes
static std::vector< std::string >	fDefaultAutogainList
	Default autogain list. More...
static const int	kDebug = 0
static const int	kEPICS_Error = -1
static const int	kEPICS_OK = 1
static const Double_t	kInvalidEPICSData = -999999.0

Detailed Description

Definition at line 26 of file QwEPICSEvent.h.

Member Enumeration Documentation

enum QwEPICSEvent::EQwEPICSDataType

EPICS data types.

Enumerator
kEPICSString
kEPICSFloat
kEPICSInt

Definition at line 31 of file QwEPICSEvent.h.

{kEPICSString, kEPICSFloat, kEPICSInt};

Constructor & Destructor Documentation

QwEPICSEvent::QwEPICSEvent

(

)

Default constructor.

Definition at line 47 of file QwEPICSEvent.cc.

References InitDefaultAutogainList(), kDebug, PrintVariableList(), and SetDataLoaded().

                          :fBlinderReversalForRunTwo(kFALSE),
           fPrecessionReversal(kFALSE),fNominalWienAngle(30.0)
{
  SetDataLoaded(kFALSE);
  QwEPICSEvent::InitDefaultAutogainList();
  if (kDebug == 1) PrintVariableList();
}

Here is the call graph for this function:

QwEPICSEvent::~QwEPICSEvent ( )

virtual

Virtual destructor.

Definition at line 56 of file QwEPICSEvent.cc.

{
}

Member Function Documentation

Int_t QwEPICSEvent::AddEPICSTag	(	const string &	tag,
		const string &	table = "",
		EQwEPICSDataType	datatype = kEPICSFloat
	)

Definition at line 221 of file QwEPICSEvent.cc.

References fEPICSTableList, fEPICSVariableList, fEPICSVariableMap, fEPICSVariableType, and fNumberEPICSVariables.

Referenced by LoadChannelMap().

{
  fEPICSVariableList.push_back(tag);
  fEPICSVariableMap[tag] = fEPICSVariableList.size() - 1;
  fEPICSTableList.push_back(table);
  fEPICSVariableType.push_back(datatype);
  fNumberEPICSVariables++;
  return 0;
}

Here is the caller graph for this function:

void QwEPICSEvent::CalculateRunningValues

(

)

Definition at line 235 of file QwEPICSEvent.cc.

References fEPICSCumulativeData, fEPICSDataEvent, fEPICSVariableList, fEPICSVariableType, fNumberEPICSEvents, fNumberEPICSVariables, kDebug, kEPICSFloat, and kEPICSInt.

Referenced by main().

{
  if (kDebug == 1) std::cout <<"Here we are in 'CalculateRunningValues'!!"<<std::endl;
  if (kDebug == 1) std::cout<<"fNumberEPICSVariables = "<<fNumberEPICSVariables<<std::endl<<std::endl;

  Bool_t anyFilled = kFALSE;
  for (size_t tagindex = 0; tagindex < fEPICSDataEvent.size(); tagindex++) {
    anyFilled |=  fEPICSDataEvent[tagindex].Filled;
  }
  if (! anyFilled) return;

  for (size_t tagindex = 0; tagindex < fEPICSVariableType.size(); tagindex++) {
    if (fEPICSVariableType[tagindex] == kEPICSFloat ||
        fEPICSVariableType[tagindex] == kEPICSInt) {

      if (fEPICSDataEvent[tagindex].Filled) {

        if (! fEPICSCumulativeData[tagindex].Filled) {
          fEPICSCumulativeData[tagindex].NumberRecords = 0;
          fEPICSCumulativeData[tagindex].Sum           = 0.0;
          fEPICSCumulativeData[tagindex].SquaredSum    = 0.0;
          fEPICSCumulativeData[tagindex].Maximum       =
              fEPICSDataEvent[tagindex].Value;
          fEPICSCumulativeData[tagindex].Minimum       =
              fEPICSDataEvent[tagindex].Value;
          fEPICSCumulativeData[tagindex].Filled        = kTRUE;
        }
        fEPICSCumulativeData[tagindex].NumberRecords++;
        fEPICSCumulativeData[tagindex].Sum +=
            fEPICSDataEvent[tagindex].Value;
        fEPICSCumulativeData[tagindex].SquaredSum +=
            (fEPICSDataEvent[tagindex].Value)*(fEPICSDataEvent[tagindex].Value);
        if (fEPICSDataEvent[tagindex].Value
            > fEPICSCumulativeData[tagindex].Maximum) {
          fEPICSCumulativeData[tagindex].Maximum       =
              fEPICSDataEvent[tagindex].Value;
        }
        if (fEPICSDataEvent[tagindex].Value
            < fEPICSCumulativeData[tagindex].Minimum) {
          fEPICSCumulativeData[tagindex].Minimum       =
              fEPICSDataEvent[tagindex].Value;
        }
        if (kDebug == 1) std::cout << "This event has "<<fEPICSVariableList[tagindex]
                                   << " equal to "<< fEPICSDataEvent[tagindex].Value
           << " giving a running average of "
           << fEPICSCumulativeData[tagindex].Sum /
              fEPICSCumulativeData[tagindex].NumberRecords
           << std::endl;
      } else {
        if (kDebug == 1) std::cout << fEPICSVariableList[tagindex]
                                   << " seems to be not filled."<<std::endl;
      }
    }

    ////////////////////////////////
    else {
      //  This is a string value.
      //  Just check to see if the EPICS string has changed;
      //  if it is the same, increment the counter.

      if (! fEPICSCumulativeData[tagindex].Filled) {
        fEPICSCumulativeData[tagindex].NumberRecords = 0;
        fEPICSCumulativeData[tagindex].SavedString   =
            fEPICSDataEvent[tagindex].StringValue;
        fEPICSCumulativeData[tagindex].Filled        = kTRUE;
      }
      if (fEPICSCumulativeData[tagindex].SavedString
          == fEPICSDataEvent[tagindex].StringValue ) {
        fEPICSCumulativeData[tagindex].NumberRecords++;
      }
    }
  }
  fNumberEPICSEvents++;
  //////////////////////

  if (kDebug == 1) std::cout << "fNumberEPICSEvents = " << fNumberEPICSEvents << std::endl;
}

Here is the caller graph for this function:

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

Construct the branch and tree vector.

Definition at line 161 of file QwEPICSEvent.cc.

References QwLog::endl(), fEPICSVariableList, fEPICSVariableType, fTreeArrayIndex, fTreeArrayNumEntries, kEPICSFloat, kEPICSInt, kEPICSString, and QwError.

{
  fTreeArrayIndex = values.size();
  Int_t treeindex = fTreeArrayIndex;
  for (size_t tagindex = 0; tagindex < fEPICSVariableType.size(); tagindex++) {
    if (fEPICSVariableType[tagindex] == kEPICSString ||
        fEPICSVariableType[tagindex] == kEPICSFloat ||
        fEPICSVariableType[tagindex] == kEPICSInt) {

      // Add element to vector
      values.push_back(0.0);

      // Determine branch name
      TString name = fEPICSVariableList[tagindex];
      name.ReplaceAll(':','_'); // remove colons before creating branch
      TString name_type = name + "/D";

      // Create branch
      tree->Branch(name, &(values[treeindex]), name_type);
        treeindex++;

    } else {

        TString name = fEPICSVariableList[tagindex];
        QwError << "Unrecognized type for EPICS variable " << name << QwLog::endl;

    }
  }
  fTreeArrayNumEntries = values.size() - fTreeArrayIndex;
}

Here is the call graph for this function:

void QwEPICSEvent::DefineOptions ( QwOptions &  options )

static

Define the configuration options.

Defines configuration options using QwOptions functionality.

Parameters

options

Options object

Definition at line 69 of file QwEPICSEvent.cc.

References QwOptions::AddOptions(), and default_bool_value.

Referenced by QwOptions::DefineOptions().

{
  // Option to disable EPICS database accesses
  options.AddOptions("Default options")
    ("disable-db-epics", 
     po::value<bool>()->default_bool_value(false),
     "disable EPICS database access");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Int_t QwEPICSEvent::DetermineIHWPPolarity

(

)

const

Definition at line 1338 of file QwEPICSEvent.cc.

References QwLog::endl(), fExtraHelicityReversal, GetDataString(), QwDebug, and QwWarning.

Referenced by QwBlinder::Update().

                                               {
  Int_t ihwppolarity = 0;
  if (GetDataString("IGL1I00DI24_24M")=="OUT"){
    ihwppolarity = 1;
  } else if (GetDataString("IGL1I00DI24_24M")=="IN"){
    ihwppolarity = -1;
  } else {
    QwWarning << "IHWP state is not well defined: "
        << GetDataString("IGL1I00DI24_24M")
        << QwLog::endl;
  }
  QwDebug << "QwEPICSEvent::DetermineIHWPPolarity: "
    << "raw IHWP polarity is: "
    << ihwppolarity << QwLog::endl;
  ihwppolarity = fExtraHelicityReversal * ihwppolarity;
  QwDebug << "QwEPICSEvent::DetermineIHWPPolarity: "
    << "IHWP polarity after extra reversal is: "
    << ihwppolarity << QwLog::endl;
  return ihwppolarity;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EQwWienMode QwEPICSEvent::DetermineWienMode

(

)

const

Definition at line 1359 of file QwEPICSEvent.cc.

References fNominalWienAngle, GetDataValue(), kWienBackward, kWienForward, kWienHorizTrans, kWienIndeterminate, and kWienVertTrans.

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

                                                 {
  EQwWienMode wienmode = kWienIndeterminate;
  
  Double_t launchangle = 0.0;

  Double_t vwienangle = GetDataValue("VWienAngle");
  Double_t phiangle   = GetDataValue("Phi_FG");
  Double_t hwienangle = GetDataValue("HWienAngle"); 
  Double_t hoffset = 0.0;
  if (fabs(vwienangle)<10.0 && fabs(phiangle)<10.0){
    hoffset = 0.0;
  } else if (fabs(vwienangle)>80.0 && fabs(phiangle)>80.0
       && fabs(vwienangle+phiangle)<10. ){
    hoffset = -90.0;
  } else if (fabs(vwienangle)>80.0 && fabs(phiangle)>80.0
       && fabs(vwienangle+phiangle)>170. ){
    hoffset = +90.0;
  } else if (fabs(vwienangle)>80.0 && fabs(phiangle)<10.0) {
    wienmode = kWienVertTrans;
  } 
  if (wienmode == kWienIndeterminate){
    launchangle = hoffset+hwienangle;
    Double_t long_proj = 
      cos((launchangle-fNominalWienAngle)*TMath::DegToRad());
    if (long_proj > 0.5){
      wienmode = kWienForward;
    } else if (long_proj < -0.5){
      wienmode = kWienBackward;
    } else if (fabs(long_proj)<0.25){
      wienmode = kWienHorizTrans;
    }
  }
  return wienmode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwEPICSEvent::ExtractEPICSValues	(	const string &	data,
		int	event
	)

Definition at line 314 of file QwEPICSEvent.cc.

References DetermineWienMode(), fEPICSDataEvent, fEPICSVariableList, FindIndex(), fIsDataLoaded, QwParameterFile::HasVariablePair(), Qw::in, kDebug, kEPICS_Error, QwParameterFile::ReadNextLine(), SetDataLoaded(), SetDataValue(), QwParameterFile::TrimWhitespace(), and WienModeName().

Referenced by QwEventBuffer::FillEPICSData().

{
  /* This routine will decode the input string, which holds the  *
   * epics buffer and extract the EPICS values from it.          */

  if (kDebug == 1) std::cout <<"Here we are, entering 'ExtractEPICSValues'!!"<<std::endl;

  for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {
    fEPICSDataEvent[tagindex].Filled = kFALSE;
  }

  // Convert the input stream into a stringstream so we can
  // do manipulation on it just like reading a file
  std::stringstream ss(data, std::stringstream::in | std::stringstream::out);
  QwParameterFile file(ss);
  while (file.ReadNextLine()) {
    file.TrimWhitespace();
    string varname, varvalue;
    if (file.HasVariablePair(" \t\n", varname, varvalue)) {
      Int_t tagindex = FindIndex(varname);
      if (tagindex != kEPICS_Error) {
        SetDataValue(tagindex, varvalue, event);
        SetDataLoaded(kTRUE);
      }
    }
  }
  if (fIsDataLoaded) {
    //  Determine the WienMode and save it.
    SetDataValue("WienMode",WienModeName(DetermineWienMode()),event);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwEPICSEvent::FillDB

(

QwParityDB *

db

)

Definition at line 707 of file QwEPICSEvent.cc.

References QwDatabase::Connect(), QwDatabase::Disconnect(), QwLog::endl(), fDisableDatabase, FillSlowControlsData(), FillSlowControlsSettings(), FillSlowControlsStrigs(), QwParityDB::GetRunletID(), QwDatabase::Query(), and QwError.

{
  // Sunday, January 16 22:09:16 EST 2011, jhlee
  // don't change disbale database flag
  // just disable FillSlowControlsSettings(db) when fDisableDatabase is off

  bool hold_fDisableDatabase = fDisableDatabase;

   try {
    db->Connect();
    mysqlpp::Query query= db->Query();
    query << "SELECT slow_controls_settings_id FROM slow_controls_settings WHERE";
    query << " runlet_id = " << mysqlpp::quote << db->GetRunletID(); 

    mysqlpp::StoreQueryResult res = query.store();

    if (res.num_rows() != 0) {
      QwError << "This runlet already has slow controls entries in the database!" << QwLog::endl;
      QwError << "The following slow_controls_settings_id values already exist in the database:  ";
      for (size_t i=0; i<res.num_rows(); i++) {
        QwError << res[i][0] << " ";
      }
      QwError << QwLog::endl;
      QwError << "Slow controls values from this replay will NOT be stored in the database."  << QwLog::endl;

      fDisableDatabase=true;
    }

    db->Disconnect();
  }
  catch (const mysqlpp::Exception& er) {
    QwError << er.what() << QwLog::endl;
    QwError << "Unable to determine if there are other slow controls entries in the database for this run.  THERE MAY BE DUPLICATES." << QwLog::endl;
    db->Disconnect();
  }

 
  if (! fDisableDatabase) {
    FillSlowControlsData(db);
    FillSlowControlsStrigs(db);
    FillSlowControlsSettings(db);
  }
  fDisableDatabase=hold_fDisableDatabase;
}

Here is the call graph for this function:

void QwEPICSEvent::FillSlowControlsData

(

QwParityDB *

db

)

Definition at line 753 of file QwEPICSEvent.cc.

References QwDatabase::Connect(), QwDatabase::Disconnect(), QwLog::endl(), fEPICSCumulativeData, fEPICSTableList, fEPICSVariableList, fEPICSVariableType, QwParityDB::GetRunletID(), QwParityDB::GetSlowControlDetectorID(), kEPICSFloat, kEPICSInt, QwDatabase::Query(), QwDebug, and QwError.

Referenced by FillDB().

{

  QwDebug << " -------------------------------------------------------------------------- " << QwLog::endl;
  QwDebug << "                         QwEPICSEvent::FillSlowControlsData(QwParityDB *db) " << QwLog::endl;
  QwDebug << " -------------------------------------------------------------------------- " << QwLog::endl;

  Double_t mean, average_of_squares, variance, sigma;
  Int_t n_records;

  mean     = 0.0;
  average_of_squares = 0.0;
  variance = 0.0;
  sigma    = 0.0;
  n_records = 0;
  //  Figure out if the target table has this runlet_id in it already,
  //  if not, create a new entry with the current runlet_id.

  UInt_t runlet_id = db->GetRunletID();

  std::vector<QwParitySSQLS::slow_controls_data> entrylist;

  UInt_t sc_detector_id;

  string table = "slow_controls_data";

  // QwError << "Step 1 Entering the loop " << QwLog::endl;
  // Loop over EPICS variables
  for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {

    // Look for variables to write into this table
    if (fEPICSTableList[tagindex] == table) {
      QwParitySSQLS::slow_controls_data tmp_row(0);

      //  Now get the current sc_detector_id for the above runlet_id.
      sc_detector_id = db->GetSlowControlDetectorID(fEPICSVariableList[tagindex]);

      tmp_row.runlet_id      = runlet_id;
      tmp_row.sc_detector_id = sc_detector_id;

      if (!sc_detector_id) continue;


      // Calculate average and error
      if (fEPICSVariableType[tagindex] == kEPICSFloat
    || fEPICSVariableType[tagindex] == kEPICSInt) {
  if (fEPICSCumulativeData[tagindex].NumberRecords > 0){

    mean     = (fEPICSCumulativeData[tagindex].Sum)/
      ((Double_t) fEPICSCumulativeData[tagindex].NumberRecords);
          average_of_squares = (fEPICSCumulativeData[tagindex].SquaredSum)/
            ((Double_t) fEPICSCumulativeData[tagindex].NumberRecords);
          variance = average_of_squares - (mean * mean);
          if (variance < 0.0){
            sigma    = sqrt(-1.0 * variance);
          } else {
            sigma    = sqrt(variance);
          }
          n_records = fEPICSCumulativeData[tagindex].NumberRecords;

    //  Build the row and submit it to the list
    tmp_row.n             = n_records;
    tmp_row.value         = mean;
    tmp_row.error         = sigma;
    tmp_row.min_value     = fEPICSCumulativeData[tagindex].Minimum;
    tmp_row.max_value     = fEPICSCumulativeData[tagindex].Maximum;
    
    entrylist.push_back(tmp_row);
  }
      }
    }
  }


  db->Connect();
  // Check the entrylist size, if it isn't zero, start to query..
  if( entrylist.size() ) {
    QwDebug << "QwEPICSEvent::FillSlowControlsData::Writing to database now" << QwLog::endl;
    mysqlpp::Query query= db->Query();

    //    query.insert(entrylist.begin(), entrylist.end());

    //QwDebug << "Query: " << query.str() << QwLog::endl;

    //    query.execute();

    ///////////////////////////////
    try {
      query.insert(entrylist.begin(), entrylist.end());
      QwDebug << "Query: " << query.str() << QwLog::endl;
      query.execute();
      QwDebug << "Done executing MySQL query" << QwLog::endl;
    } catch (const mysqlpp::Exception &er) {
      QwError << "MySQL exception: " << er.what() << QwLog::endl;
    }
    ///////////////////////////////

  } else {
    QwDebug << "QwEPICSEvent::FillSlowControlsData :: This is the case when the entrylist contains nothing " << QwLog::endl;
  }
  db->Disconnect();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwEPICSEvent::FillSlowControlsSettings

(

QwParityDB *

db

)

Definition at line 929 of file QwEPICSEvent.cc.

References QwDatabase::Connect(), QwDatabase::Disconnect(), QwLog::endl(), fEPICSCumulativeData, fEPICSDataEvent, fEPICSVariableList, FindIndex(), fNumberEPICSEvents, fPrecessionReversal, QwParityDB::GetRunletID(), kEPICS_Error, QwDatabase::Query(), QwDebug, QwError, QwWarning, and WienModeIndex().

Referenced by FillDB().

{
  QwParitySSQLS::slow_controls_settings  tmp_row(0);
  std::vector<QwParitySSQLS::slow_controls_settings> entrylist;

  tmp_row.slow_helicity_plate = mysqlpp::null;
  tmp_row.wien_reversal = mysqlpp::null;
  tmp_row.helicity_length = mysqlpp::null;
  tmp_row.charge_feedback = mysqlpp::null;
  tmp_row.position_feedback = mysqlpp::null;
  tmp_row.qtor_current = mysqlpp::null;
  tmp_row.target_position = mysqlpp::null;

  UInt_t runlet_id = db->GetRunletID();
  tmp_row.runlet_id      = runlet_id;
  Int_t tagindex;

  // Add as many blocks as needed in the following for all slow_controls_settings.

  ////////////////////////////////////////////////////////////

  // For QTOR current
  tagindex = FindIndex("qw:qt_mps_i_dcct");
  if (tagindex != kEPICS_Error) {
    QwDebug << "tagindex for  = qw:qt_mps_i_dcct" << tagindex << QwLog::endl;
    if (! fEPICSCumulativeData[tagindex].Filled) {
      //  No data for this run.
      tmp_row.qtor_current = mysqlpp::null;
    } else if (fEPICSCumulativeData[tagindex].NumberRecords <= 0) {
      // No events in this variable
      QwWarning << "The value of "
    << fEPICSVariableList[tagindex]
    << " had no events during this run.  "
    << "Send NULL word to the database."
    << QwLog::endl;
      tmp_row.qtor_current = mysqlpp::null;
    } else {
      Double_t qtorcurrent = (fEPICSCumulativeData[tagindex].Sum)/
  ((Double_t) fEPICSCumulativeData[tagindex].NumberRecords);
      QwDebug << "Send the value of "
        << fEPICSVariableList[tagindex]
        << ", "
        << qtorcurrent
        << ", to the database."
        << QwLog::endl;
      tmp_row.qtor_current = qtorcurrent;
    }
  }

  ////////////////////////////////////////////////////////////

  // For target position
  tagindex = FindIndex("QWtgt_name");
  if (tagindex != kEPICS_Error) {
  QwDebug << "tagindex for  = QWtgt_name" << tagindex << QwLog::endl;
  if (! fEPICSCumulativeData[tagindex].Filled) {
    //  No data for this run.
    tmp_row.target_position = mysqlpp::null;
  } else if (fEPICSCumulativeData[tagindex].NumberRecords
       != fNumberEPICSEvents) {
    // Target position changed
    QwWarning << "The value of "
        << fEPICSVariableList[tagindex]
        << " changed during this run.  "
        << "Send NULL word to the database."
        << QwLog::endl;
    tmp_row.target_position = mysqlpp::null;
  }
  if(fEPICSDataEvent[tagindex].StringValue.Contains("***") ){
    QwWarning << "The value of "
        << fEPICSVariableList[tagindex]
        << " is not defined."
        << "Send NULL word to the database."
        << QwLog::endl;
    tmp_row.target_position =mysqlpp::null;
  }  else {
    // Target position did not change.
    // Store the position as a text string.
    QwDebug << "Send the value of "
      << fEPICSVariableList[tagindex]
      << ", "
      << fEPICSDataEvent[tagindex].StringValue.Data()
      << ", to the database."
      << QwLog::endl;
    tmp_row.target_position = fEPICSDataEvent[tagindex].StringValue.Data();
  }
  }

  ////////////////////////////////////////////////////////////

  // For insertable Half Wave Plate Setting
  tagindex = FindIndex("IGL1I00DI24_24M");
  if (tagindex != kEPICS_Error) {
  QwDebug << "tagindex for IGL1I00DI24_24M = " << tagindex << QwLog::endl;

  if (! fEPICSCumulativeData[tagindex].Filled) {
    //  No data for this run.
    tmp_row.slow_helicity_plate = mysqlpp::null;
  } else if (fEPICSCumulativeData[tagindex].NumberRecords
       != fNumberEPICSEvents) {
    // Insertable Half Wave Plate Setting position changed
    QwWarning << "The value of "
        << fEPICSVariableList[tagindex]
        << " changed during the run."
        << "Send NULL word to the database."
        << QwLog::endl;
    tmp_row.slow_helicity_plate = mysqlpp::null;
  }
  if(fEPICSDataEvent[tagindex].StringValue.Contains("***") ){
    QwWarning << "The value of "
        << fEPICSVariableList[tagindex]
        << " is not defined."
        << "Send NULL word to the database."
        << QwLog::endl;
    tmp_row.slow_helicity_plate =mysqlpp::null;
  } else {
    // Insertable Half Wave Plate Setting position did not change
    // Insertable Half Wave Plate Setting setting is stored as a string with possible values
    // "OUT" and "IN".
    QwDebug << "Send the value of "
      << fEPICSVariableList[tagindex]
      << ", "
      << fEPICSDataEvent[tagindex].StringValue.Data()
      << ", to the database."
      << QwLog::endl;
    tmp_row.slow_helicity_plate = fEPICSDataEvent[tagindex].StringValue.Data();
  }
  }

  // For IHWP2 Setting
  // IGL1I00DIOFLRD: Passive IHWP readback (13056=IN,8960=OUT)
  tagindex = FindIndex("IGL1I00DIOFLRD");
  if (tagindex != kEPICS_Error) {
    QwDebug << "tagindex for IGL1I00DIOFLRD = " << tagindex << QwLog::endl;
    
    if (! fEPICSCumulativeData[tagindex].Filled) {
      //  No data for this run.
      tmp_row.passive_helicity_plate = mysqlpp::null;
    } else if (fEPICSCumulativeData[tagindex].NumberRecords
         != fNumberEPICSEvents) {
      // IHWP2 Setting position changed
      QwWarning << "The value of "
    << fEPICSVariableList[tagindex]
    << " changed during the run."
    << "Send NULL word to the database."
    << QwLog::endl;
      tmp_row.passive_helicity_plate = mysqlpp::null;
    } else {
      Double_t ihwp2_readback = (fEPICSCumulativeData[tagindex].Sum)/
  ((Double_t) fEPICSCumulativeData[tagindex].NumberRecords);
      if (fabs(ihwp2_readback-13056)<1){
  // IHWP2 is IN
  QwDebug << "Send the value of "
    << fEPICSVariableList[tagindex]
    << ", "
    << fEPICSDataEvent[tagindex].StringValue.Data()
    << ", to the database."
    << QwLog::endl;
  tmp_row.passive_helicity_plate = "in";
      } else if (fabs(ihwp2_readback-8960)<1){
  // IHWP2 is OUT
  QwDebug << "Send the value of "
    << fEPICSVariableList[tagindex]
    << ", "
    << fEPICSDataEvent[tagindex].StringValue.Data()
    << ", to the database."
    << QwLog::endl;
  tmp_row.passive_helicity_plate = "out";
      } else {
  QwWarning << "The value of "
      << fEPICSVariableList[tagindex]
      << " is not defined."
      << "Send NULL word to the database."
      << QwLog::endl;
  tmp_row.passive_helicity_plate =mysqlpp::null;
      }
    }
  }

 // For Wien Setting
  tagindex = FindIndex("WienMode");
  if (tagindex != kEPICS_Error) {
    QwDebug << "tagindex for WienMode = " << tagindex << QwLog::endl;

    if (! fEPICSCumulativeData[tagindex].Filled) {
      //  No data for this run.
      tmp_row.wien_reversal = mysqlpp::null;
    } else if (fEPICSCumulativeData[tagindex].NumberRecords
         != fNumberEPICSEvents) {
      // WienMode changed
      QwWarning << "The value of "
    << fEPICSVariableList[tagindex]
    << " changed during the run."
    << "Send NULL word to the database."
    << QwLog::endl;
      tmp_row.wien_reversal = mysqlpp::null;
    }
    if(fEPICSDataEvent[tagindex].StringValue.Contains("***") ){
      QwWarning << "The value of "
    << fEPICSVariableList[tagindex]
    << " is not defined."
    << "Send NULL word to the database."
    << QwLog::endl;
      tmp_row.wien_reversal =mysqlpp::null;
    } else {
      // WienMode is stored as an enum of the following labels:
      TString wien_enum[5] = {"indeterminate",
            "normal","reverse",
            "transverse_vertical",
            "transverse_horizontal"};
      QwDebug << "Send the value of "
        << fEPICSVariableList[tagindex]
        << ", "
        << fEPICSDataEvent[tagindex].StringValue.Data()
        << ", to the database."
        << QwLog::endl;
      tmp_row.wien_reversal = wien_enum[WienModeIndex(fEPICSDataEvent[tagindex].StringValue)].Data();
    }
  }
  
  // For the precession reversal
  //   This just uses the flag from the channel map to determine if the precession 
  //   is normal or reversed.
  if (fPrecessionReversal){
    tmp_row.precession_reversal = "reverse";
  } else {
    tmp_row.precession_reversal = "normal";
  }

  // For charge feedback

  tagindex = FindIndex("qw:ChargeFeedback");
  if (tagindex != kEPICS_Error) {
  //std::cout << "tagindex for qw:ChargeFeedback = " << tagindex << std::endl;

  if (! fEPICSCumulativeData[tagindex].Filled) {
    //  No data for this run.
    tmp_row.charge_feedback = mysqlpp::null;

  } else if (fEPICSCumulativeData[tagindex].NumberRecords
       != fNumberEPICSEvents) {
    // charge feedback status changed
    QwWarning << "The value of "
        << fEPICSVariableList[tagindex]
        << " changed during the run."
        << "Send NULL word to the database."
        << QwLog::endl;
    tmp_row.charge_feedback = mysqlpp::null;
  }

  if(fEPICSDataEvent[tagindex].StringValue.Contains("***") ){
    QwWarning << "The value of "
        << fEPICSVariableList[tagindex]
        << " is not defined."
        << "Send NULL word to the database."
        << QwLog::endl;
    tmp_row.charge_feedback =mysqlpp::null;
  }

  else {
    // charge feedback setting did not change
    //   charge feedback setting is stored as a string with possible values
    //   "on" and "off".
    QwDebug << "Send the value of "
      << fEPICSVariableList[tagindex]
      << ", "
      << fEPICSDataEvent[tagindex].StringValue.Data()
      << ", to the database."
      << QwLog::endl;
    TString tmpval = fEPICSDataEvent[tagindex].StringValue;
    tmpval.ToLower();
    tmp_row.charge_feedback = tmpval.Data();
  }
  }

  ////////////////////////////////////////////////////////////



  entrylist.push_back(tmp_row);

  db->Connect();
  // Check the entrylist size, if it isn't zero, start to query..
  if( entrylist.size() ) {
    QwDebug << "QwEPICSEvent::FillSlowControlsSettings Writing to database now" << QwLog::endl;
    mysqlpp::Query query= db->Query();
    //   query.insert(entrylist.begin(), entrylist.end());
    //     QwDebug << "Query: " << query.str() <<  QwLog::endl;
    //     query.execute();
    ///////////////////////////////
    try {
      query.insert(entrylist.begin(), entrylist.end());
      QwDebug << "Query: " << query.str() << QwLog::endl;
      query.execute();
      QwDebug << "Done executing MySQL query" << QwLog::endl;
    } catch (const mysqlpp::Exception &er) {
      QwError << "MySQL exception: " << er.what() << QwLog::endl;
    }
    ///////////////////////////////


  } else {
    QwDebug << "QwEPICSEvent::FillSlowControlsSettings :: This is the case when the entrylist contains nothing " << QwLog::endl;
  }
  db->Disconnect();
  QwDebug << "Leaving QwEPICSEvent::FillSlowControlsStrings()" << QwLog::endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwEPICSEvent::FillSlowControlsStrigs

(

QwParityDB *

db

)

Definition at line 857 of file QwEPICSEvent.cc.

References QwDatabase::Connect(), QwDatabase::Disconnect(), QwLog::endl(), fEPICSDataEvent, fEPICSTableList, fEPICSVariableList, fEPICSVariableType, QwParityDB::GetRunletID(), QwParityDB::GetSlowControlDetectorID(), kEPICSString, QwDatabase::Query(), QwDebug, QwError, and QwWarning.

Referenced by FillDB().

{
  std::vector<QwParitySSQLS::slow_controls_strings> entrylist;
  UInt_t sc_detector_id;
  UInt_t runlet_id = db->GetRunletID();
  string table = "polarized_source";

  // QwError << "Step 1 Entering the loop " << QwLog::endl;
  // Loop over EPICS variables
  for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {
    // Look for variables to write into this table

    if (fEPICSTableList[tagindex] == table) {
      QwParitySSQLS::slow_controls_strings tmp_row(0);

      //  Now get the current sc_detector_id for the above runlet_id.
      sc_detector_id = db->GetSlowControlDetectorID(fEPICSVariableList[tagindex]);

      tmp_row.runlet_id      = runlet_id;
      tmp_row.sc_detector_id = sc_detector_id;

      if (!sc_detector_id) continue;

      if (fEPICSVariableType[tagindex] == kEPICSString) {

      if (fEPICSDataEvent[tagindex].Filled) {
    if(fEPICSDataEvent[tagindex].StringValue.Contains("***") ){
      QwWarning<<"fEPICSDataEvent[tagindex].StringValue.Data() is not defined, tmp_row.value is set to an empty string."<<QwLog::endl;
      tmp_row.value ="";
    }
    else {
      //std::cout<<" Just a test value: "<<fEPICSDataEvent[tagindex].StringValue.Data()<<QwLog::endl;
      tmp_row.value = fEPICSDataEvent[tagindex].StringValue.Data();
    }
    //  Only add rows for filled variables
    entrylist.push_back(tmp_row);
  }
      }
    }
  }

  db->Connect();
  // Check the entrylist size, if it isn't zero, start to query.
  if( entrylist.size() ) {
    QwDebug << "QwEPICSEvent::FillSlowControlsStrigs Writing to database now" << QwLog::endl;
    mysqlpp::Query query= db->Query();
//     query.insert(entrylist.begin(), entrylist.end());

//     QwDebug << "Query: " << query.str() << QwLog::endl;

//     query.execute();


    ///////////////////////////////
        try {
          query.insert(entrylist.begin(), entrylist.end());
          QwDebug << "Query: " << query.str() << QwLog::endl;
          query.execute();
          QwDebug << "Done executing MySQL query for FillSlowControlsStrings"
      << QwLog::endl;
        } catch (const mysqlpp::Exception &er) {
          QwError << "MySQL exception: " << er.what() << QwLog::endl;
        }
    ///////////////////////////////

  } else {
    QwDebug << "QwEPICSEvent::FillSlowControlsData :: This is the case when the entrylist contains nothing " << QwLog::endl;
  }
  db->Disconnect();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwEPICSEvent::FillTreeVector

(

std::vector< Double_t > &

values

)

const

Fill the tree vector.

Definition at line 193 of file QwEPICSEvent.cc.

References QwLog::endl(), fEPICSDataEvent, fEPICSVariableList, fEPICSVariableType, fTreeArrayIndex, kEPICSFloat, kEPICSInt, kEPICSString, and QwError.

{
  Int_t treeindex = fTreeArrayIndex;
  for (size_t tagindex = 0; tagindex < fEPICSVariableType.size(); tagindex++) {
    switch (fEPICSVariableType[tagindex]) {
      case kEPICSFloat:
      case kEPICSInt: {
        // Add value to vector
        values[treeindex] = fEPICSDataEvent[tagindex].Value;
        treeindex++;
        break;
      }
      case kEPICSString: {
        // Add value to vector
        values[treeindex] = static_cast<Double_t>(fEPICSDataEvent[tagindex].StringValue.Hash());
        treeindex++;
        break;
      }
      default: {
        TString name = fEPICSVariableList[tagindex];
        QwError << "Unrecognized type for EPICS variable " << name << QwLog::endl;
        break;
      }
    }
  }
}

Here is the call graph for this function:

Int_t QwEPICSEvent::FindIndex

(

const string &

tag

)

const

Find the index of an EPICS variable, or return error.

Definition at line 347 of file QwEPICSEvent.cc.

References fEPICSVariableMap, and kEPICS_Error.

Referenced by ExtractEPICSValues(), FillSlowControlsSettings(), GetDataString(), GetDataValue(), and SetDataValue().

{
  // Find a match for the tag
  std::map<std::string,Int_t>::const_iterator match = fEPICSVariableMap.find(tag);

  if (match != fEPICSVariableMap.end())
    // A match was found
    return match->second;

  else
    // Otherwise return error
    return kEPICS_Error;
}

Here is the caller graph for this function:

TString QwEPICSEvent::GetDataString

(

const string &

tag

)

const

Definition at line 374 of file QwEPICSEvent.cc.

References fEPICSDataEvent, fEPICSVariableType, FindIndex(), kEPICS_Error, and kEPICSString.

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

{
  Int_t tagindex = FindIndex(tag);
  if (tagindex != kEPICS_Error) {
    if (fEPICSVariableType[tagindex]==kEPICSString
  && fEPICSDataEvent[tagindex].Filled) {
      return(fEPICSDataEvent[tagindex].StringValue);
    }
  }
  return TString("");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Double_t QwEPICSEvent::GetDataValue

(

const string &

tag

)

const

Definition at line 362 of file QwEPICSEvent.cc.

References fEPICSDataEvent, FindIndex(), kEPICS_Error, and kInvalidEPICSData.

Referenced by DetermineWienMode(), main(), ReportAutogains(), and QwBlinder::Update().

{
  Double_t data_value = kInvalidEPICSData;
  Int_t tagindex = FindIndex(tag);
  if (tagindex != kEPICS_Error) {
    if (fEPICSDataEvent[tagindex].Filled) {
      data_value = fEPICSDataEvent[tagindex].Value;
    }
  }
  return data_value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static std::vector<std::string> QwEPICSEvent::GetDefaultAutogainList ( )

inlinestatic

Definition at line 108 of file QwEPICSEvent.h.

References fDefaultAutogainList.

{ return fDefaultAutogainList; };

TList * QwEPICSEvent::GetEPICSStringValues ( )

private

Definition at line 1237 of file QwEPICSEvent.cc.

References fEPICSDataEvent, fEPICSVariableList, fEPICSVariableType, and kEPICSString.

{
  Bool_t local_debug = false;

  TList *string_list = new TList;
  string_list->SetOwner(true);

  std::size_t tagindex = 0;
  
  for (tagindex=0; tagindex<fEPICSVariableList.size(); tagindex++) 
    {
      if (fEPICSVariableType[tagindex] == kEPICSString) {

  TString epics_string = fEPICSVariableList[tagindex];
  epics_string += "---";

  if (fEPICSDataEvent[tagindex].Filled) {
    epics_string += fEPICSDataEvent[tagindex].StringValue;
  } 
  else {
    epics_string += "empty";
  }
  if(local_debug) {
    std::cout << "QwEPICSEvent::GetEPICSStringValues() "
        << epics_string
        << std::endl;
  }
  string_list -> Add(new TObjString(epics_string));
      }
    }
    
  return string_list;
}

Bool_t QwEPICSEvent::HasDataLoaded ( ) const

inline

Definition at line 68 of file QwEPICSEvent.h.

References fIsDataLoaded.

Referenced by main().

{ return fIsDataLoaded; };

Here is the caller graph for this function:

void QwEPICSEvent::InitDefaultAutogainList ( )

staticprivate

Initialize the default autogain list.

Definition at line 386 of file QwEPICSEvent.cc.

References fDefaultAutogainList.

Referenced by QwEPICSEvent().

{
  // Clear the vector first
  fDefaultAutogainList.clear();

  // Add default autogain channels
  fDefaultAutogainList.push_back("IPM3C17.XIFG");
  fDefaultAutogainList.push_back("IPM3C17.YIFG");
  fDefaultAutogainList.push_back("IBC3C17.XIFG");
  fDefaultAutogainList.push_back("IBC3C17.YIFG");
  fDefaultAutogainList.push_back("IPM3C18.XIFG");
  fDefaultAutogainList.push_back("IPM3C18.YIFG");
  fDefaultAutogainList.push_back("IPM3C19.XIFG");
  fDefaultAutogainList.push_back("IPM3C19.YIFG");
  fDefaultAutogainList.push_back("IPM3C03.YIFG");
  fDefaultAutogainList.push_back("IPM3P01.XIFG");
  fDefaultAutogainList.push_back("IPM3P01.YIFG");
  fDefaultAutogainList.push_back("IPM3P02A.XIFG");
  fDefaultAutogainList.push_back("IPM3P02A.YIFG");
  fDefaultAutogainList.push_back("IPM3P03A.XIFG");
  fDefaultAutogainList.push_back("IPM3P03A.YIFG");
  fDefaultAutogainList.push_back("IPM3P02B.XIFG");
  fDefaultAutogainList.push_back("IPM3P02B.YIFG");
  fDefaultAutogainList.push_back("IPM3C20.XIFG");
  fDefaultAutogainList.push_back("IPM3C20.YIFG");
  fDefaultAutogainList.push_back("IPM3C21.XIFG");
  fDefaultAutogainList.push_back("IPM3C21.YIFG");
  fDefaultAutogainList.push_back("IPM3H02.XIFG");
  fDefaultAutogainList.push_back("IPM3H02.YIFG");
  fDefaultAutogainList.push_back("IPM3H04.XIFG");
  fDefaultAutogainList.push_back("IPM3H04.YIFG");
  fDefaultAutogainList.push_back("IPM3H07A.XIFG");
  fDefaultAutogainList.push_back("IPM3H07A.YIFG");
  fDefaultAutogainList.push_back("IPM3H07B.XIFG");
  fDefaultAutogainList.push_back("IPM3H07B.YIFG");
  fDefaultAutogainList.push_back("IPM3H07C.XIFG");
  fDefaultAutogainList.push_back("IPM3H07C.YIFG");
  fDefaultAutogainList.push_back("IPM3H09.XIFG");
  fDefaultAutogainList.push_back("IPM3H09.YIFG");
  fDefaultAutogainList.push_back("IPM3H09B.XIFG");
  fDefaultAutogainList.push_back("IPM3H09B.YIFG");
}

Here is the caller graph for this function:

Bool_t QwEPICSEvent::IsNumber ( const string &  word )

inlineprivate

Definition at line 133 of file QwEPICSEvent.h.

Referenced by SetDataValue().

                                      {
    size_t pos;
    pos = word.find_first_not_of("0123456789.+-eE"); // white space not allowed
    if (pos != std::string::npos) return kFALSE;
    else return kTRUE;
  }

Here is the caller graph for this function:

Int_t QwEPICSEvent::LoadChannelMap

(

TString

mapfile

)

Definition at line 90 of file QwEPICSEvent.cc.

References AddEPICSTag(), QwLog::endl(), fBlinderReversalForRunTwo, fEPICSVariableList, fEPICSVariableType, fExtraHelicityReversal, fNominalWienAngle, fNumberEPICSVariables, fPrecessionReversal, kDebug, kEPICSFloat, kEPICSInt, kEPICSString, QwDebug, QwError, ResetCounters(), and QwParameterFile::TrimComment().

Referenced by main().

{
  Int_t lineread = 0;

  fNumberEPICSVariables = 0;
  fEPICSVariableList.clear();
  fEPICSVariableType.clear();

  fExtraHelicityReversal = 1;
  fBlinderReversalForRunTwo = kFALSE;
  fPrecessionReversal       = kFALSE;

  // Open the file
  QwParameterFile mapstr(mapfile.Data());
  std::string varname, varvalue;
  while (mapstr.ReadNextLine()) {
    lineread++;

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

    if (mapstr.HasVariablePair("=",varname,varvalue)){
      QwDebug << "QwEPICSEvent::LoadChannelMap:  keyword,value pair:"
        << varname << "," << varvalue << QwLog::endl;
      if (varname == "NominalWienAngle"){
  fNominalWienAngle = atof(varvalue.c_str());
      } else if (varname == "BlinderReversalForRunTwo"){
  if (! fBlinderReversalForRunTwo){
    fBlinderReversalForRunTwo = kTRUE;
    fExtraHelicityReversal = -1 * fExtraHelicityReversal;
  }
      } else if (varname == "PrecessionReversal"){
  if (! fPrecessionReversal){
    fPrecessionReversal = kTRUE;
    fExtraHelicityReversal = -1 * fExtraHelicityReversal;
  }
      } else {
  QwError << "QwEPICSEvent::LoadChannelMap: "
    << "Unknown keyword,variable pair: "
    << varname << "," << varvalue << QwLog::endl;
  exit(1);
      }
      continue;
    }

    varname = mapstr.GetTypedNextToken<std::string>();
    std::string dbtable = mapstr.GetTypedNextToken<std::string>();
    TString datatype    = mapstr.GetTypedNextToken<TString>();
    datatype.ToLower();

    if (datatype == "") {
      AddEPICSTag(varname,dbtable);
    } else {
      EQwEPICSDataType datatypeid = kEPICSString;
      if (datatype == "string")  datatypeid = kEPICSString;
      if (datatype == "float")   datatypeid = kEPICSFloat;
      if (datatype == "int")     datatypeid = kEPICSInt;
      AddEPICSTag(varname,dbtable,datatypeid);
    }
  }
  if (kDebug == 1) std::cout << "fNumberEPICSVariables = " << fNumberEPICSVariables << std::endl << std::endl;
  if (kDebug == 1) std::cout << "line read in the parameter file =" << lineread << std::endl;

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

Here is the call graph for this function:

Here is the caller graph for this function:

void QwEPICSEvent::PrintAverages

(

)

const

Definition at line 496 of file QwEPICSEvent.cc.

References fEPICSCumulativeData, fEPICSDataEvent, fEPICSVariableList, fEPICSVariableType, fNumberEPICSEvents, kEPICSFloat, kEPICSInt, and kEPICSString.

{
  Double_t mean     = 0.0;
  Double_t average_of_squares = 0.0;
  Double_t variance = 0.0;
  Double_t sigma    = 0.0;

  std::cout <<"#####  EPICS Event Summary from PrintAverages() #####\n"
      <<"Total number of EPICS events in this run == "
      <<fNumberEPICSEvents <<".\n\n"
      << std::setw(20) << std::setiosflags(std::ios::left) <<"Name"
      <<"\tMean        Sigma       "
      <<"Minimum     Maximum"<<std::endl;
  std::cout << "*****Non-string EPICS Variables*****" << std::endl;
  for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {
    if (fEPICSVariableType[tagindex] == kEPICSFloat ||
        fEPICSVariableType[tagindex] == kEPICSInt) {

      mean     = 0.0;
      variance = 0.0;
      sigma    = 0.0;
      if (fEPICSCumulativeData[tagindex].NumberRecords > 0){
  mean     = (fEPICSCumulativeData[tagindex].Sum)/
    ((Double_t) fEPICSCumulativeData[tagindex].NumberRecords);
  average_of_squares = (fEPICSCumulativeData[tagindex].SquaredSum)/
    ((Double_t) fEPICSCumulativeData[tagindex].NumberRecords);
  variance = average_of_squares - (mean * mean);
  if (variance < 0.0){
    sigma    = sqrt(-1.0 * variance);
  } else {
    sigma    = sqrt(variance);
  }

  std::cout << std::setw(20) << std::setiosflags(std::ios::left)
       <<fEPICSVariableList[tagindex]<<"\t"
      << std::setprecision(5) << std::setw(10)
      <<mean<<"  " << std::setw(10)<<sigma<<"  " << std::setw(10)
      <<fEPICSCumulativeData[tagindex].Minimum<<"  " << std::setw(10)
      <<fEPICSCumulativeData[tagindex].Maximum<<std::endl;
      } else {
  std::cout << std::setw(20) << std::setiosflags(std::ios::left)
      <<fEPICSVariableList[tagindex]<<"\t"
      << std::setprecision(5) << std::setw(10)
      << "...No data..."
      << std::endl;
      }
    }
  }

  std::cout << "*****String EPICS Variables are below, if any*****" << std::endl;
  for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {
    if (fEPICSVariableType[tagindex] == kEPICSString) {
      if (fEPICSDataEvent[tagindex].Filled) {
  std::cout << std::setw(20) << std::setiosflags(std::ios::left)
      <<"tagindex for variable "<< fEPICSVariableList[tagindex]<<"\t is "
      <<tagindex<<"\tand status is\t\t"
      <<fEPICSDataEvent[tagindex].StringValue;

  if (fEPICSCumulativeData[tagindex].NumberRecords!= fNumberEPICSEvents){
    std::cout << "\t*****\tThis variable changed during the run.  Only "
        << (Double_t(fEPICSCumulativeData[tagindex].NumberRecords)
      *100.0 / Double_t(fNumberEPICSEvents))
        << "% of the events has this value.";
  }
  std::cout <<std::endl;
      } else {
  std::cout << std::setw(20) << std::setiosflags(std::ios::left)
      <<fEPICSVariableList[tagindex]<<"\t"
      <<"No data..."<<std::endl;
      }
    }
  }
}

void QwEPICSEvent::PrintVariableList

(

)

const

Definition at line 571 of file QwEPICSEvent.cc.

References QwLog::endl(), fEPICSVariableList, and QwMessage.

Referenced by QwEPICSEvent().

{
  // Prints all valid Epics variables on the terminal while creating a rootfile.
  for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {
    QwMessage << "fEPICSVariableList[" << tagindex << "] == "
              << fEPICSVariableList[tagindex] << QwLog::endl;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QwEPICSEvent::ProcessOptions

(

QwOptions &

options

)

Process the configuration options.

Parse the configuration options and store in class fields

Parameters

options

Options object

Definition at line 83 of file QwEPICSEvent.cc.

References fDisableDatabase, and QwOptions::GetValue().

Referenced by main().

{
  // Option to disable EPICS database accesses
  fDisableDatabase = options.GetValue<bool>("disable-db-epics");
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< Double_t > QwEPICSEvent::ReportAutogains

(

std::vector< std::string >

tag_list = fDefaultAutogainList

)

Definition at line 581 of file QwEPICSEvent.cc.

References GetDataValue().

{
  std::vector<Double_t> autogain_values;
  std::vector<std::string>::iterator ptr_tag;

  autogain_values.clear(); //clear the vector first

  /*  Iterate through the input vector of the variable names     *
   *  and fill the output vector with the values.                */
  ptr_tag = tag_list.begin();
  while (ptr_tag < tag_list.end()) {
    autogain_values.push_back(GetDataValue(*ptr_tag));
    ptr_tag++;
  }

  return autogain_values;
}

Here is the call graph for this function:

void QwEPICSEvent::ReportEPICSData

(

)

const

Definition at line 601 of file QwEPICSEvent.cc.

References fEPICSCumulativeData, fEPICSDataEvent, fEPICSVariableList, fEPICSVariableType, fNumberEPICSEvents, kEPICSFloat, kEPICSInt, and kEPICSString.

{
  Double_t mean     = 0.0;
  Double_t average_of_squares = 0.0;
  Double_t variance = 0.0;
  Double_t sigma    = 0.0;


  std::ofstream output;
  TString theEPICSDataFile;
  theEPICSDataFile =  getenv("QW_TMP");
  theEPICSDataFile += "/QwEPICSData.txt";// puts QwEPICSData.txt in  QwAnalysis_DB_01.00.0000/scratch/tmp/ diretory.
  output.open(theEPICSDataFile,std::ofstream::out);

  if (output.is_open()) {


    output <<"#####  EPICS Event Summary  #####\n"
     <<"Total number of EPICS events in this run == "
     <<fNumberEPICSEvents <<".\n\n"
     << std::setw(20) << std::setiosflags(std::ios::left) <<"Name"
     <<"\tMean        Sigma       "
     <<"Minimum     Maximum"<<std::endl;
    for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {
      if (fEPICSVariableType[tagindex] == kEPICSFloat ||
    fEPICSVariableType[tagindex] == kEPICSInt) {
  mean     = 0.0;
  variance = 0.0;
  sigma    = 0.0;
  if (fEPICSCumulativeData[tagindex].NumberRecords > 0){
    mean     = (fEPICSCumulativeData[tagindex].Sum)/
      ((Double_t) fEPICSCumulativeData[tagindex].NumberRecords);
    average_of_squares = (fEPICSCumulativeData[tagindex].SquaredSum)/
      ((Double_t) fEPICSCumulativeData[tagindex].NumberRecords);
    variance = average_of_squares - (mean * mean);
    if (variance < 0.0){
      sigma    = sqrt(-1.0 * variance);
    } else {
      sigma    = sqrt(variance);
    }

    output << std::setw(20) << std::setiosflags(std::ios::left)
     <<fEPICSVariableList[tagindex]<<"\t"
     << std::setprecision(5) << std::setw(10)
     <<mean<<"  " << std::setw(10)<<sigma<<"  " << std::setw(10)
     <<fEPICSCumulativeData[tagindex].Minimum<<"  " << std::setw(10)
     <<fEPICSCumulativeData[tagindex].Maximum<<std::endl;
  } else {
    output << std::setw(20) << std::setiosflags(std::ios::left)
     <<fEPICSVariableList[tagindex]<<"\t"
     << std::setprecision(5) << std::setw(10)
     << "-No data-"
     << std::endl;
  }
      }

    }
    for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {
      if (fEPICSVariableType[tagindex] == kEPICSString) {
  if (fEPICSDataEvent[tagindex].Filled) {
    output << std::setw(20) << std::setiosflags(std::ios::left)
     <<fEPICSVariableList[tagindex]<<"\t"
     <<fEPICSDataEvent[tagindex].StringValue<<std::endl;
  } else {
    output << std::setw(20) << std::setiosflags(std::ios::left)
     <<fEPICSVariableList[tagindex]<<"\t"
     <<"No data..."<<std::endl;
  }
      }
    }

  } output.close();
}

void QwEPICSEvent::ResetCounters

(

)

Definition at line 675 of file QwEPICSEvent.cc.

References fEPICSCumulativeData, fEPICSDataEvent, fEPICSVariableList, fEPICSVariableType, fIsDataLoaded, fNumberEPICSEvents, and fNumberEPICSVariables.

Referenced by LoadChannelMap().

{
  fIsDataLoaded = kFALSE;
  /*  Verify that the variable list and variable type vectors
      are the same size, and agree with fNumberEPICSVariables.  */
  Int_t listlength = fEPICSVariableList.size();
  Int_t typelength = fEPICSVariableType.size();
  if (typelength != fNumberEPICSVariables ||
      listlength != fNumberEPICSVariables) {
    std::cerr << "The EPICS variable label and type arrays are not the same size!\n"
        << "EPICS readback may be corrupted!"<<std::endl;
  }
  /*  Reset the sizes of the fEPICSDataEvent and
      fEPICSCumulativeData vectors.                             */
  fEPICSDataEvent.resize(fNumberEPICSVariables);
  fEPICSCumulativeData.resize(fNumberEPICSVariables);
  for (size_t tagindex = 0; tagindex < fEPICSVariableList.size(); tagindex++) {
    fEPICSDataEvent[tagindex].Filled      = kFALSE;
    fEPICSDataEvent[tagindex].EventNumber = 0;
    fEPICSDataEvent[tagindex].Value       = 0.0;
    fEPICSDataEvent[tagindex].StringValue = "";
    fEPICSCumulativeData[tagindex].Filled        = kFALSE;
    fEPICSCumulativeData[tagindex].NumberRecords = 0;
    fEPICSCumulativeData[tagindex].Sum           = 0.0;
    fEPICSCumulativeData[tagindex].SquaredSum    = 0.0;
    fEPICSCumulativeData[tagindex].Minimum       = 0.0;
    fEPICSCumulativeData[tagindex].Maximum       = 0.0;
  }
  fNumberEPICSEvents = 0;
}

Here is the caller graph for this function:

void QwEPICSEvent::SetDataLoaded ( Bool_t  flag )

inlineprivate

Definition at line 96 of file QwEPICSEvent.h.

References fIsDataLoaded.

Referenced by ExtractEPICSValues(), and QwEPICSEvent().

{ fIsDataLoaded = flag; };

Here is the caller graph for this function:

int QwEPICSEvent::SetDataValue	(	const string &	tag,
		const double	value,
		const int	event
	)

Definition at line 436 of file QwEPICSEvent.cc.

References FindIndex().

Referenced by ExtractEPICSValues(), and SetDataValue().

{
  Int_t tagindex = FindIndex(tag);
  return (SetDataValue(tagindex, value, event));
}

Here is the call graph for this function:

Here is the caller graph for this function:

int QwEPICSEvent::SetDataValue	(	const string &	tag,
		const string &	value,
		const int	event
	)

Definition at line 442 of file QwEPICSEvent.cc.

References FindIndex(), and SetDataValue().

{
  Int_t tagindex = FindIndex(tag);
  return (SetDataValue(tagindex, value, event));
}

Here is the call graph for this function:

int QwEPICSEvent::SetDataValue	(	int	index,
		const double	value,
		const int	event
	)

Definition at line 448 of file QwEPICSEvent.cc.

References fEPICSDataEvent, kEPICS_Error, and kInvalidEPICSData.

{
  if (index == kEPICS_Error) return kEPICS_Error;
  if (index < 0)             return kEPICS_Error;

  if (value != kInvalidEPICSData) {
    fEPICSDataEvent[index].EventNumber = event;
    fEPICSDataEvent[index].Value       = value;
    fEPICSDataEvent[index].StringValue = "";
    fEPICSDataEvent[index].Filled      = kTRUE;
    return 0;
  }
  return kEPICS_Error;
}

int QwEPICSEvent::SetDataValue	(	int	index,
		const string &	value,
		const int	event
	)

Definition at line 463 of file QwEPICSEvent.cc.

References fEPICSDataEvent, fEPICSVariableType, IsNumber(), kEPICS_Error, kEPICSFloat, kEPICSInt, kEPICSString, kInvalidEPICSData, and SetDataValue().

{
  if (index == kEPICS_Error) return kEPICS_Error;
  if (index < 0)             return kEPICS_Error;

  Double_t tmpvalue = kInvalidEPICSData;
  switch (fEPICSVariableType[index]) {
  case kEPICSString:
    fEPICSDataEvent[index].EventNumber = event;
    fEPICSDataEvent[index].Value       = 0.0;
    fEPICSDataEvent[index].StringValue = value;
    fEPICSDataEvent[index].Filled      = kTRUE;
    return 0;
    break;

  case kEPICSFloat:
    if (IsNumber(value)) {
      tmpvalue = Double_t(atof(value.c_str()));
    }
    return SetDataValue(index, tmpvalue, event);
    break;

  case kEPICSInt:
    if(IsNumber(value)) {
      tmpvalue = Double_t(atol(value.c_str()));
    }
    return SetDataValue(index, tmpvalue, event);
    break;
  }

  return kEPICS_Error;
}

Here is the call graph for this function:

void QwEPICSEvent::SetDefaultAutogainList ( std::vector< std::string > &  input_list )

static

Definition at line 429 of file QwEPICSEvent.cc.

References fDefaultAutogainList.

{
  fDefaultAutogainList.clear();  //clear the vector first
  fDefaultAutogainList = input_list;
}

void QwEPICSEvent::WriteEPICSStringValues

(

)

Definition at line 1271 of file QwEPICSEvent.cc.

References QwLog::endl(), fEPICSDataEvent, fEPICSVariableList, fEPICSVariableType, kEPICSString, and QwDebug.

{
  QwDebug << "Entering QwEPICSEvent::WriteEPICSStringValues()"  << QwLog::endl;

  Bool_t local_debug = false;

  TSeqCollection *file_list = gROOT->GetListOfFiles();

  if (file_list) {
    
    Int_t size = file_list->GetSize();
    for (Int_t i=0; i<size; i++) 
      {
  TFile *file = (TFile*) file_list->At(i);

  if(local_debug) {
    std::cout << "QwEPICSEvent::WriteEPICSStringValue()"
        << file->GetName()
        << std::endl;
  }
  
  TTree *slow_tree = (TTree*) file->Get("Slow_Tree");
  
  for (std::size_t tagindex=0; tagindex<fEPICSVariableList.size(); tagindex++) 
    {
      // only String 
      if (fEPICSVariableType[tagindex] == kEPICSString) {
        
        TString name = fEPICSVariableList[tagindex];
        name.ReplaceAll(':','_'); // remove colons before creating branch
        TString name_type = name + "/C";\

        Char_t epics_char[128];
        TString epics_string;

        TBranch *new_branch = slow_tree->Branch(name, epics_char, name_type);
        
        if (fEPICSDataEvent[tagindex].Filled) {
    epics_string = fEPICSDataEvent[tagindex].StringValue;
        } 
        else {
    epics_string = "empty";
        }

        if(local_debug) {
    std::cout << "QwEPICSEvent::WriteEPICSStringValue()\n";
    std::cout << name << " " << epics_string << std::endl;
    std::cout <<"\n";
        }

        sprintf(epics_char, "%s", epics_string.Data());
        new_branch->Fill();
      }
      
    }

  file -> Write("", TObject::kOverwrite);
      }
  }

  QwDebug << "Leaving QwEPICSEvent::WriteEPICSStringValues() normally"  << QwLog::endl;

  return;
  
}

Here is the call graph for this function:

Field Documentation

Bool_t QwEPICSEvent::fBlinderReversalForRunTwo

private

Definition at line 173 of file QwEPICSEvent.h.

Referenced by LoadChannelMap().

std::vector< std::string > QwEPICSEvent::fDefaultAutogainList

staticprivate

Default autogain list.

Definition at line 116 of file QwEPICSEvent.h.

Referenced by GetDefaultAutogainList(), InitDefaultAutogainList(), and SetDefaultAutogainList().

bool QwEPICSEvent::fDisableDatabase

private

Definition at line 130 of file QwEPICSEvent.h.

Referenced by FillDB(), and ProcessOptions().

std::vector<EPICSCumulativeRecord> QwEPICSEvent::fEPICSCumulativeData

private

Definition at line 160 of file QwEPICSEvent.h.

Referenced by CalculateRunningValues(), FillSlowControlsData(), FillSlowControlsSettings(), PrintAverages(), ReportEPICSData(), and ResetCounters().

std::vector<EPICSVariableRecord> QwEPICSEvent::fEPICSDataEvent

private

Definition at line 146 of file QwEPICSEvent.h.

Referenced by CalculateRunningValues(), ExtractEPICSValues(), FillSlowControlsSettings(), FillSlowControlsStrigs(), FillTreeVector(), GetDataString(), GetDataValue(), GetEPICSStringValues(), PrintAverages(), ReportEPICSData(), ResetCounters(), SetDataValue(), and WriteEPICSStringValues().

std::vector<std::string> QwEPICSEvent::fEPICSTableList

private

Definition at line 166 of file QwEPICSEvent.h.

Referenced by AddEPICSTag(), FillSlowControlsData(), and FillSlowControlsStrigs().

std::vector<std::string> QwEPICSEvent::fEPICSVariableList

private

Definition at line 165 of file QwEPICSEvent.h.

Referenced by AddEPICSTag(), CalculateRunningValues(), ConstructBranchAndVector(), ExtractEPICSValues(), FillSlowControlsData(), FillSlowControlsSettings(), FillSlowControlsStrigs(), FillTreeVector(), GetEPICSStringValues(), LoadChannelMap(), PrintAverages(), PrintVariableList(), ReportEPICSData(), ResetCounters(), and WriteEPICSStringValues().

std::map<std::string,Int_t> QwEPICSEvent::fEPICSVariableMap

private

Definition at line 169 of file QwEPICSEvent.h.

Referenced by AddEPICSTag(), and FindIndex().

std::vector<EQwEPICSDataType> QwEPICSEvent::fEPICSVariableType

private

Definition at line 167 of file QwEPICSEvent.h.

Referenced by AddEPICSTag(), CalculateRunningValues(), ConstructBranchAndVector(), FillSlowControlsData(), FillSlowControlsStrigs(), FillTreeVector(), GetDataString(), GetEPICSStringValues(), LoadChannelMap(), PrintAverages(), ReportEPICSData(), ResetCounters(), SetDataValue(), and WriteEPICSStringValues().

Int_t QwEPICSEvent::fExtraHelicityReversal

private

Definition at line 177 of file QwEPICSEvent.h.

Referenced by DetermineIHWPPolarity(), and LoadChannelMap().

Bool_t QwEPICSEvent::fIsDataLoaded

private

Definition at line 95 of file QwEPICSEvent.h.

Referenced by ExtractEPICSValues(), HasDataLoaded(), ResetCounters(), and SetDataLoaded().

Double_t QwEPICSEvent::fNominalWienAngle

private

Definition at line 176 of file QwEPICSEvent.h.

Referenced by DetermineWienMode(), and LoadChannelMap().

Int_t QwEPICSEvent::fNumberEPICSEvents

private

Definition at line 163 of file QwEPICSEvent.h.

Referenced by CalculateRunningValues(), FillSlowControlsSettings(), PrintAverages(), ReportEPICSData(), and ResetCounters().

Int_t QwEPICSEvent::fNumberEPICSVariables

private

Definition at line 164 of file QwEPICSEvent.h.

Referenced by AddEPICSTag(), CalculateRunningValues(), LoadChannelMap(), and ResetCounters().

Bool_t QwEPICSEvent::fPrecessionReversal

private

Definition at line 174 of file QwEPICSEvent.h.

Referenced by FillSlowControlsSettings(), and LoadChannelMap().

size_t QwEPICSEvent::fTreeArrayIndex

private

Definition at line 91 of file QwEPICSEvent.h.

Referenced by ConstructBranchAndVector(), and FillTreeVector().

size_t QwEPICSEvent::fTreeArrayNumEntries

private

Definition at line 92 of file QwEPICSEvent.h.

Referenced by ConstructBranchAndVector().

const int QwEPICSEvent::kDebug = 0

staticprivate

Definition at line 123 of file QwEPICSEvent.h.

Referenced by CalculateRunningValues(), ExtractEPICSValues(), LoadChannelMap(), and QwEPICSEvent().

const int QwEPICSEvent::kEPICS_Error = -1

staticprivate

Definition at line 124 of file QwEPICSEvent.h.

Referenced by ExtractEPICSValues(), FillSlowControlsSettings(), FindIndex(), GetDataString(), GetDataValue(), and SetDataValue().

const int QwEPICSEvent::kEPICS_OK = 1

staticprivate

Definition at line 125 of file QwEPICSEvent.h.

const Double_t QwEPICSEvent::kInvalidEPICSData = -999999.0

staticprivate

Definition at line 126 of file QwEPICSEvent.h.

Referenced by GetDataValue(), and SetDataValue().

---

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

• QwEPICSEvent.h
• QwEPICSEvent.cc