PREAN/TFndPreanScalers.cxx

// @(#)fROOT/PREAN:$Name:  $:$Id: TFndPreanScalers.cxx,v 1.3 2007/09/05 10:15:21 Diego_Faso Exp $
// Author: H. So , 2006/05/29

#include "TFndPreanScalers.h"

//______________________________________________________________________________
// TFndPreanScalers
//
// Preanalyzer for scaler data.  It is a fROOT version of readscaler daemon.
//
// Technical note: this class is a non-copyable singleton class.  Default
// constructor is hidden from users, and copy constructor / assignment
// operator are not implemented on purpose.  All accesses to the singleton
// instance should be done via Instance() static method.  A global pointer
// like gFndPreanScalers could have been added for users' convinience, but
// this idea was discarded due to thread-safety and efficiency.  It is
// recommended for users to save the pointer returned by Instance() for
// repetead use.
//
// The comment below, copied from the original source, shows the raw event
// structure relevant to scalers analysis.
//
//                                                                                       //
//      Original code: readscaler: a daemon to read the FINUDA scaler values             //
//                     written by S. Piano, F. Pompili, G. Simonetti on Aug. 2003        //
//                                                                                       //
//
//            GLOBAL EVENT HEADER
//
//      RawEvent[0] -----> GLOBAL EVENT LENGTH
//      RawEvent[1] -----> EVENT NUMBER (Hardware)
//      RawEvent[2] -----> EVENT NUMBER (Software)
//      RawEvent[3] -----> RUN TYPE
//      RawEvent[4] -----> RUN NUMBER
//      RawEvent[5] -----> Run starting time (unix format)
//      RawEvent[6] -----> elapsed time from run start
//      RawEvent[7] -----> GTS pointer == 16
//      RawEvent[8] -----> TOF pointer
//      RawEvent[9] -----> ISI pointer
//      RawEvent[10] ----> OSI pointer
//      RawEvent[11] ----> LMD pointer
//      RawEvent[12] ----> STB pointer
//       ... ...         ... ... ... ...
//      RawEvent[15] ----> 0 END OF GLOBAL EVENT HEADER
//
//            GTS EVENT BUFFER
//
//     RawEvent[16+0 =16] -----> EVENT LENGTH = HEADER LENGTH + k (k = number of read data)
//     RawEvent[16+1 =17] -----> EVENT NUMBER (Hardware)
//     RawEvent[16+2 =18] -----> DETECTOR IDENTIFIER (GTS)
//     RawEvent[16+3 =19] -----> RUN NUMBER
//     RawEvent[16+4 =20] -----> EVENT NUMBER (Software)
//     RawEvent[16+5 =21] -----> HEADER LENGTH (36)
//
//     RawEvent[16+6 =22] -----> EQUIPMENT  1 POINTER: CORBO
//     RawEvent[16+8 =24] -----> EQUIPMENT  3 POINTER: VME TRIGGER SELECTOR
//     RawEvent[16+9 =25] -----> EQUIPMENT  4 POINTER: VME PATTERN UNIT
//     RawEvent[16+10=26] -----> EQUIPMENT  5 POINTER: VME SCALER
//     RawEvent[16+31=47] -----> EQUIPMENT 26 POINTER: CAMAC TDC (LECROY 2229)
//     RawEvent[16+36=52] -----> FIRST DATUM
//
//     scp=RawEvent[26]+16
//
//     (5) VME SCALER
//      RawEvent[scp+0] ----> length
//      RawEvent[scp+1] ----> scaler V1 config. (cascading)
//      RawEvent[scp+2] ----> MULT 2-7 (HYP)
//      RawEvent[scp+3] ----> MULT 2-7 (BHA)
//      RawEvent[scp+4] ----> BTB-MB
//      RawEvent[scp+5] ----> BTB-EL
//      RawEvent[scp+6] ----> PC (Prompt Coincidence)
//      RawEvent[scp+7] ----> Presc BTB-MB
//      RawEvent[scp+8] ----> OR-MB
//      RawEvent[scp+9] ----> OR-EL
//      RawEvent[scp+10] ---> HYP
//      RawEvent[scp+11] ---> BHA
//      RawEvent[scp+12] ---> Presc BHA
//      RawEvent[scp+13] ---> Presc BTB-EL
//      RawEvent[scp+14] ---> OR-TOFONE
//      RawEvent[scp+15] ---> Presc OR-MB
//      RawEvent[scp+16] ---> Total Triggers
//      RawEvent[scp+17] ---> TIME (100 Hz)
//
//      RawEvent[scp+18] ---> scaler V2 config. (cascading)
//      RawEvent[scp+19] ---> MULT 2-7 (HYP)
//      RawEvent[scp+20] ---> MULT 2-7 (BHA)
//      RawEvent[scp+21] ---> BTB-MB
//      RawEvent[scp+22] ---> BTB-EL
//      RawEvent[scp+23] ---> PC (Prompt Coincidence)
//      RawEvent[scp+24] ---> Presc BTB-MB
//      RawEvent[scp+25] ---> OR-MB
//      RawEvent[scp+26] ---> OR-EL
//      RawEvent[scp+27] ---> HYP
//      RawEvent[scp+28] ---> BHA
//      RawEvent[scp+29] ---> Presc BHA
//      RawEvent[scp+30] ---> Presc BTB-EL
//      RawEvent[scp+31] ---> OR-TOFONE
//      RawEvent[scp+32] ---> Presc OR-MB
//      RawEvent[scp+33] ---> Total Triggers
//      RawEvent[scp+34] ---> TIME (100 Hz)
//
//      RawEvent[scp+35] ---> scaler V3 config (cascading)
//      RawEvent[scp+36] ---> HYP
//      RawEvent[scp+37] ---> BHA
//      RawEvent[scp+38] ---> Presc OR-EL
//      RawEvent[scp+39] ---> BTB-EL
//      RawEvent[scp+40] ---> OR TOFONE
//      RawEvent[scp+41] ---> LASER photodiode
//      RawEvent[scp+42] ---> OR TOFINO
//      RawEvent[scp+43] ---> SC (Slow Coincidence)
//      RawEvent[scp+44] ---> void
//      RawEvent[scp+45] ---> ORTofino*ORTofone
//      RawEvent[scp+46] ---> void
//      RawEvent[scp+47] ---> void
//      RawEvent[scp+48] --->      |canali
//      RawEvent[scp+49] ---> RF/4 |in cascata
//      RawEvent[scp+50] ---> trigger*busy
//      RawEvent[scp+51] ---> TIME (100 Hz)
//
//      RawEvent[scp+52] ---> scaler V4 config (cascading)
//      RawEvent[scp+53] ---> HYP
//      RawEvent[scp+54] ---> BHA
//      RawEvent[scp+55] ---> Presc OR-EL
//      RawEvent[scp+56] ---> BTB-EL
//      RawEvent[scp+57] ---> OR TOFONE
//      RawEvent[scp+58] ---> LASER photodiode
//      RawEvent[scp+59] ---> OR TOFINO
//      RawEvent[scp+60] ---> SC (Slow Coincidence)
//      RawEvent[scp+61] ---> void
//      RawEvent[scp+62] ---> ORTofino*ORTofone
//      RawEvent[scp+63] ---> void
//      RawEvent[scp+64] ---> void
//      RawEvent[scp+65] --->      |canali
//      RawEvent[scp+66] ---> RF/4 |in cascata
//      RawEvent[scp+67] ---> trigger*busy
//      RawEvent[scp+68] ---> TIME (100 Hz)
//
//      RawEvent[scp+69] ---> Scaler TOFINO config (cascading)
//      RawEvent[scp+70] ---> Tofino MT 1
//      RawEvent[scp+71] ---> Tofino MT 2
//      RawEvent[scp+72] ---> Tofino MT 3
//      RawEvent[scp+73] ---> Tofino MT 4
//      RawEvent[scp+74] ---> Tofino MT 5
//      RawEvent[scp+75] ---> Tofino MT 6
//      RawEvent[scp+76] ---> Tofino MT 7
//      RawEvent[scp+77] ---> Tofino MT 8
//      RawEvent[scp+78] ---> Tofino MT 9
//      RawEvent[scp+79] ---> Tofino MT 10
//      RawEvent[scp+80] ---> Tofino MT 11
//      RawEvent[scp+81] ---> Tofino MT 12

