JDataQuality.cc File Reference

#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <set>
#include <map>
#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "TF1.h"
#include "TString.h"
#include "TNtuple.h"
#include "TRegexp.h"
#include "JDB/JDB.hh"
#include "JDB/JSelector.hh"
#include "JDB/JSelectorSupportkit.hh"
#include "JDB/JRunQuality.hh"
#include "JDB/JRunsetups.hh"
#include "JDB/JDBToolkit.hh"
#include "JLang/JLangToolkit.hh"
#include "JTools/JRange.hh"
#include "JROOT/JRootPrinter.hh"
#include "JROOT/JRootToolkit.hh"
#include "JGizmo/JManager.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Example program to plot quality data from data base.

Author

mdejong

Definition in file JDataQuality.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 90 of file JDataQuality.cc.

{
  using namespace std;
  using namespace JPP;
 
  typedef JRange<int>         JRange_t; 
  typedef vector<JSelection>  JSelection_t;
 
  string          usr;
  string          pwd;
  string          cookie;
  string          inputFile;
  string          outputFile;
  string          detid;
  JRange_t        runs;
  vector<string>  source;
  JSelection_t    selection;
  JSelection_t    veto;
  TRegexp         regexp(".");
  int             debug;
 
  try {
 
    JParser<> zap("Example program to plot quality data from data base.");
    
    zap['u'] = make_field(usr)           = "";
    zap['!'] = make_field(pwd)           = "";
    zap['C'] = make_field(cookie)        = "";
    zap['f'] = make_field(inputFile,  "Optional input file instead of database.")       = "";
    zap['o'] = make_field(outputFile, "Output file containing histograms and n-tuple.") = "quality.root";
    zap['D'] = make_field(detid)         = "";
    zap['R'] = make_field(runs,       "Run range")                                      = JRange_t(1, JRange_t::getMaximum());
    zap['S'] = make_field(source,     "GIT versions");
    zap['Q'] = make_field(selection,  "User defined selections");
    zap['V'] = make_field(veto,       "User defined vetos.")                            = JPARSER::initialised();
    zap['r'] = make_field(regexp,     "TRegexp for selection of run setup names.")      = JPARSER::initialised();
    zap['d'] = make_field(debug,      "Debug level")                                    = 1;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  double W = 0.0;
  
  for (JSelection_t::const_iterator i = selection.begin(); i != selection.end(); ++i) {
    W += i->weight;
  }
 
  if (W <= 0.0) {
    FATAL("Invalid total weight: " << W << endl);
  }
 
  JRunsetups       setup;
 
  set<JRunQuality> buffer;
 
  if (inputFile == "") {
 
    ASSERT(detid != "");
 
    int ID = -1;        // integer representation of detectir identifier
 
    try {
 
      JDB::reset(usr, pwd, cookie);
 
      if (is_integer(detid))
        ID = to_value<int>(detid);
      else
        ID = getDetector(detid);
 
      if (is_integer(detid)) {
        detid = getDetector(to_value<int>(detid));
      }
 
      ResultSet& rs  = getResultSet(getTable<JRuns>(), getSelector<JRuns>(ID));
 
      for (JRuns parameters; rs >> parameters; ) {
        if (TString(parameters.RUNSETUPNAME.c_str()).Contains(regexp)) {
          setup.put(parameters);
        }
      }
 
      rs.Close();
 
      for (vector<string>::const_iterator i = source.begin(); i != source.end(); ++i) {
 
        typedef map<string, string>    data_type;
        typedef map<int, data_type>    map_type;
 
        map_type zmap;
 
        JSelector selector = getSelector<JRunSummaryNumbers>(detid, runs.getLowerLimit(), runs.getUpperLimit());
 
        selector.add(&JRunSummaryNumbers::SOURCE_NAME, *i);
 
        try {
 
          ResultSet& rs  = getResultSet(getTable<JRunSummaryNumbers>(), selector);
 
          for (JRunSummaryNumbers parameters; rs >> parameters; ) {
            if (setup.has(parameters.RUN)) {
              zmap[parameters.RUN].insert(make_pair(parameters.PARAMETER_NAME, parameters.DATA_VALUE));
            }
          }
        }
        catch(const exception& error) {}
 
        for (map_type::const_iterator run = zmap.begin(); run != zmap.end(); ++run) {
 
          JRunQuality quality;
 
          quality.GIT      = *i;
          quality.detector = ID;
          quality.run      = run->first;
 
          for (data_type::const_iterator p = run->second.begin(); p != run->second.end(); ++p) {
            quality.put(p->first, p->second);
          }
 
          buffer.insert(quality);
        }
      }
    }
    catch(const exception& error) {
      FATAL(error.what() << endl);
    }
 
  } else {
 
    ifstream in(inputFile.c_str());
 
    for (JRunQuality quality; in >> quality; ) {
      buffer.insert(quality);
    }
 
    in.close();
  }
 
  if (buffer.empty()) {
    FATAL("No data." << endl);
  }
 
 
  runs = JRange_t(buffer.begin()->run, buffer.rbegin()->run);
 
  TH1D h0("h0", NULL, 1000, 0.0, 1.01);
  TH1D h1("h1", NULL, selection.size(), -0.5, selection.size() + 0.5);
 
  h0.SetMinimum(0.0);
  h0.SetMaximum(1.1 * (runs.getUpperLimit() - runs.getLowerLimit()));
 
  h1.SetMinimum(0.0);
  h1.SetMaximum(1.1 * (runs.getUpperLimit() - runs.getLowerLimit()));
 
  JManager<TString, TH1D> zmap(new TH1D("%", NULL, 
                                        runs.getLength() + 1,
                                        runs.getLowerLimit() - 0.5,
                                        runs.getUpperLimit() + 0.5));
 
  // show range
 
  for (JSelection_t::const_iterator i = selection.begin(); i != selection.end();++i) {
 
    const string buffer = i->formula;
 
    zmap[buffer]->GetListOfFunctions()->Add(new TF1(MAKE_CSTRING(buffer << ":upper"), MAKE_CSTRING(i->range.getUpperLimit()), runs.getLowerLimit(), runs.getUpperLimit()));
    zmap[buffer]->GetListOfFunctions()->Add(new TF1(MAKE_CSTRING(buffer << ":lower"), MAKE_CSTRING(i->range.getLowerLimit()), runs.getLowerLimit(), runs.getUpperLimit()));
  }
 
  for (JSelection_t::const_iterator i = veto.begin(); i != veto.end();++i) {
 
    const string buffer = MAKE_STRING("VETO[" << i->formula << "]");
 
    zmap[buffer]->GetListOfFunctions()->Add(new TF1(MAKE_CSTRING(buffer << ":upper"), MAKE_CSTRING(i->range.getUpperLimit()), runs.getLowerLimit(), runs.getUpperLimit()));
    zmap[buffer]->GetListOfFunctions()->Add(new TF1(MAKE_CSTRING(buffer << ":lower"), MAKE_CSTRING(i->range.getLowerLimit()), runs.getLowerLimit(), runs.getUpperLimit()));
  }
 
  ostringstream os;
 
  os << "run";
 
  for (size_t i = 0; i != selection.size(); ++i) {
    os << ":" << (char) ('a' + i);
  }
 
  os << ":Q:V:R";
 
  TNtuple n1("n1", "quality", os.str().c_str());
 
 
  h0.SetDirectory(NULL);
  h1.SetDirectory(NULL);
  n1.SetDirectory(NULL);
 
 
  // process data
 
  for (set<JRunQuality>::const_iterator quality = buffer.begin(); quality != buffer.end(); ++quality) {
 
    vector<Float_t> tuple;
 
    tuple.push_back((Float_t) quality->run);
 
    double w = 0.0;
 
    for (size_t i = 0; i != selection.size(); ++i) {
 
      const JSelection& ps = selection[i];
      const double      y  = getResult(ps.formula, *quality);
 
      tuple.push_back((Float_t) y);
 
      zmap[ps.formula]->Fill((double) quality->run, y);
 
      if (ps.range(y)) {
        w += ps.weight;
      }
 
      h1.AddBinContent(i + 1, ps.range(y) ? 1.0 : 0.0);
    }
 
    const double Q = w/W;
 
    tuple.push_back((Float_t) Q);
 
    int V = 0;
 
    for (size_t i = 0; i != veto.size(); ++i) {
 
      const JSelection& ps = veto[i];
      const double      y  = getResult(ps.formula, *quality);
 
      zmap[MAKE_STRING("VETO[" << ps.formula << "]")]->Fill((double) quality->run, ps.range(y) ? 0.0 : 1.0);
 
      if (!ps.range(y)) {
        ++V;
      }
    }
 
    tuple.push_back((Float_t) V);
    tuple.push_back((Float_t) setup.get(quality->run));
 
    h0.Fill(Q);
    n1.Fill(tuple.data());
 
    cout << setw(8) << quality->run << ' ' << FIXED(5,3) << Q << ' ' << setw(2) << V << endl;
  }
 
  double w = 0.0;
 
  for (Int_t i = 0; i <= h0.GetXaxis()->GetNbins(); ++i) {
    h0.SetBinContent(i, (w += h0.GetBinContent(i)));
  }
  
  // output
 
  TFile out(outputFile.c_str(), "recreate");
 
  out << h0 << h1 << n1 << zmap;
 
  out.Write();
  out.Close();
}