JAcousticsMonitorTest.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <map>
#include <locale>

#include "TROOT.h"
#include "TFile.h"
#include "TObject.h"
#include "TKey.h"
#include "TString.h"
#include "TRegexp.h"
#include "TGraph.h"
#include "TF1.h"

#include "JGizmo/JRootObjectID.hh"
#include "JGizmo/JGizmoToolkit.hh"
#include "JTools/JRange.hh"
#include "JLang/JLangToolkit.hh"
#include "JLang/JColorFacet.hh"
#include "JLang/JVectorize.hh"

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

#include "TH2D.h"


namespace {

  using JTOOLS::JRange;

  /**
   * Auxilliary data structure with test criteria.
   */
  struct JParameters_t {

    static const char SKIPLINE  =  '#';           //!< skip line character

    /**
     * Default constructor.
     */
    JParameters_t() :
      working(1),
      expected_rate(0),
      range(JRange<double>::DEFAULT_RANGE),
      number_of_outliers(0)
    {}


    /**
     * Read parameters from input stream.
     *
     * \param  input           input stream
     * \param  object          parameters
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JParameters_t& object)
    {
      using namespace std;
      return in >> object.working >> object.expected_rate >> object.range >> object.number_of_outliers;
    }


    /**
     * Write parameters to output stream.
     *
     * \param  output          output stream
     * \param  object          parameters
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JParameters_t& object)
    {
      using namespace std;
      using namespace JPP;

      return out << setw(6)     << object.working     << ' '
                 << FIXED(2,6)  << object.expected_rate    << ' '
                 << FIXED(2,6)  << object.range.getLowerLimit() << ' '
                 << FIXED(2,6)  << object.range.getUpperLimit() << ' '
                 << setw(4)     << object.number_of_outliers;
    }

    int working;
    double  expected_rate;
    JRange<double>  range;
    int  number_of_outliers;
  };

  /*                                                                                                                          
   * Gets list of keys in a ROOT TDirectory and stores it on a vector.                                                        
   *                                                                                                                          
   * \param  dir        The ROOT directory
   * \param  buffer     Vector to store keys 
   */
  void readDir(TDirectory*                         dir,
               std::vector<JGIZMO::JRootObjectID>& buffer) {

    TIter iter(dir->GetListOfKeys());

    for (TKey* key; (key = (TKey*) iter.Next()) != NULL; ) {

      if (key->IsFolder()){

        dir->cd(key->GetName());

        TDirectory *subdir = gDirectory;
        readDir(subdir, buffer);

        dir->cd();

      } else {

        JGIZMO::JRootObjectID objectID(MAKE_STRING(dir->GetPath() << key->GetName()));

        buffer.push_back(objectID);
      }
    }
  }

}


/**
 *
 * Program to test:
 * - If there is acoustic data.
 * - If the rate recorded by each receiver is within the expected range.
 * - If emitters and receivers are working and compares it to what is expected.
 *
 * Reports failure if: no acoustic data, too large number of outliers, emitter expected to work is not working,
 * hydrophone expected to work is not working.
 *
 */

int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;

  string inputFile;
  string parametersFile;
  string facet;
  string outputFile;
  int    debug;
  int    number_of_failures = 0;
  int    run;
 
  try {

    JParser<> zap("Auxiliary program to apply test criteria to 2D histograms monitoring acoustic rate per emitter.");
    
    zap['f'] = make_field(inputFile,          "output root file from JAcousticsMonitor_short");
    zap['P'] = make_field(parametersFile,     "ASCII formatted input file with test criteria (acoustic_monitor_00000XXX.txt)");
    zap['F'] = make_field(facet,              "Color facet")                                       = get_keys(color_facets);
    zap['d'] = make_field(debug)              = 1;
    zap['w'] = make_field(outputFile,         "output summary file");
    zap['r'] = make_field(run,                "run number");
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }

  ofstream out(outputFile.c_str());
  out.imbue(locale(out.getloc(), color_facets[facet]->clone()));
  out << "ACOUSTIC MONITORING \nRun: " << run << endl;
  out << "\n(Note: red highlights are the reason for the warning)" << endl;
  // read parameters file

  typedef map<string, JParameters_t> map_type;

  map_type zmap;

  ifstream in(parametersFile.c_str());

  if (in) {

    string        key;
    JParameters_t parameters;

    for (string buffer; getline(in, buffer); ) {

      if (!buffer.empty() && buffer[0] != JParameters_t::SKIPLINE) {

        istringstream is(buffer);

        if (is >> key >> parameters) { zmap[key] = parameters; }
      }
    }

    in.close();

  } else {
    FATAL("Error opening file: " << parametersFile << endl);
  }