#include <cerrno>
#include <stdexcept>
#include <sstream>
#include <TMutex.h>

#include "TFndPrean.h"
#include "TFndEnv.h"

using namespace std;

ClassImp(TFndPreanScalers)

static TVirtualMutex *fgMutex = NULL;

//______________________________________________________________________________
TFndPreanScalers *TFndPreanScalers::Instance()
{
  // Returns a pointer to the global instance of this class.  The instance is
  // created when this function is called for the first time.

  R__LOCKGUARD2(fgMutex);
  static TFndPreanScalers instance;
  return &instance;
}

//______________________________________________________________________________
TFndPreanScalers::Data::Data(const UInt_t rawEvent[])
{
  const UInt_t *pEvh = rawEvent;        // pointer to Global Event Header
  const UInt_t *pGts = pEvh + kEvhLen;  // pointer to GTS buffer
  const UInt_t *pScb = pGts + pGts[10]; // pointer to VME scalers buffer
  memcpy(evh, pEvh, sizeof(evh));
  memcpy(gts, pGts, sizeof(gts));
  memcpy(scb, pScb, sizeof(scb));
}

//______________________________________________________________________________
TFndPreanScalers::TFndPreanScalers()
  : fDatime(), fSavedTime(), fSavedDay(), fSavedFif(),
    fV0(), fBhaInt(), fBhaInt0(), fHypInt(), fHypInt0(), fSavedEvNum()
{
  // Default constructor.
  //
  // Throws std::runtime_error if it is not possible to open the fast files.

  fCurTime = fDatime.Convert();
  fSavedDay = fCurTime / kSecondsPerDay ;
  fSavedFif = fCurTime / kScalerInterval ;

  TFndEnv *env = TFndEnv::Instance();
  const char *pathDafne = env->GetValue("froot.PreAnalysis.PathDafne", "/data02/fnddafne", "FND_PREAN_SHR");
  fPath[0] = FROOT::ConcatFileName(pathDafne, env->GetValue("froot.PreAnalysis.DirReadScaler", "readscaler"));
  fPath[1] = FROOT::ConcatFileName(pathDafne, env->GetValue("froot.PreAnalysis.DirRunInfo", "runinfo"));

  fFastFd[0] = fFastFd[1] = -1;

  if (RecreateFastFiles() < 0)
    throw std::runtime_error("Cannot proceed scalers preanalysis");
}

