JDetectorCalibration.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JDETECTORCALIBRATION__
#define __JDETECTOR__JDETECTORCALIBRATION__

#include <string>
#include <vector>

#include "JDB/JUPI.hh"
#include "JSon/JSon.hh"
#include "JLang/JObjectID.hh"
#include "JDetector/JCalibration.hh"
#include "JGeometry3D/JPosition3D.hh"
#include "JGeometry3D/JQuaternion3D.hh"


/**
 * \author mdejong
 */

namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }

/**
 * Auxiliary classes and methods for detector calibration.
 */
namespace JDETECTOR {

  using JSON::json;
  using JLANG::JObjectID;
  using JDATABASE::JUPI;
  using JDATABASE::JPBS;
  using JGEOMETRY3D::JPosition3D;
  using JGEOMETRY3D::JQuaternion3D;

  /**
   * Detector calibration key words for JSON I/O.
   */

  // Headers
  static const std::string  User_t             =  "User";
  static const std::string  Location_t         =  "Location";
  static const std::string  StartTime_t        =  "StartTime";
  static const std::string  EndTime_t          =  "EndTime";
  static const std::string  Comment_t          =  "Comment";

  // Meta data
  static const std::string  Type_t             =  "Type";
  static const std::string  Parameters_t       =  "Parameters";
  static const std::string  Tests_t            =  "Tests";
  static const std::string  Data_t             =  "Data";
  static const std::string  RunNumber_t        =  "RUN_NUMBER";
  static const std::string  Name_t             =  "Name";
  static const std::string  Unit_t             =  "Unit";
  static const std::string  Values_t           =  "Values";

  // Calibration types
  static const std::string  PMTT0s_t           =  "PMTT0s";
  static const std::string  PMTSupplyVoltage_t =  "PMT_Supply_Voltage";
  static const std::string  PMTGain_t          =  "PMT_Gain";
  static const std::string  DOMPositions_t     =  "DOMPositions";
  static const std::string  DOMRotations_t     =  "DOMRotations";

  // Prefixes
  static const std::string  Test_t             =  "Test";
  static const std::string  Target_t           =  "Target";
  static const std::string  Outcome_t          =  "Outcome";

  // Identifiers
  static const std::string  UPI_t              =  "UPI";
  static const std::string  PBS_t              =  "PBS";
  static const std::string  Variant_t          =  "Variant";
  static const std::string  PMTSerial_t        =  "PMTSerial";
  static const std::string  DOMSerial_t        =  "DOMSerial";
  static const std::string  DOMId_t            =  "DOMId";

  // Variable names
  static const std::string  T0_t               =  "T0";
  static const std::string  PX_t               =  "PX";
  static const std::string  PY_t               =  "PY";
  static const std::string  PZ_t               =  "PZ";
  static const std::string  Q0_t               =  "Q0";
  static const std::string  QX_t               =  "QX";
  static const std::string  QY_t               =  "QY";
  static const std::string  QZ_t               =  "QZ";

  // Units
  static const std::string  Unitless_t         =  "-";
  static const std::string  Volt_t             =  "V";

  // Status
  static const std::string  Result_t           =  "Result";
  static const std::string  OK_t               =  "OK";
  static const std::string  Failed_t           =  "FAILED";


  /**
   * Check validity of JSon data.
   *
   * \param  js                    JSon data
   * \return                       true if valid; else false
   */
  inline bool is_valid(const json& js)
  {
    return js.contains(Result_t)  &&  js[Result_t] == OK_t;
  }


  /**
   * Create ISO 8601 date string for output file header
   * 
   * \param  time                  Unix timestamp
   * \return                       ISO 8601 timestamp corresponding to input time
   */
  inline std::string get_date_string(const std::time_t& time)
  {
    using namespace std;

    const int N = 256;

    char buffer[N];

    strftime(buffer, N, "%FT%T%z", localtime(&time));

    return string(buffer);
  }


  /**
   * Cast single value to array of strings, conform the DB-format.
   *
   * \param  value                 value
   * \return                       std::vector containing value casted to string
   */
  template <class T>
  inline std::vector<std::string> get_string_array(T value) 
  {
    using namespace std;
    
    return vector<string>{ to_string(value) };
  }


  /**
   * Retrieve value from json array of strings.
   *
   * \param  string_value_array    array of string-casted values
   * \return                       double-casted value
   */
  inline double retrieve_value(std::vector<std::string> string_value_array) 
  {
    return std::stod(string_value_array[0]);
  }


  /**
   * Auxiliary data structure for PMT time calibration.
   */
  struct JPMTCalibration_t :
    public JObjectID,
    public JCalibration
  {
    /**
     * Default constructor.
     */
    JPMTCalibration_t()
    {}


    /**
     * Constructor.
     *
     * \param  id             PMT identifier
     * \param  calibration    PMT time calibration
     */
    JPMTCalibration_t(const JObjectID&    id,
                      const JCalibration& calibration) :
      JObjectID   (id),
      JCalibration(calibration)
    {}
  };


  /**
   * Convert PMT time calibration to JSon.
   *
   * \param  js         json
   * \param  object     PMT time calibration
   */
  inline void to_json(json& js, const JPMTCalibration_t& object)
  {
    js = json{ { PMTSerial_t, object.getID() },
               { T0_t,        object.getT0() } };
  }


  /**
   * Convert JSon to PMT time calibration.
   *
   * \param  js         json
   * \param  object     PMT time calibration
   */
  inline void from_json(const json& js, JPMTCalibration_t& object)
  {
    object.setID(js.at(PMTSerial_t).get<int>());

    object.setT0(js.at(T0_t).get<double>());
  }


