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 "TH2D.h"
#include "JGizmo/JRootObjectID.hh"
#include "JGizmo/JGizmoToolkit.hh"
#include "JTools/JRange.hh"
#include "JTools/JHashCollection.hh"
#include "JTools/JHashMap.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 "JROOT/JManager.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"

Go to the source code of this file.

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

Function Documentation

main()

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 144 of file JAcousticsMonitorTest.cc.

{
  using namespace std;
  using namespace JPP;
 
  string inputFile;
  string parametersFile;
  string facet;
  string outputFile1;
  string outputFile2;
  string detectorFile;
  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(outputFile1,         "output summary file");
    zap['t'] = make_field(outputFile2,         "output root file");
    zap['a'] = make_field(detectorFile);
    zap['r'] = make_field(run,                "run number");
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
  ofstream out(outputFile1.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);
  }
 
  // create hist for test output
 
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  JHashMap<int, JLocation>   receivers;
 
  for (JDetector::const_iterator i = detector.begin(); i != detector.end(); ++i) {
 
    receivers[i->getID()] = i->getLocation();
  }
 
  const JHashCollection<int> string1(make_array(detector.begin(), detector.end(), &JModule::getString));
  const JRange         <int> floor1 (make_array(detector.begin(), detector.end(), &JModule::getFloor));
 
  JManager<int, TH2D> H3(new TH2D("H[%].rate-test",        NULL,
                                  string1.size(),             - 0.5, string1.size() - 0.5,
                                  floor1.getUpperLimit() + 1, - 0.5, floor1.getUpperLimit() + 0.5));
 
  for (Int_t i = 1; i <= H3->GetXaxis()->GetNbins(); ++i) {
    H3->GetXaxis()->SetBinLabel(i, MAKE_CSTRING(string1.at(i-1)));
  }
 
  for (Int_t i = 1; i <= H3->GetYaxis()->GetNbins(); ++i) {
    H3->GetYaxis()->SetBinLabel(i, MAKE_CSTRING(i-1));
  }
 
  // read input file
 
  TFile* f = TFile::Open(inputFile.c_str());  
 
  vector<JRootObjectID> objectIDs;
 
  readDir(f,objectIDs);
 
  // check if the monitor.root file is empty  
  int no_data = 0;
  if(objectIDs.empty()) { 
    ++number_of_failures;
    no_data += 1;
    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 parameters file
 
    out << "\nEmitter: " << i->first << endl;
 
    const TRegexp regexp(i->first);
 
    TH2D* h3 = H3[stoi(i->first)];
 
    // if no data at all, all receivers out of range
    if (no_data > 0) {
      for (Int_t ix = 1; ix <= h3->GetXaxis()->GetNbins(); ++ix) {
        for (Int_t iy = 1; iy <= h3->GetYaxis()->GetNbins(); ++iy) {
          h3->Fill(ix-1, iy-1, 1.0);
        }
      }
    }
 
    // 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 emitter expected to work, test acoustic rate
        if (i->second.working) {
          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) {
 
                  h3->Fill(ix-1, iy-1, 1.0);
 
                  ++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()) {
 
        // for all receivers rate out of range                                                                                        
        for (Int_t ix = 1; ix <= h3->GetXaxis()->GetNbins(); ++ix) {
          for (Int_t iy = 1; iy <= h3->GetYaxis()->GetNbins(); ++iy) {
            h3->Fill(ix-1, iy-1, 1.0);
          }
        }
 
        // 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;
        }
      }
    }
  }
  out.close();
 
  TFile out2(outputFile2.c_str(), "recreate");
 
  out2 << H3;
 
  out2.Write();
  out2.Close();
 
  // if number_of_failures > 0 program output needs to be reported
  if (number_of_failures > 0) {
    number_of_failures = 1;
    cout << number_of_failures << endl;
  }
  return 0;
}