//______________________________________________________________________________
TFndPreanScalers::~TFndPreanScalers()
{
  // Destroys the object.  Raw files and fast files are closed.  Since the
  // class is a singleton class this method will be called only when the
  // program is stopped or the library is unloaded.

  CloseRawFiles();
  CloseFastFiles();
}

//______________________________________________________________________________
Int_t TFndPreanScalers::RecreateFastFiles()
{
  // Creates or recreates fast files.
  //
  // Returns 0 on success, -1 on error.

  TString readScalerFastFileName, runInfoFastFileName;
  readScalerFastFileName.Form("%s/finuda_stat.fast", fPath[0].Data());
  runInfoFastFileName.Form("%s/runinfo_stat.fast", fPath[1].Data());

  if (fFastFd[0] >= 0 && TEMP_FAILURE_RETRY(close(fFastFd[0])) < 0)
    Warning("RecreateFastFiles", "Cannot close previous readscaler fast file: %s", strerror(errno));
  if (fFastFd[1] >= 0 && TEMP_FAILURE_RETRY(close(fFastFd[1])) < 0)
    Warning("RecreateFastFiles", "Cannot close previous runinfo fast file: %s", strerror(errno));

  int ret = 0;
  if ((fFastFd[0] = TEMP_FAILURE_RETRY(creat(readScalerFastFileName.Data(), 0644))) < 0) {
    Error("RecreateFastFiles", "Cannot create readscaler fast file: %s", strerror(errno));
    ret = -1;
  }
  if ((fFastFd[1] = TEMP_FAILURE_RETRY(creat(runInfoFastFileName.Data(), 0644))) < 0) {
    Error("RecreateFastFiles", "Cannot create runinfo fast file: %s", strerror(errno));
    ret = -1;
  }
  return ret;
}