  /**
   * Data structure for PMT high-voltage calibration.
   */
  struct JHVCalibration_t :
    public JUPI
  {
    /**
     * Default constructor.
     */
    JHVCalibration_t()
    {}
    
    
    /**
     * Constructor.
     *
     * \param  upi            %UPI
     * \param  result         result
     * \param  hv             HV
     * \param  gain           PMT gain
     * \param  runNumbers     run numbers
     */
    JHVCalibration_t(const JUPI&                     upi,
                     const std::string&              result,
                     const double                    hv,
                     const double                    gain,
                     const std::vector<std::string>& runNumbers = std::vector<std::string>{}) :
      JUPI         (upi),
      result       (result),
      supplyVoltage(hv),
      PMTgain      (gain),
      runNumberList(runNumbers)
    {}

    std::string              result;
    double                   supplyVoltage;
    double                   PMTgain;
    std::vector<std::string> runNumberList;
  };


  /**
   * Convert PMT high-voltage calibration to JSon.
   *
   * \param  js         json
   * \param  object     PMT high-voltage calibration
   */
  inline void to_json(json& js, const JHVCalibration_t& object)
  {
    std::ostringstream os;

    os << object.getUPI();

    js[UPI_t]                    = os.str();
    js[Test_t + Result_t]        = object.result;
    js[Test_t + Parameters_t][0] = json{ { Name_t,   PMTSupplyVoltage_t                        },
                                         { Unit_t,   Volt_t                                    },
                                         { Values_t, get_string_array(object.supplyVoltage)    } };
    js[Test_t + Parameters_t][1] = json{ { Name_t,   PMTGain_t                                 },
                                         { Unit_t,   Unitless_t                                },
                                         { Values_t, get_string_array(object.PMTgain)          } };
    js[Test_t + Parameters_t][2] = json{ { Name_t,   RunNumber_t                               },
                                         { Unit_t,   Unitless_t                                },
                                         { Values_t, object.runNumberList                      } };
  }


  /**
   * Convert JSon to PMT high-voltage calibration.
   *
   * \param  js         json
   * \param  object     PMT high-voltage calibration
   */
    inline void from_json(const json& js, JHVCalibration_t& object)
  {
    using namespace std;
    
    stringstream is(js.at(UPI_t).get<string>());

    is >> static_cast<JUPI&>(object);

    object.result          = js.at(Test_t + Result_t).get<string>();
    object.supplyVoltage   = retrieve_value(js.at(Test_t + Parameters_t)[0].at(Values_t).get<vector<string>>());
    object.PMTgain         = retrieve_value(js.at(Test_t + Parameters_t)[1].at(Values_t).get<vector<string>>());
    object.runNumberList   = js.at(Test_t + Parameters_t)[2].at(Values_t).get<vector<string>>();
  }


  /**
   * Auxiliary data structure for module position.
   */
  struct JModulePosition_t :
    public JObjectID,
    public JPosition3D
  {
    /**
     * Default constructor.
     */
    JModulePosition_t()
    {}


    /**
     * Constructor.
     *
     * \param  id             module identifier
     * \param  position       module position
     */
    JModulePosition_t(const JObjectID&   id,
                      const JPosition3D& position) :
      JObjectID  (id),
      JPosition3D(position)
    {}
  };


  /**
   * Convert module position to JSon.
   *
   * \param  js         json
   * \param  object     module position
   */
  inline void to_json(json& js, const JModulePosition_t& object)
  {
    js = json{ { DOMId_t, object.getID() },
               { PX_t,    object.getX()  },
               { PY_t,    object.getY()  },
               { PZ_t,    object.getZ()  } };
  }


  /**
   * Convert JSon to module position.
   *
   * \param  js         json
   * \param  object     module position
   */
  inline void from_json(const json& js, JModulePosition_t& object)
  {
    object.setID(js.at(DOMId_t).get<int>());

    object.setPosition(JPosition3D(js.at(PX_t).get<double>(),
                                   js.at(PY_t).get<double>(),
                                   js.at(PZ_t).get<double>()));
  }

  /**
   * Auxiliary data structure for module rotation.
   */
  struct JModuleRotation_t :
    public JObjectID,
    public JQuaternion3D
  {
    /**
     * Default constructor.
     */
    JModuleRotation_t()
    {}


    /**
     * Constructor.
     *
     * \param  id             module identifier
     * \param  rotation       module rotation
     */
    JModuleRotation_t(const JObjectID&     id,
                      const JQuaternion3D& rotation) :
      JObjectID    (id),
      JQuaternion3D(rotation)
    {}
  };


  /**
   * Convert module rotation to JSon.
   *
   * \param  js         json
   * \param  object     module rotation
   */
  inline void to_json(json& js, const JModuleRotation_t& object)
  {
    js = json{ { DOMId_t, object.getID() },
               { Q0_t,    object.getA()  },
               { QX_t,    object.getB()  },
               { QY_t,    object.getC()  },
               { QZ_t,    object.getD()  } };
  }


  /**
   * Convert JSon to module rotation.
   *
   * \param  js         json
   * \param  object     module rotation
   */
  inline void from_json(const json& js, JModuleRotation_t& object)
  {
    object.setID(js.at(DOMId_t).get<int>());

    object.setQuaternion(JQuaternion3D(js.at(Q0_t).get<double>(),
                                       js.at(QX_t).get<double>(),
                                       js.at(QY_t).get<double>(),
                                       js.at(QZ_t).get<double>()));
  }

  typedef std::vector<JHVCalibration_t>        JHVCalibration;      //!< PMT high voltage calibration
  typedef std::vector<JPMTCalibration_t>       JPMTCalibration;     //!< PMT time calibration
  typedef std::vector<JModulePosition_t>       JModulePosition;     //!< Module position
  typedef std::vector<JModuleRotation_t>       JModuleRotation;     //!< Module rotation
}

#endif