JAcousticsMonitorTest.cc File Reference

#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"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)
	Program to test: More...

Function Documentation

int main	(	int	argc,
		char **	argv
	)

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.

Definition at line 139 of file JAcousticsMonitorTest.cc.

{
  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 " << i->first << " started working." << endl;
          out << RESET;
        }

        // 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 " << i->first << " stopped working." << endl;
          out << RESET;
        } else {
          out << "Emitter " << i->first << " is expected to not work." << endl;
        }
      }
    }
  }
  // if number_of_failures > 0 program output needs to be reported
  cout << number_of_failures << endl;
  return 0;
}