//______________________________________________________________________________
Int_t TFndPreanScalers::WriteFastFiles(const string &readScalerText, const string &runInfoText)
{
  // Writes pre-generated text in fast files.
  //
  // Returns 0 on success, -1 on error.

  int ret = 0;
  if (lseek(fFastFd[0], 0, SEEK_SET) < 0 ||
      TEMP_FAILURE_RETRY(ftruncate(fFastFd[0], 0)) < 0 ||
      TEMP_FAILURE_RETRY(write(fFastFd[0], readScalerText.c_str(), readScalerText.size())) < 0) {
    Error("WriteFastFiles", "Cannot update readscaler fast file: %s", strerror(errno));
    ret = -1;
  }
  if (lseek(fFastFd[1], 0, SEEK_SET) < 0 ||
      TEMP_FAILURE_RETRY(ftruncate(fFastFd[1], 0)) < 0 ||
      TEMP_FAILURE_RETRY(write(fFastFd[1], runInfoText.c_str(), runInfoText.size())) < 0) {
    Error("WriteFastFiles", "Cannot update runinfo fast file: %s", strerror(errno));
    ret = -1;
  }
  return ret;
}

//______________________________________________________________________________
Int_t TFndPreanScalers::CloseFastFiles()
{
  // Closes fast files.
  //
  // Returns 0 on success, -1 on error.

  int ret = 0;
  if (fFastFd[0] >= 0 && TEMP_FAILURE_RETRY(close(fFastFd[0])) < 0) {
    Error("CloseFastFiles", "Cannot close readscaler fast file: %s", strerror(errno));
    ret = -1;
  }
  fFastFd[0] = -1;
  if (fFastFd[1] >= 0 && TEMP_FAILURE_RETRY(close(fFastFd[1])) < 0) {
    Error("CloseFastFiles", "Cannot close readscaler fast file: %s", strerror(errno));
    ret = -1;
  }
  fFastFd[1] = -1;
  return ret;
}

//______________________________________________________________________________
Int_t TFndPreanScalers::OpenRawFiles()
{
  // Opens raw files based on date.  Note that the date is specified by
  // fDatime and may be different from the current date.
  //
  // Returns 0 on success, -1 on error.

  int ret = 0;
  if (!fRawFile[0].is_open()) {
    TString str;
    str.Form("%s/%04d%02d%02d.raw", fPath[0].Data(), fDatime.GetYear(), fDatime.GetMonth(), fDatime.GetDay());
    fRawFile[0].clear();
    fRawFile[0].open(str, ofstream::app);
    if (!fRawFile[0]) {
      Error("OpenRawFiles", "%s: %s", str.Data(), strerror(errno));
      ret = -1;
    }
  }
  if (!fRawFile[1].is_open()) {
    TString str;
    str.Form("%s/%04d%02d%02d.raw", fPath[1].Data(), fDatime.GetYear(), fDatime.GetMonth(), fDatime.GetDay());
    fRawFile[1].clear();
    fRawFile[1].open(str, ofstream::app);
    if (!fRawFile[1]) {
      Error("OpenRawFiles", "%s: %s", str.Data(), strerror(errno));
      ret = -1;
    }
  }
  return ret;
}

//______________________________________________________________________________
Int_t TFndPreanScalers::CloseRawFiles()
{
  // Closes raw files currently open.
  //
  // Returns 0 on success, -1 on error.

  int ret = 0;
  if (fRawFile[0].is_open()) {
    fRawFile[0].clear();
    fRawFile[0].close();
    if (!fRawFile[0]) {
      Error("CloseRawFiles", "Cannot close readscaler file: %s", strerror(errno));
      ret = -1;
    }
  }
  if (fRawFile[1].is_open()) {
    fRawFile[1].clear();
    fRawFile[1].close();
    if (!fRawFile[1]) {
      Error("CloseRawFiles", "Cannot close runinfo file: %s", strerror(errno));
      ret = -1;
    }
  }
  return ret;
}

