JMergeTuneHV.cc

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
 
#include "JSystem/JDateAndTime.hh"
 
#include "JLang/JUUID.hh"
#include "JLang/JPredicate.hh"
 
#include "JSupport/JMeta.hh"
#include "JSupport/JFilenameSupportkit.hh"
 
#include "JDetector/JDetectorCalibration.hh"
 
#include "JDB/JDBSupportkit.hh"
 
#include "JSon/JSon.hh"
 
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
#include "Jeep/JProperties.hh"
 
 
/**
 * \file
 *
 * Auxiliary program to merge multiple HV tuning calibrations.
 *
 * Note that only the calibration in the first given file will be maintained\n
 * in case a PMT appears in multiple files.
 * \author bjung
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
 
  string         login;
  string         locationID;
  int            elapsedTime = 0;
  
  vector<string> inputFiles;
  string         outputFile;
  
  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 merge high-voltage calibration results.");
 
    zap['f'] = make_field(inputFiles,   "input  files");
    zap['o'] = make_field(outputFile,   "output file");
    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 (login.empty() || locationID.empty()) {
    FATAL("Missing user information (please specify via -#login and -#locationID)." << endl);
  }
 
 
  const JUUID& UUID = JUUID::rndm();
 
  JDateAndTime       timer;
 
  timer.sub(elapsedTime);
  
  
  // Merge high-voltage calibrations
  
  JDBAPIVersion      DBAPIVersion;  
  set<string>        testTypes;
  string             metaInfoStr = MAKE_STRING(JMeta(argc, argv));
 
  JHVCalibration     merged;
  
  for (vector<string>::const_iterator fileIt = inputFiles.cbegin(); fileIt != inputFiles.cend(); ++fileIt) {
 
    NOTICE("Merging " << (*fileIt) << endl);
 
    if (isJSONFile(fileIt->c_str())) {
 
      json     js;
      ifstream ifs(fileIt->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) ) {
 
        set<string>::const_iterator j = testTypes.insert(testTypes.cbegin(), (*i1)[0].at(Test_t + Type_t).get<string>());
 
        JHVCalibration_t::setVersion(getDBVersionTuneHV(*j));
        
        HVcals         = (*i1)[0].at(Tests_t).get<JHVCalibration>();
        metaInfoStr   += (*i1)[0].at(Provenance_t + Info_t).at(Configuration_t).get<string>();
      
      } else {
        
        set<string>::const_iterator j = testTypes.insert(testTypes.cbegin(), js.at(Test_t + Type_t).get<string>());
 
        JHVCalibration_t::setVersion(getDBVersionTuneHV(*j));
        
        HVcals         = js.at(Tests_t).get<JHVCalibration>();
      }
 
      // Merge calibrations
 
      for (JHVCalibration::const_iterator cal = HVcals.cbegin(); cal != HVcals.cend(); ++cal) {
        
        if (find_if(merged.cbegin(), merged.cend(), make_predicate(&JHVCalibration_t::getNumber, cal->getNumber())) == merged.cend()) {
          merged.push_back(*cal);
        }
      }
 
    } else {
 
      WARNING(*fileIt << " is not a JSON file; skip" << endl);
      continue;
    }
  }
 
  if (testTypes.size() > 1) {
   
    WARNING("Ambiguous database test types; Assuming " << *testTypes.crbegin() << endl);
    
  } else if (testTypes.size() == 0) {
    
    FATAL("No database test type specified.");
  }
 
 
  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()        },
                             {End_t   + Time_t,       timer().toString()      },
                             {Test_t  + Type_t,     *(testTypes.crbegin())    },
                             {Tests_t,                json(merged)            } };
      
    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();
    js[End_t]            = timer().toString();
    js[Data_t][0]        = json(data);
    
  } else {
 
    js[User_t]           = login;
    js[Location_t]       = locationID;
    js[Test_t + Type_t]  = *(testTypes.crbegin());
    js[Start_t + Time_t] = timer.toString();
    js[End_t + Time_t]   = timer().toString();
    js[Tests_t]          = json(merged);
  }
  
  ofstream ofs(outputFile.c_str());
 
  ofs << setw(2) << setprecision(8);
  ofs << js;
 
  ofs.close();
 
  return 0;
}