JEditTuneHV.cc

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <set>

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

#include "JSystem/JTime.hh"

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

#include "JLang/JPredicate.hh"

#include "JSupport/JFilenameSupportkit.hh"

#include "JDetector/JDetectorCalibration.hh"

#include "JDB/JDB.hh"
#include "JDB/JDBToolkit.hh"
#include "JDB/JDBincludes.hh"
#include "JDB/JProductRouter.hh"
#include "JDB/JSelector.hh"
#include "JDB/JSelectorSupportkit.hh"
#include "JDB/JDetectorIntegration.hh"
#include "JDB/JDetectorIntegration_t.hh"

#include "JSon/JSon.hh"


/**
 * \file
 *
 * Auxiliary program to treat failed HV-tuning calibrations.
 *
 * Possible operations are to update according to:
 *     - the high-voltage settings corresponding to a specific DAQ run\n
 *       if both detector ID and run number are specified.
 *     - the vendor high-voltage settings\n
 *       if the detector ID is specified, but the run number is left unspecified.
 *     - manually specifiable values\n
 *       if both detector ID and run number are left unspecified.
 * \author bjung
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;

  string      usr;
  string      pwd;
  string      cookie;
  
  string      inputFile;
  string      outputFile;

  set<JUPI_t> pmtSet;

  double      minHV = -1500;
  double      maxHV = - 800;

  int         detID;
  int         runNr;
  
  int         debug;

  try {

    JProperties properties;

    properties.insert(gmake_property(minHV));
    properties.insert(gmake_property(maxHV));

    JParser<> zap("Auxiliary program to treat failed high-voltage tuning results.");

    zap['u'] = make_field(usr)                                                         = "";
    zap['!'] = make_field(pwd)                                                         = "";
    zap['C'] = make_field(cookie)                                                      = "";
    zap['f'] = make_field(inputFile,    "input file");
    zap['o'] = make_field(outputFile,   "output file");
    zap['D'] = make_field(detID,        "detector identifier")                         = -1;
    zap['r'] = make_field(runNr,        "run number")                                  = -1;
    zap['P'] = make_field(pmtSet,       "Set of PMT UPIs")                             = JPARSER::initialised();
    zap['@'] = make_field(properties)                                                  = JPARSER::initialised();
    zap['d'] = make_field(debug,        "debug")                                       =  2;

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

  JDateAndTime   timer;

  string         testType;
  JHVCalibration toEdit;
  
  if (isJSONFile(inputFile.c_str())) {
    
    json js;

    ifstream ifs(inputFile.c_str());

    ifs >> js;
    ifs.close();

    JHVCalibration HVcals;
    
    json::const_iterator data   = js.find(Tests_t);

    if (data != js.end()) {
    
      HVcals = data->get<JHVCalibration>();
    
    } else {

      ERROR("HV calibration data could not be found!");
    }

    json::const_iterator DBtype = js.find(Test_t + Type_t);

    if (DBtype != js.end()) {

      testType = DBtype->get<string>();
      
    } else {

      WARNING("No database test type specified.");
    }

    if (pmtSet.empty()) {
      
      for (JHVCalibration::iterator it = HVcals.begin(); it != HVcals.end(); ++it) {
      
        if (it->result != OK_t) {
          toEdit.push_back(*it);
        }
      }
      
    } else {

      for (set<JUPI_t>::const_iterator it = pmtSet.cbegin(); it != pmtSet.cend(); ++it) {

        JHVCalibration::iterator pmt = find_if(HVcals.begin(), HVcals.end(),
                                               make_predicate(&JHVCalibration_t::getNumber, it->getNumber()));
        if (pmt != HVcals.end()) {

          if (pmt->result == OK_t) {
            WARNING("Editing result for " << pmt->getUPI() << ", which is already labeled " << OK_t << endl);
          }
          
          toEdit.push_back(*pmt);
        }
      }
    }
    
  } else {

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


  JPersons person;
  
  try {

    JDB::reset(usr, pwd, cookie);

    {
      JSelector  selector = getSelector<JPersons>(JDB::get()->User());
      ResultSet& rs       = getResultSet(getTable<JPersons>(), selector);
      rs >> person;
      rs.Close();
    }
    
    if (detID > 0 && runNr > 0) {

      NOTICE("Setting high-voltages corresponding to run " << runNr << "..." << endl);

      JSelector  selector = getSelector<JPMTHVRunSettings>(getDetector(detID), runNr);  
      ResultSet& rs       = getResultSet(getTable<JPMTHVRunSettings>(), selector);
        
      for (JPMTHVRunSettings table; rs >> table; ) {
          
        JHVCalibration::iterator cal = find_if(toEdit.begin(), toEdit.end(),
                                               make_predicate(&JHVCalibration_t::getNumber, table.PMTSERIAL));
        if (cal != toEdit.end()) {
            
          cal->supplyVoltage = table.HV_VALUE;
          cal->result        = OK_t;
        }
      }
        
      rs.Close();
        
    } else if (detID > 0) {
      
      NOTICE("Setting vendor high-voltages..." << endl);

      JSelector  selector = getSelector<JVendorHV>(detID);
      ResultSet& rs       = getResultSet(getTable<JVendorHV>(), selector);

      for (JVendorHV table; rs >> table; ) {
          
        JHVCalibration::iterator cal = find_if(toEdit.begin(), toEdit.end(),
                                               make_predicate(&JHVCalibration_t::getNumber, table.PMTSERIAL));
        if (cal != toEdit.end()) {
              
          cal->supplyVoltage = table.PMT_SUPPLY_VOLTAGE;
          cal->result        = OK_t;
        }
      }

      rs.Close();
        
    } else {
      
      NOTICE("Setting high-voltages manually..." << endl);
        
        for (JHVCalibration::iterator cal = toEdit.begin(); cal != toEdit.end(); ++cal) {

          NOTICE("Please specify high-voltage for " << RIGHT(30) << cal->getUPI() << ":" << endl);

          double manualHV;
          cin >> manualHV;

          if (manualHV > minHV && manualHV < maxHV) {
            
            cal->supplyVoltage = manualHV;
            cal->result        = OK_t;
            
          } else {
            
            WARNING("Specified high-voltage is not within range [" << minHV << ", " << maxHV << "]; skip.");
          }

          NOTICE(endl);
        }
    }

  } catch (const exception& error) {
      
    FATAL(error.what() << endl);
  }
  
  json js;

  js[User_t]          = person.LOGIN;
  js[Location_t]      = person.LOCATIONID;
  js[StartTime_t]     = timer.toString();
  js[EndTime_t]       = timer().toString();
  js[Test_t + Type_t] = testType;
  js[Tests_t]         = json(toEdit);

  ofstream ofs(outputFile.c_str());

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

  ofs.close();
  
  return 0;
}