JTuna.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <iomanip>
#include <limits>
#include <vector>
#include <set>
#include <map>

#include "TROOT.h"
#include "TFile.h"
#include "TGraph.h"
#include "TNamed.h"
#include "TString.h"
#include "TRegexp.h"

#include "JDB/JDB.hh"
#include "JDB/JSelector.hh"
#include "JDB/JSelectorSupportkit.hh"
#include "JDB/JDBToolkit.hh"
#include "JDB/JDetectorIntegration_t.hh"
#include "JDB/JProductRouter.hh"
#include "JDB/JAllParams.hh"
#include "JDB/JDatalogNumbers.hh"
#include "JDB/JDatalog.hh"
#include "JDB/JSupport.hh"

#include "JTools/JRange.hh"
#include "JSupport/JFileRecorder.hh"
#include "JLang/JLangToolkit.hh"

#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

namespace {

  const char FILTER = '!';   //!< negate filter option
}


/**
 * \file
 *
 * Auxiliary program to convert slow control data from the database to ROOT TTree.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
 
  typedef JRange<int>  JRange_t;

  JFileRecorder<JTYPELIST<JDatalog, TGraph, TNamed>::typelist> outputFile;
  string          usr;
  string          pwd;
  string          cookie;
  string          detid;
  JRange_t        runs           = JRange_t::DEFAULT_RANGE;
  long long int   numberOfRows;
  vector<string>  filter;
  set<string>     locate;
  int             prescale;
  bool            graph;
  JSelector       selection;
  int             debug;

  locate.insert("pmt_id");
  locate.insert("pmt_threshold");
  locate.insert("pmt_threshold@");
  locate.insert("pmt_highvolt");
  locate.insert("pmt_highvolt@");

  try {

    JParser<> zap("Auxiliary program to convert slow control data from the database to ROOT TTree.");
    
    zap['u'] = make_field(usr)           = "";
    zap['!'] = make_field(pwd)           = "";
    zap['C'] = make_field(cookie)        = "";
    zap['o'] = make_field(outputFile);
    zap['D'] = make_field(detid,        "Detector identifier");
    zap['R'] = make_field(runs,         "Run range");
    zap['n'] = make_field(numberOfRows, "Maximal number of rows")         = numeric_limits<long long int>::max();
    zap['F'] = make_field(filter,       "Filter parameter")               = JPARSER::initialised();
    zap['L'] = make_field(locate,       "Locate parameter")               = JPARSER::initialised();
    zap['P'] = make_field(prescale,     "Prescale sampling of data")      = 1;
    zap['G'] = make_field(graph,        "Write TGraph instead of TTree");
    zap['@'] = make_field(selection,    "Possible selections: " << JEEPZ() << getColumns<JDatalogNumbers>())  = JPARSER::initialised();
    zap['d'] = make_field(debug)         = 2;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }

  filter.push_back(MAKE_STRING(FILTER << "CLBControlTimeoutMS"));

  if (runs.getUpperLimit() < runs.getLowerLimit()) {
    runs.setUpperLimit(runs.getLowerLimit());
  }

  if (prescale < 1) {
    WARNING("Setting prescale to one." << endl);
    prescale = 1;
  }

  struct JGraph_t {

    JGraph_t() :
      counter(0)
    {}

    void put(const Double_t x, const Double_t y)
    {
      X.push_back(x);
      Y.push_back(y);
    }

    int counter;

    vector<Double_t> X;
    vector<Double_t> Y;
  };

  typedef map<string, JGraph_t>    map_type;

  vector< vector< map_type > >     data;

  set<int> strings;
  set<int> floors;

  map<string, int>                 warnings;
  map<string, int>                 errors;
  map<string, double>              unit;

  outputFile.open();

  if (!outputFile.is_open()) {
    FATAL("Error opening file: " << outputFile << endl);
  }

  try {

    JDB::reset(usr, pwd, cookie);

    if (is_integer(detid)) {
      detid = getDetector(to_value<int>(detid));
    }

    JDetectorIntegration_t detector;

    {
      DEBUG("Reading database table " << getTable<JDetectorIntegration_t>() << endl); 

      ResultSet& rs  = getResultSet(getTable<JDetectorIntegration_t>());

      if (! (rs >> detector)) {
        THROW(JDatabaseException, "Error reading " << getTable<JDetectorIntegration_t>());
      }
    }

    DEBUG("Number of integrated products (before) " << right << detector.size() << endl);
    
    detector.configure(detid);
    
    DEBUG("Number of integrated products (after)  " << right << detector.size() << endl);

    const JProductRouter router(detector);

    {
      DEBUG("Reading database table " << getTable<JAllParams>() << endl); 

      ResultSet& rs  = getResultSet(getTable<JAllParams>());

      for (JAllParams parameters; rs >> parameters; ) {

        // "INTEGER_UNIT_SCALE
        // For real and string parameters, this is meaningless and must be NULL.
        // For integer parameters, this is 0 if the value is an index to TB_PARAMETER_DISCRETE_REAL;
        // otherwise this is the positive factor to multiply by the value to obtain the parameter value."

        if (to_upper(parameters.TYPE) == "INTEGER" && parameters.INTEGER_UNIT_SCALE > 0.0) {
          unit[to_upper(parameters.NAME)] = parameters.INTEGER_UNIT_SCALE;
        }
      }

      rs.Close();
    }

    {
      DEBUG("Reading database table " << getTable<JDatalogNumbers>() << endl); 

      selection += getSelector<JDatalogNumbers>(detid, 
                                                runs.getLowerLimit(),
                                                runs.getUpperLimit());

      ResultSet& rs  = getResultSet(getTable<JDatalogNumbers>(), selection);

      long long int counter = 0;

      for (JDatalogNumbers parameters; rs >> parameters && counter != numberOfRows; ++counter) {

        STATUS(setw(10) << counter << '\r'); DEBUG(endl);

        const JUPI         upi      = parameters.SOURCE_NAME;
        const JLocation_t& location = router.getLocation(upi);

        if (location != JLocation_t()) {

          strings.insert(location.string);
          floors .insert(location.floor);

          bool status = true;

          for (vector<string>::const_iterator i = filter.begin(); i != filter.end(); ++i) {

            if (*i != "") {

              bool    nos    = (*i)[0] == FILTER;
              TRegexp regexp = (nos ? i->substr(1).c_str() : i->c_str());

              if (TString(parameters.PARAMETER_NAME).Contains(regexp)) {
                status = !nos;
              }
            }
          }

          if (status) {

            if (location.string >= (int) data.size()) {
              data.resize(location.string + 1);
            }

            if (location.floor  >= (int) data[location.string].size()) { 
              data[location.string].resize(location.floor + 1);
            }

            string buffer = parameters.PARAMETER_NAME;

            if (locate.count(buffer) != 0) {
              buffer += MAKE_STRING("[" << FILL(2,'0') << location.position << "]");
            }

            JGraph_t& g1 = data[location.string][location.floor][buffer];

            double factor = 1.0;

            map<string, double>::const_iterator p = unit.find(to_upper(parameters.PARAMETER_NAME));

            if (p != unit.end()) 
              factor = p->second;
            else
              errors[parameters.PARAMETER_NAME] += 1;
              

            if ((g1.counter++)%prescale == 0) {

              if (!graph) {

                outputFile.put(JDatalog(parameters.RUN,
                                        location.string,
                                        location.floor,
                                        location.position,
                                        parameters.PARAMETER_NAME,
                                        parameters.UNIXTIME,
                                        parameters.DATA_VALUE * factor));

              } else {

                g1.put(parameters.getTime(), parameters.DATA_VALUE * factor);
              }
            }
          }

        } else {

          warnings[parameters.PARAMETER_NAME] += 1;
        }
      }
      STATUS(endl);
    }
  }
  catch(const exception& error) {
    ERROR(error.what() << endl);
  }

  if (debug >= warning_t && !warnings.empty()) {

    cout << endl << "Parameters without location in detector." << endl;

    for (map<string, int>::const_iterator i = warnings.begin(); i != warnings.end(); ++i) {
      cout << left << setw(48) << i->first << ' ' << setw(6) << i->second << endl;
    }
  }

  if (!errors.empty()) {

    cout << endl << "Parameters without scale." << endl;

    for (map<string, int>::const_iterator i = errors.begin(); i != errors.end(); ++i) {
      cout << left << setw(48) << i->first << ' ' << setw(6) << i->second << endl;
    }
  }

  if (graph) {

    for (size_t string = 0; string != data.size(); ++string) {
      for (size_t floor = 0; floor != data[string].size(); ++floor) {
        for (map_type::iterator i = data[string][floor].begin(); i != data[string][floor].end(); ++i) {

          TGraph g1(i->second.X.size(), i->second.X.data(), i->second.Y.data());
          
          g1.SetName(MAKE_CSTRING(FILL(3,'0') << string << '.' << FILL(2,'0') << floor << '.' << setfill(' ') << i->first));

          const JRange<double> range(i->second.Y.begin(), i->second.Y.end());

          g1.SetMinimum(range.getLowerLimit());
          g1.SetMaximum(range.getUpperLimit());

          outputFile.put(g1);
        }
      }
    }

    ostringstream os;

    os << "set_variable NUMBER_OF_STRINGS " << setw(4) <<  strings.size()   << ";" << endl;
    os << "set_variable NUMBER_OF_FLOORS  " << setw(4) <<  floors. size()   << ";" << endl;
    if (!strings.empty()) {
      os << "set_variable FIRST_STRING      " << setw(4) << *strings. begin() << ";" << endl;
      os << "set_variable LAST_STRING       " << setw(4) << *strings.rbegin() << ";" << endl;
    }
    if (!floors.empty()) {
      os << "set_variable FIRST_FLOOR       " << setw(4) << *floors.  begin() << ";" << endl;
      os << "set_variable LAST_FLOOR        " << setw(4) << *floors. rbegin() << ";" << endl;
    }
    os << "set_array    STRINGS           ";
    copy(strings.begin(), strings.end(), ostream_iterator<int>(os, " "));
    os << endl;

    outputFile.put(TNamed("TUNA", os.str().c_str()));
  }

  outputFile.close();
}