JPrintTuneHV.cc

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <map>

#include "km3net-dataformat/online/JDAQ.hh"

#include "JSystem/JDate.hh"

#include "JLang/JUUID.hh"

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

#include "JSupport/JMeta.hh"
#include "JSupport/JFilenameSupportkit.hh"

#include "JDetector/JDetector.hh"
#include "JDetector/JPMTRouter.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JDetectorCalibration.hh"

#include "JDB/JDBSupportkit.hh"
#include "JDB/JProductRouter.hh"

#include "JSon/JSon.hh"


/**
 * \file
 *
 * Auxiliary program to print HV-tuning output.
 *
 * An output JSON file listing all failed evaluations other than those in dead modules\n
 * can be created optionally by specifiying an output file and the meta-information 
 * required by the database (user login and location ID).
 * \author bjung
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;
  
  string inputFile;
  string detectorFile;
  string outputFile;

  string login;
  string locationID;
  int    elapsedTime = 0;  
  
  int    debug;

  try {

    JProperties properties;

    properties.insert(gmake_property(login));
    properties.insert(gmake_property(locationID));
    properties.insert(gmake_property(elapsedTime));    

    JParser<> zap("Auxiliary program to print high-voltage tuning results.");
    
    zap['f'] = make_field(inputFile,    "input file (JSON output of JTuneHV)");
    zap['a'] = make_field(detectorFile, "detector file");    
    zap['o'] = make_field(outputFile,   "output file (for writing failed evaluations to separate JSON output)") = "";
    zap['#'] = make_field(properties,   "database information")                        = JPARSER::initialised();    
    zap['d'] = make_field(debug,        "debug")                                       = 2;

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

  if (!outputFile.empty() && (login.empty() || locationID.empty())) {
    
    FATAL("Missing user information (please specify via -#login and -#locationID).");
  }

  
  const JUUID& UUID = JUUID::rndm();
  
  JDateAndTimeFormat format = ISO8601;
  JDateAndTime       timer;

  timer->tm_sec -= elapsedTime;
  
  JDetector detector;

  try {
    load(detectorFile, detector);
  }
  catch (const exception& error) {
    FATAL(error.what() << endl);
  }

  const JPMTRouter PMTrouter(detector);
  

  JDBAPIVersion DBAPIVersion;
  string        DBTestType;
  string        metaInfoStr = MAKE_STRING(JMeta(argc, argv));
  
  size_t        Ntotal = 0;
  
  map<int, JHVCalibration> failureMap;
  
  if (isJSONFile(inputFile.c_str())) {
    
    json js;
    
    ifstream ifs(inputFile.c_str());
    
    ifs >> js;
    ifs.close();

    // Extract data    
    
    json::const_iterator i0 = js.find(APIVersion_t);

    if (i0 != js.cend()) {
      
      istringstream iss(i0->get<string>());
      
      iss >> DBAPIVersion;
    }

    JHVCalibration HVcals;
    
    json::const_iterator i1 = js.find(Data_t);
    
    if ((DBAPIVersion.getMajorVersion() == 2) &&
        (i1 != js.cend() && i1->size() > 0)) {

      DBTestType   = (*i1)[0].at(Test_t + Type_t).get<string>();

      JHVCalibration_t::setVersion(getDBVersionTuneHV(DBTestType));
      
      HVcals       = (*i1)[0].at(Tests_t).get<JHVCalibration>();
      metaInfoStr += (*i1)[0].at(Provenance_t + Info_t).at(Configuration_t).get<string>();
      
    } else {

      DBTestType   = js.at(Test_t + Type_t).get<string>();

      JHVCalibration_t::setVersion(getDBVersionTuneHV(DBTestType));      
      
      HVcals       = js.at(Tests_t).get<JHVCalibration>();
    }
    
    
    NOTICE(LEFT (30) << "UPI"  << CENTER(35) << "(identifier / location)" <<
           RIGHT(20) << "HV"   << RIGHT (10)  << "gain" << RIGHT(10) << "status" << endl);
    
    for (JHVCalibration::const_iterator it = HVcals.cbegin(); it != HVcals.cend(); ++it) {

      const JUPI_t&         pmtUPI = it->getUPI();
      const JModule&        module = PMTrouter.getParentModule(pmtUPI.getNumber());
      const JPMTIdentifier& pmtID  = PMTrouter.getIdentifier  (pmtUPI.getNumber());

      const JLocation_t    location(module.getString(), module.getFloor(), pmtID.getTDC());

      if (it->result != OK_t) {
        failureMap[pmtID.getModuleID()].push_back(*it);
      }

      NOTICE(LEFT (30) << pmtUPI << "(a.k.a. " << pmtID << " / " << location << "):" <<
             FIXED(20,1) << it->supplyVoltage << RIGHT(10) << it->result << endl);

      ++Ntotal;
    }

  } else {

    ERROR(inputFile << " is not a JSON file." << endl);
  }


  size_t Nfailed  = 0;
  size_t Nmissing = 0;

  JHVCalibration failures;
  
  NOTICE(endl << FILL(105, '-') << " List of failures" << setfill(' ') << endl);
  
  for (map<int, JHVCalibration>::const_iterator i = failureMap.cbegin(); i != failureMap.cend(); ++i) {

    Nfailed += i->second.size();
    
    if (i->second.size() == NUMBER_OF_PMTS) {
      
      Nmissing += NUMBER_OF_PMTS;
      WARNING("No successful calibrations found for module " << i->first << " (dead module?)" << endl);
      
    } else {

      for (JHVCalibration::const_iterator j = i->second.cbegin(); j != i->second.cend(); ++j) {
        
        const JUPI_t&         pmtUPI = j->getUPI();
        const JModule&        module = PMTrouter.getParentModule(pmtUPI.getNumber());
        const JPMTIdentifier& pmtID  = PMTrouter.getIdentifier  (pmtUPI.getNumber());
        
        const JLocation_t     location(module.getString(), module.getFloor(), pmtID.getTDC());
        
        NOTICE(LEFT(30) << pmtUPI << "(a.k.a. " << pmtID << " / " << location << "):" <<
               right << FIXED(20,1) << j->supplyVoltage << RIGHT(10) << j->result << endl);
        
        failures.push_back(*j);
      }
    }
  }
  
  NOTICE(endl << FILL(105, '-') << " SUMMARY" << setfill(' ') << endl);
  NOTICE(LEFT(40)  << "Number of evaluated PMTs:" << RIGHT(20) << Ntotal << endl);
  NOTICE(LEFT(40)  << "Number of successful evaluations:" << RIGHT(20) << Ntotal - Nfailed << endl);
  NOTICE(LEFT(40)  << "Number of failed evaluations:" << RIGHT(20) << Nfailed << endl);
  NOTICE(RIGHT(20) << '-' << LEFT(20) << " in missing modules:" << RIGHT(20) << Nmissing << endl);
  NOTICE(RIGHT(20) << '-' << LEFT(20) << " other:" << RIGHT(20) << Nfailed - Nmissing << endl << endl);

  
  if (!outputFile.empty()) {

    json js;

    if (DBAPIVersion.getMajorVersion() == 2) {
    
      json error           = { {Message_t,              ""                      },
                               {Code_t,                 OK_t                    },
                               {Arguments_t,            json::array()           } };
    
      json metaData        = { {Configuration_t,        metaInfoStr             },
                               {UUID_t,                 MAKE_STRING(UUID)       } };
    
      json data            = { {Provenance_t + Info_t,  json(metaData)          },
                               {User_t,                 login                   },
                               {Location_t,             locationID              },
                               {Start_t + Time_t,       timer.toString  (format)},
                               {End_t   + Time_t,       timer().toString(format)},
                               {Test_t  + Type_t,       DBTestType              },
                               {Tests_t,                json(failures)          } };
      
      js[APIVersion_t]     = MAKE_STRING(DBAPIVersion);
      js[Data_t + Type_t]  = MAKE_STRING("ProductTestSession");
      js[Encoding_t]       = MAKE_STRING("NativeJSON");
      js[Error_t]          = json(error);
      js[Start_t]          = timer.toString(format);
      js[End_t]            = timer().toString(format);
      js[Data_t][0]        = json(data);
    
    } else {

      js[User_t]           = login;
      js[Location_t]       = locationID;
      js[Test_t + Type_t]  = DBTestType;
      js[Start_t + Time_t] = timer.toString(format);
      js[End_t + Time_t]   = timer().toString(format);
      js[Tests_t]          = json(failures);
    }
    
    ofstream ofs(outputFile.c_str());

    ofs << setw(2) << setprecision(8);
    ofs << js;

    ofs.close();
  }

  return 0;
}