  // read input file

  TFile* f = TFile::Open(inputFile.c_str());  

  vector<JRootObjectID> objectIDs;

  readDir(f,objectIDs);

  // check if the monitor.root file is empty  
  if(objectIDs.empty()) { 
    ++number_of_failures;
    out << RED << "No acoustic data." << endl; 
    out << RESET;
  }

  // loop over expected emitters

  for (map_type::const_iterator i = zmap.begin(); i != zmap.end(); ++i) {

    if (i->first[0] == '0') { continue; } // skip receivers

    out << "\nEmitter: " << i->first << endl;

    const TRegexp regexp(i->first);


    // check if data from emitter is in input file
    
    for (vector<JRootObjectID>::const_iterator objectID = objectIDs.cbegin() ; objectID != objectIDs.cend() ; ++objectID) {
    
      const TString& objectName = objectID->getFullObjectName();
   
      // data from emitter is in input file
      if (objectName.Index(regexp) != -1) {

        // check if expected status emitter changed
        if (!i->second.working) {
          out << (i->second.working != 0 ? RED : GREEN);
          out << "Emitter started working." << endl;
          out << RESET;   
          out << "(Acoustic rates not tested)" << endl;
        }

        if (i->second.working) {
          // test acoustic rate
          TObject* p = (TObject*)f->Get(objectName);
          TH2*      h2 = NULL;

          int number_of_bins   = 0;
          int number_of_outliers = 0;

          double min_rate = i->second.expected_rate * i->second.range.getLowerLimit();
          double max_rate = i->second.expected_rate * i->second.range.getUpperLimit();
          int outliers = i->second.number_of_outliers;
        
          if (h2 == NULL && dynamic_cast<TH2*>(p) != NULL) { h2 = dynamic_cast<TH2*>(p); };

          if (h2 != NULL) {

            for (Int_t ix = 1; ix <= h2->GetXaxis()->GetNbins(); ++ix) {
              for (Int_t iy = 1; iy <= h2->GetYaxis()->GetNbins(); ++iy) {

                const Double_t z = h2->GetBinContent(ix, iy);
                string du = to_string(h2->GetXaxis()->GetBinLabel(ix));
                string floor = to_string(h2->GetYaxis()->GetBinLabel(iy));

                du.insert(du.begin(), 4 - du.length(), '0');
                floor.insert(floor.begin(), 3 - floor.length(), '0');
                const string id = du + '.' + floor;

                int working = 1;
                if (zmap.find(id)!=zmap.end()) { working = zmap.find(id)->second.working; }

                ++number_of_bins;

                // acoustic rate out of range
                if (z < min_rate || z > max_rate) {

                  ++number_of_outliers;
                  if (working) { // receiver expected to work

                    if (floor == "000" && z == 0) { // if hydrophone doesn't work
                      out << "DU " << du << ", floor " << floor << " : Acoustic rate out of range -> " << z << " Hz." << RED << " Hydrophone stopped working." << endl;
                      out << RESET;
                      ++number_of_failures;
                    } else {
                      out << "DU " << du << ", floor " << floor << " : Acoustic rate out of range -> " << z << " Hz." << endl;
                    }
                  }
                } else if (!working) { // receiver expected to not work                                               
                  out << "DU " << du << ", floor " << floor << " : Working again -> " << z << " Hz." << endl;
                }
              }
            }
          } else { FATAL("Object at " << objectName << " is not TH2." << endl); }

          out << (number_of_outliers > outliers ? RED : GREEN) << "Number of outliers = " << number_of_outliers << "/" << number_of_bins << endl;
          out << RESET;

          if (number_of_outliers > outliers) {
          
            ++number_of_failures;
            out << (number_of_outliers > outliers ? RED : GREEN) << "Test failed." << endl;
            out << RESET;
          } else {
          
            out << (outliers > number_of_outliers ? GREEN : RED) << "Test passed." << endl;
            out << RESET;
          }
        }
        break;
        
  
      // data from emitter is not in input file
      } else if (objectID + 1 == objectIDs.cend()) {

        // check if expected status emitter changed
        if (i->second.working) {
          ++number_of_failures;
          out << (i->second.working != 0 ? RED : GREEN) << "Emitter stopped working." << endl;
          out << RESET;
        } else {
          out << "Emitter is expected to not work." << endl;
        }
      }
    }
  }
  // if number_of_failures > 0 program output needs to be reported
  cout << number_of_failures << endl;
  return 0;
}