//______________________________________________________________________________
Int_t TFndPreanScalers::WriteRawFiles(const string &scalerText, const string &scalerInfoText)
{
  // Writes pre-generated text in raw files.
  //
  // Returns 0 on success, -1 on error.

  int ret = 0;
  if (!(fRawFile[0] << scalerText << flush)) {
    Error("WriteRawFiles", "Cannot write to readscaler file: %s", strerror(errno));
    ret = -1;
  }
  if (!(fRawFile[1] << scalerInfoText << flush)) {
    Error("WriteRawFiles", "Cannot write to runinfo file: %s", strerror(errno));
    ret = -1;
  }
  return ret;
}

//______________________________________________________________________________
void TFndPreanScalers::CalculateRate(const UInt_t v[], const UInt_t v0[], Float_t vr[])
{
  // Calcluates event rates and save them in vr.

  Float_t tempo = (v[17] - v0[17]) / 100.;
  memset(vr, 0, sizeof(vr));
  for (Int_t i = 2; i < 18; i++)
    vr[i] = (v[i] - v0[i]) / tempo;
  for (Int_t i = 19; i < 35; i++)
    vr[i] = (v[i] - v0[i]) / tempo;
  for (Int_t i = 36; i < 52; i++) {
    switch (i) {
    case 44: case 46: case 47: break; // void: nothing to do
    case 48: break;                   // high word of RF/4: cannot be used alone
    case 49:                          // 64bit calculation - don't forget that UInt_t is usually 32bit.
      vr[i] = (FROOT::Convert64(v[48], v[49]) - FROOT::Convert64(v0[48], v0[49])) / tempo;
      break;
    default:
      vr[i] = (v[i] - v0[i]) / tempo;
    }
  }
  for (Int_t i = 53; i < 69; i++) {
    switch (i) {
    case 61: case 63: case 64: break; // void: nothing to do
    case 65: break;                   // high word of RF/4: cannot be used alone
    case 66:                          // 64bit calculation - don't forget that UInt_t is usually 32bit.
      vr[i] = (FROOT::Convert64(v[65], v[66]) - FROOT::Convert64(v0[65], v0[66])) / tempo;
      break;
    default:
      vr[i] = (v[i] - v0[i]) / tempo;
    }
  }
  for (Int_t i = 70; i < 82; i++)
    vr[i] = (v[i] - v0[i]) / tempo;
}

//______________________________________________________________________________
string TFndPreanScalers::GenerateReadScalerText(const UInt_t evh[], const Float_t vr[], UInt_t daqStatus)
{
  // Generate text for writing readscaler raw/fast files.
  //
  // Returns generated std::string.

  ostringstream ss;
  ss << fCurTime
     << " " << evh[1] << " " << evh[2] << " " << evh[3] << " " << evh[4]
     << " " << vr[4] << " " << vr[5] << " " << vr[8] << " " << vr[9]
     << " " << vr[11] << " " << vr[14] << " " << vr[16] << " " << vr[17]
     << " " << vr[70] << " " << vr[71] << " " << vr[72] << " " << vr[73]
     << " " << vr[74] << " " << vr[75] << " " << vr[76] << " " << vr[77]
     << " " << vr[78] << " " << vr[79] << " " << vr[80] << " " << vr[81]
     << " " << daqStatus << " " << fBhaInt0 << " " << fHypInt0 << " " << endl;
  if (!ss)
    Warning("GenerateReadScalerText", "Failed");
  return ss.str();
}

