JDetectorCalibration.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JDETECTORCALIBRATION__
#define __JDETECTOR__JDETECTORCALIBRATION__
 
#include <string>
#include <vector>
 
#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 JGEOMETRY3D::JPosition3D;
  using JGEOMETRY3D::JQuaternion3D;
 
  /**
   * Detector calibration key words for JSON I/O.
   */
  static const std::string  Result_t        =  "Result";
  static const std::string  Comment_t       =  "Comment";
  static const std::string  Data_t          =  "Data";
 
  static const std::string  PMTT0s_t        =  "PMTT0s";
  static const std::string  DOMPositions_t  =  "DOMPositions";
  static const std::string  DOMRotations_t  =  "DOMRotations";
 
  static const std::string  PMTSerial_t     =  "PMTSerial";
  static const std::string  DOMSerial_t     =  "DOMSerial";
  static const std::string  DOMId_t         =  "DOMId";
  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";
 
  static const std::string  OK_t            =  "OK";
 
 
  /**
   * 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;
  }
 
 
  /**
   * Auxiliary data structure for PMT calibration.
   */
  struct JPMTCalibration_t :
    public JObjectID,
    public JCalibration
  {
    /**
     * Default constructor.
     */
    JPMTCalibration_t()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  id             PMT identifier
     * \param  calibration    PMT calibration
     */
    JPMTCalibration_t(const JObjectID&    id,
                      const JCalibration& calibration) :
      JObjectID   (id),
      JCalibration(calibration)
    {}
  };
 
 
  /**
   * Convert PMT calibration to JSon.
   *
   * \param  js         json
   * \param  object     PMT 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 calibration.
   *
   * \param  js         json
   * \param  object     PMT 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>());
  }
 
  /**
   * 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(DOMSerial_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(DOMSerial_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<JPMTCalibration_t>     JPMTCalibration;   //!< PMT calibration
  typedef std::vector<JModulePosition_t>     JModulePosition;   //!< Module position
  typedef std::vector<JModuleRotation_t>     JModuleRotation;   //!< Module rotation
}
 
#endif