//______________________________________________________________________________
string TFndPreanScalers::GenerateRunInfoText(const UInt_t evh[], const UInt_t gts[], const Float_t vr[], UInt_t daqStatus)
{
  // Generate text for writing runinfo raw/fast files.
  //
  // Returns generated std::string.

  ostringstream ss;
  ss << fCurTime
     << " " << evh[1] << " " << evh[2] << " " << evh[3] << " " << evh[4]
     << " " << evh[5] << " " << evh[6] << " " << evh[7] << " " << evh[8]
     << " " << evh[9] << " " << evh[10] << " " << evh[11] << " " << evh[12]
     << " " << gts[10]
     << " " << vr[2] << " " << vr[3] << " " << vr[4] << " " << vr[5]
     << " " << vr[6] << " " << vr[7] << " " << vr[8] << " " << vr[9]
     << " " << vr[10] << " " << vr[11] << " " << vr[12] << " " << vr[13]
     << " " << vr[14] << " " << vr[15] << " " << vr[16] << " " << vr[17]
     << " " << vr[19] << " " << vr[20] << " " << vr[21] << " " << vr[22]
     << " " << vr[23] << " " << vr[24] << " " << vr[25] << " " << vr[26]
     << " " << vr[27] << " " << vr[28] << " " << vr[29] << " " << vr[30]
     << " " << vr[31] << " " << vr[32] << " " << vr[33] << " " << vr[34]
     << " " << vr[36] << " " << vr[37] << " " << vr[38] << " " << vr[39]
     << " " << vr[40] << " " << vr[41] << " " << vr[42] << " " << vr[43]
     << " " << vr[45] << " " << "0" << " " << vr[49] << " " << vr[50]
     << " " << vr[51] << " " << vr[53] << " " << vr[54] << " " << vr[55]
     << " " << vr[56] << " " << vr[57] << " " << vr[58] << " " << vr[59]
     << " " << vr[60] << " " << vr[62] << " " << "0" << " " << vr[66]
     << " " << vr[67] << " " << vr[68] << " " << vr[70] << " " << vr[71]
     << " " << vr[72] << " " << vr[73] << " " << vr[74] << " " << vr[75]
     << " " << vr[76] << " " << vr[77] << " " << vr[78] << " " << vr[79]
     << " " << vr[80] << " " << vr[81] << " " << daqStatus << " " << endl;
  if (!ss)
    Warning("GenerateRunInfoText", "Failed");
  return ss.str();
}

//______________________________________________________________________________
Int_t TFndPreanScalers::Write(const Data &data)
{
  // Writes data in files and save information for later use.  Destination raw
  // files are decided based on the current date.
  //
  // Returns 0 on success, -1 on error.

  int ret = 0;

  // event number (hardware)
  UInt_t evNum = data.evh[1];

  // DAQ status: kStopped in offline mode, one of EDaqStatus in online mode.
  Int_t daqStatus = data.evh[15];
  if (evNum == fSavedEvNum && daqStatus == kActive)
    daqStatus = kCrashed;

  fDatime.Set();
  if (OpenRawFiles() < 0) {
    Error("Write", "cannot open scaler files");
    return -1;
  }

  fCurTime = fDatime.Convert();
  UInt_t curDay  = fCurTime / kSecondsPerDay;
  if (curDay > fSavedDay) {
    // new day - close old file and open new one
    fSavedDay = curDay;

    if (CloseRawFiles() < 0) {
      Error("Write", "cannot close old scaler files");
      return -1;
    }
    if (OpenRawFiles() < 0) {
      Error("Write", "cannot open new scaler files");
      return -1;
    }
  }

  Float_t vr[kScbLen];
  CalculateRate(data.scb, fV0, vr);
  fBhaInt += data.scb[11] - fV0[11];
  fHypInt += data.scb[10] - fV0[10];

  UInt_t curFif  = fCurTime / kScalerInterval;
  if (curFif > fSavedFif) {
    fSavedFif = curFif;
    fBhaInt0  = fBhaInt;
    fBhaInt   = 0;
    fHypInt0  = fHypInt;
    fHypInt   = 0;
  }

  const string &readScalerText = GenerateReadScalerText(data.evh, vr, daqStatus);
  const string &runInfoText    = GenerateRunInfoText(data.evh, data.gts, vr, daqStatus);

  if (WriteFastFiles(readScalerText, runInfoText) < 0)
    ret = -1;

  if ((fCurTime % kScalerInterval == 0 && fCurTime != fSavedTime) || daqStatus == kStopped) {
    fSavedTime = fCurTime;
    if (WriteRawFiles(readScalerText, runInfoText) < 0)
      ret = -1;
  }

  memcpy(fV0, data.scb, sizeof(fV0));
  fSavedEvNum = evNum;

  return ret;
}

---