Define the Swap2 class

src/include/tfrfme.h

 /*! \file tfrfme.h
  *
- * \brief Representation of the trapping configuration objects.
+ * \brief Representation of the trapping calculation objects.
  */
 
 #ifndef INCLUDE_TFRFME_H_
@@ -97,6 +97,146 @@ public:
 /*! \brief Class to represent the second group of trapping swap data.
  */
 class Swap2 {
+protected:
+  //! Number of vector coordinates
+  int nkv;
+  //! QUESTION: definition?
+  double *vkv;
+  //! QUESTION: definition?
+  double **vkzm;
+  //! QUESTION: definition?
+  double apfafa;
+  //! QUESTION: definition?
+  double pmf;
+  //! QUESTION: definition?
+  double spd;
+  //! QUESTION: definition?
+  double rir;
+  //! QUESTION: definition?
+  double ftcn;
+  //! QUESTION: definition?
+  double fshmx;
+  //! QUESTION: definition?
+  double vxyzmx;
+  //! Cartesian displacement. QUESTION: correct?
+  double delxyz;
+  //! QUESTION: definition?
+  double vknmx;
+  //! QUESTION: definition?
+  double delk;
+  //! QUESTION: definition?
+  double delks;
+  //! NLMMT = LM * (LM + 2) * 2
+  int nlmmt;
+  //! Number of radial vector coordinates. QUESTION: correct?
+  int nrvc;
+
+  /*! \brief Load a Swap2 instance from a HDF5 binary file.
+   *
+   * \param file_name: `string` Name of the file to be loaded.
+   * \return instance: `Swap2 *` Pointer to a new Swap2 instance.
+   */
+  static Swap2 *from_hdf5(std::string file_name);
+
+  /*! \brief Load a Swap2 instance from a legacy binary file.
+   *
+   * \param file_name: `string` Name of the file to be loaded.
+   * \return instance: `Swap2 *` Pointer to a new Swap2 instance.
+   */
+  static Swap2 *from_legacy(std::string file_name);
+
+  /*! \brief Save a Swap2 instance to a HDF5 binary file.
+   *
+   * \param file_name: `string` Name of the file to be written.
+   */
+  void write_hdf5(std::string file_name);
+
+  /*! \brief Save a Swap2 instance to a legacy binary file.
+   *
+   * \param file_name: `string` Name of the file to be written.
+   */
+  void write_legacy(std::string file_name);
+
+public:
+  /*! \brief Swap2 instance constructor.
+   *
+   * \param _nkv: `int` Number of vector coordinates. QUESTION: correct?
+   */
+  Swap2(int _nkv);
+
+  /*! \brief Swap2 instance destroyer.
+   */
+  ~Swap2();
+
+  /*! \brief Load a Swap2 instance from binary file.
+   *
+   * \param file_name: `string` Name of the file.
+   * \param mode: `string` Format of the file (can be either "HDF5"
+   * or "LGEACY". Default is "LEGACY").
+   * \return instance: `Swap2 *` Pointer to a newly created Swap2 instance.
+   */
+  static Swap2* from_binary(std::string file_name, std::string mode="LEGACY");
+
+  /*! \brief Get an element from the VKZM matrix.
+   *
+   * \param row: `int` Index of the desired element row.
+   * \param col: `int` Index of the desired element column.
+   * \return value: `double` The value of the requested element.
+   */
+  double get_matrix_element(int row, int col) { return vkzm[row][col]; }
+
+  /*! \brief Get a parameter by its name.
+   *
+   * \param param_name: `string` Name of the parameter.
+   * \return value: `double` The value of the requested parameter.
+   */
+  double get_param(std::string param_name);
+
+  /*! \brief Get an element from the VKV vector.
+   *
+   * \param index: `int` Index of the desired element.
+   * \return value: `double` The value of the requested element.
+   */
+  double get_vector_element(int index) { return vkv[index]; }
+
+  /*! \brief Set an element in the VKZM matrix.
+   *
+   * \param row: `int` Index of the desired element row.
+   * \param col: `int` Index of the desired element column.
+   * \param value: `double` The value of the element to be stored.
+   */
+  void set_matrix_element(int row, int col, double value) { vkzm[row][col] = value; }
+  
+  /*! \brief Set a parameter by its name and value.
+   *
+   * \param param_name: `string` Name of the parameter.
+   * \param value: `double` The value of the parameter.
+   */
+  void set_param(std::string param_name, double value);
+
+  /*! \brief Get an element from the VKV vector.
+   *
+   * \param index: `int` Index of the desired element.
+   * \param value: `double` The value of element to be stored.
+   */
+  void set_vector_element(int index, double value) { vkv[index] = value; }
+
+  /*! \brief Write a Swap2 instance to binary file.
+   *
+   * \param file_name: `string` Name of the file.
+   * \param mode: `string` Format of the file (can be either "HDF5"
+   * or "LGEACY". Default is "LEGACY").
+   */
+  void write_binary(std::string file_name, std::string mode="LEGACY");
+
+  /*! \brief Test whether two instances of Swap2 are equal.
+   *
+   * \param other: `Swap1 &` Reference to the instance to be compared
+   * with.
+   * \return result: `bool` True, if the two instances are equal,
+   * false otherwise.
+   */
+  bool operator ==(Swap2 &other);
 };
 
 /*! \brief Class to represent the trapping configuration.

src/libnptm/tfrfme.cpp

 /*! \file tfrfme.cpp
  *
- * \brief Implementation of the trapping configuration objects.
+ * \brief Implementation of the trapping calculation objects.
  */
 
 #include <complex>
@@ -27,6 +27,7 @@
 
 using namespace std;
 
+// >>> START OF Swap1 CLASS IMPLEMENTATION <<<
 Swap1::Swap1(int lm) {
   nlmmt = 2 * lm * (lm + 2);
   wk = new complex<double>[nlmmt]();
@@ -173,7 +174,357 @@ bool Swap1::operator ==(Swap1 &other) {
   }
   return true;
 }
+// >>> END OF Swap1 CLASS IMPLEMENTATION <<<
 
+// >>> START OF Swap2 CLASS IMPLEMENTATION <<<
+Swap2::Swap2(int _nkv) {
+  nkv = _nkv;
+  vkv = new double[nkv]();
+  vkzm = new double*[nkv];
+  for (int vi = 0; vi < nkv; vi++) vkzm[vi] = new double[nkv]();
+}
+
+Swap2::~Swap2() {
+  delete[] vkv;
+  for (int vi = nkv - 1; vi > -1; vi--) delete[] vkzm[vi];
+  delete[] vkzm;
+}
+
+Swap2* Swap2::from_binary(string file_name, string mode) {
+  Swap2 *instance = NULL;
+  if (mode.compare("LEGACY") == 0) {
+    instance = from_legacy(file_name);
+  } else if (mode.compare("HDF5") == 0) {
+    instance = from_hdf5(file_name);
+  } else {
+    string message = "Unknown format mode: \"" + mode + "\"";
+    throw UnrecognizedFormatException(message);
+  }
+  return instance;
+}
+
+Swap2* Swap2::from_hdf5(string file_name) {
+  Swap2 *instance = NULL;
+  unsigned int flags = H5F_ACC_RDONLY;
+  HDFFile *hdf_file = new HDFFile(file_name, flags);
+  herr_t status = hdf_file->get_status();
+  string str_type;
+  int _nkv, _nlmmt, _nrvc;
+  double value;
+  if (status == 0) {
+    status = hdf_file->read("NKV", "INT32", &_nkv);
+    instance = new Swap2(_nkv);
+    str_type = "FLOAT64_(" + to_string(_nkv) + ")";
+    status = hdf_file->read("VKV", str_type, instance->vkv);
+    str_type = "FLOAT64_(" + to_string(_nkv) + "," + to_string(_nkv) + ")";
+    status = hdf_file->read("VKZM", str_type, instance->vkzm);
+    status = hdf_file->read("APFAFA", "FLOAT64", &value);
+    instance->set_param("apfafa", value);
+    status = hdf_file->read("PMF", "FLOAT64", &value);
+    instance->set_param("pmf", value);
+    status = hdf_file->read("SPD", "FLOAT64", &value);
+    instance->set_param("spd", value);
+    status = hdf_file->read("RIR", "FLOAT64", &value);
+    instance->set_param("rir", value);
+    status = hdf_file->read("FTCN", "FLOAT64", &value);
+    instance->set_param("ftcn", value);
+    status = hdf_file->read("FSHMX", "FLOAT64", &value);
+    instance->set_param("fshmx", value);
+    status = hdf_file->read("VXYZMX", "FLOAT64", &value);
+    instance->set_param("vxyzmx", value);
+    status = hdf_file->read("DELXYZ", "FLOAT64", &value);
+    instance->set_param("delxyz", value);
+    status = hdf_file->read("VKNMX", "FLOAT64", &value);
+    instance->set_param("vknmx", value);
+    status = hdf_file->read("DELK", "FLOAT64", &value);
+    instance->set_param("delk", value);
+    status = hdf_file->read("DELKS", "FLOAT64", &value);
+    instance->set_param("delks", value);
+    status = hdf_file->read("NLMMT", "INT32", &_nlmmt);
+    instance->set_param("nlmmt", 1.0 * _nlmmt);
+    status = hdf_file->read("NRVC", "INT32", &_nrvc);
+    instance->set_param("nrvc", 1.0 * _nrvc);
+    status = hdf_file->close();
+    delete hdf_file;
+  }
+  return instance;
+}
+
+Swap2* Swap2::from_legacy(string file_name) {
+  fstream input;
+  Swap2 *instance = NULL;
+  int _nkv, _nlmmt, _nrvc;
+  double value;
+  input.open(file_name.c_str(), ios::in | ios::binary);
+  if (input.is_open()) {
+    input.read(reinterpret_cast<char *>(&_nkv), sizeof(int));
+    instance = new Swap2(_nkv);
+    for (int vj = 0; vj < _nkv; vj++) {
+      input.read(reinterpret_cast<char *>(&value), sizeof(double));
+      instance->set_vector_element(vj, value);
+    }
+    for (int mi = 0; mi < _nkv; ,i++) {
+      for (int mj = 0; mj < _nkv; mj++) {
+	input.read(reinterpret_cast<char *>(&value), sizeof(double));
+	instance->set_matrix_element(vi, vj, value);
+      }
+    }
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("apfafa", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("pmf", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("spd", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("rir", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("ftcn", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("fshmx", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("vxyzmx", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("delxyz", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("vknmx", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("delk", value);
+    input.read(reinterpret_cast<char *>(&value), sizeof(double));
+    instance->set_param("delks", value);
+    input.read(reinterpret_cast<char *>(&_nlmmt), sizeof(int));
+    instance->set_param("nlmmt", 1.0 * _nlmmt);
+    input.read(reinterpret_cast<char *>(&_nrvc), sizeof(int));
+    instance->set_param("nrvc", 1.0 * _nrvc);
+    input.close();
+  } else {
+    printf("ERROR: could not open input file \"%s\"\n", file_name.c_str());
+  }
+  return instance;
+}
+
+double Swap2::get_param(string param_name) {
+  double value;
+  if (param_name.compare("nkv") == 0) value = 1.0 * nkv;
+  else if (param_name.compare("apfafa") == 0) value = apfafa;
+  else if (param_name.compare("pmf") == 0) value = pmf;
+  else if (param_name.compare("spd") == 0) value = spd;
+  else if (param_name.compare("rir") == 0) value = rir;
+  else if (param_name.compare("ftcn") == 0) value = ftcn;
+  else if (param_name.compare("fshmx") == 0) value = fshmx;
+  else if (param_name.compare("vxyzmx") == 0) value = vxyzmx;
+  else if (param_name.compare("delxyz") == 0) value = delxyz;
+  else if (param_name.compare("vknmx") == 0) value = vknmx;
+  else if (param_name.compare("delk") == 0) value = delk;
+  else if (param_name.compare("delks") == 0) value = delks;
+  else if (param_name.compare("nlmmt") == 0) value = 1.0 * nlmmt;
+  else if (param_name.compare("nrvc") == 0) value = 1.0 * nrvc;
+  else {
+    string message = "Unrecognized parameter name \"" + param_name + "\"";
+    throw UnrecognizedParameterException(message);
+  }
+  return value;
+}
+
+void Swap2::set_param(string param_name, double value) {
+  if (param_name.compare("nkv") == 0) nkv = (int)value;
+  else if (param_name.compare("apfafa") == 0) apfafa = value;
+  else if (param_name.compare("pmf") == 0) pmf = value;
+  else if (param_name.compare("spd") == 0) spd = value;
+  else if (param_name.compare("rir") == 0) rir = value;
+  else if (param_name.compare("ftcn") == 0) ftcn = value;
+  else if (param_name.compare("fshmx") == 0) fshmx = value;
+  else if (param_name.compare("vxyzmx") == 0) vxyzmx = value;
+  else if (param_name.compare("delxyz") == 0) delxyz = value;
+  else if (param_name.compare("vknmx") == 0) vknmx = value;
+  else if (param_name.compare("delk") == 0) delk = value;
+  else if (param_name.compare("delks") == 0) delks = value;
+  else if (param_name.compare("nlmmt") == 0) nlmmt = (int)value;
+  else if (param_name.compare("nrvc") == 0) nrvc = (int)value;
+  else {
+    string message = "Unrecognized parameter name \"" + param_name + "\"";
+    throw UnrecognizedParameterException(message);
+  }
+}
+
+void Swap2::write_binary(string file_name, string mode) {
+  if (mode.compare("LEGACY") == 0) {
+    write_legacy(file_name);
+  } else if (mode.compare("HDF5") == 0) {
+    write_hdf5(file_name);
+  } else {
+    string message = "Unknown format mode: \"" + mode + "\"";
+    throw UnrecognizedFormatException(message);
+  }
+}
+
+void Swap2::write_hdf5(string file_name) {
+  List<string> rec_name_list(1);
+  List<string> rec_type_list(1);
+  List<void *> rec_ptr_list(1);
+  herr_t status;
+  string str_type;
+  rec_name_list.set(0, "NKV");
+  rec_type_list.set(0, "INT32_(1)");
+  rec_ptr_list.set(0, &nkv);
+  rec_name_list.append("VKV");
+  str_type = "FLOAT64_(" + to_string(nkv) + ")";
+  rec_type_list.append(str_type);
+  rec_ptr_list.append(vkv);
+  rec_name_list.append("VKZM");
+  str_type = "FLOAT64_(" + to_string(nkv) + "," + to_string(nkv) + ")";
+  rec_type_list.append(str_type);
+  rec_ptr_list.append(vkzm);
+  rec_name_list.append("APFAFA");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&apfafa);
+  rec_name_list.append("PMF");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&pmf);
+  rec_name_list.append("SPD");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&spd);
+  rec_name_list.append("RIR");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&rir);
+  rec_name_list.append("FTCN");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&ftcn);
+  rec_name_list.append("FSHMX");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&fshmx);
+  rec_name_list.append("VXYZMX");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&vxyzmx);
+  rec_name_list.append("delxyz");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&delxyz);
+  rec_name_list.append("VKNMX");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&vknmx);
+  rec_name_list.append("DELK");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&delk);
+  rec_name_list.append("DELKS");
+  rec_type_list.append("FLOAT64_(1)");
+  rec_ptr_list.append(&delks);
+  rec_name_list.append("NLMMT");
+  rec_type_list.append("INT32_(1)");
+  rec_ptr_list.append(&nlmmt);
+  rec_name_list.append("NRVC");
+  rec_type_list.append("INT32_(1)");
+  rec_ptr_list.append(&nrvc);
+
+  string *rec_names = rec_name_list.to_array();
+  string *rec_types = rec_type_list.to_array();
+  void **rec_pointers = rec_ptr_list.to_array();
+  const int rec_num = rec_name_list.length();
+  FileSchema schema(rec_num, rec_types, rec_names);
+  HDFFile *hdf_file = HDFFile::from_schema(schema, file_name, H5F_ACC_TRUNC);
+  for (int ri = 0; ri < rec_num; ri++)
+    status = hdf_file->write(rec_names[ri], rec_types[ri], rec_pointers[ri]);
+  status = hdf_file->close();
+
+  delete[] rec_names;
+  delete[] rec_types;
+  delete[] rec_pointers;
+  delete hdf_file;
+}
+
+void Swap2::write_legacy(string file_name) {
+  fstream output;
+  double value
+  output.open(file_name.c_str(), ios::out | ios::binary);
+  if (output.is_open()) {
+    output.write(reinterpret_cast<char *>(&nkv), sizeof(int));
+    for (int j = 0; j < nkv; j++){
+      value = vkv[j];
+      output.write(reinterpret_cast<const char*>(&value), sizeof(double));
+    }
+    for (int mi = 0; mi < nkv; mi++) {
+      for (int mj = 0; mj < nkv; mj++) {
+	value = vkzm[mi][mj];
+	output.write(reinterpret_cast<const char*>(&value), sizeof(double));
+      }
+    }
+    output.write(reinterpret_cast<const char*>(&apfafa), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&pmf), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&spd), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&rir), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&ftcn), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&fshmx), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&vxyzmx), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&delxyz), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&vknmx), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&delk), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&delks), sizeof(double));
+    output.write(reinterpret_cast<const char*>(&nlmmt), sizeof(int));
+    output.write(reinterpret_cast<const char*>(&nrvc), sizeof(int));
+    output.close();
+  } else { // Should never occur
+    printf("ERROR: could not open output file \"%s\"\n", file_name.c_str());
+  }
+}
+
+bool Swap2::operator ==(Swap2 &other) {
+  if (nlmmt != other.nlmmt) {
+    return false;
+  }
+  if (nrvc != other.nrvc) {
+    return false;
+  }
+  if (nkv != other.nkv) {
+    return false;
+  }
+  if (apfafa != other.apfafa) {
+    return false;
+  }
+  if (pmf != other.pmf) {
+    return false;
+  }
+  if (spd != other.spd) {
+    return false;
+  }
+  if (rir != other.rir) {
+    return false;
+  }
+  if (ftcn != other.ftcn) {
+    return false;
+  }
+  if (fshmx != other.fshmx) {
+    return false;
+  }
+  if (vxyzmx != other.vxyzmx) {
+    return false;
+  }
+  if (delxyz != other.delxyz) {
+    return false;
+  }
+  if (vknmx != other.vknmx) {
+    return false;
+  }
+  if (delk != other.delk) {
+    return false;
+  }
+  if (delks != other.delks) {
+    return false;
+  }
+  for (int vi = 0; vi < nkv; vi++) {
+    if (vkv[vi] != other.vkv[vi]) {
+      return false;
+    }
+  }
+  for (int mi = 0; mi < nkv; mi++) {
+    for (int mj = 0; mj < nkv; mj++) {
+      if (vkzm[mi][mj] != other.vkzm[mi][mj]) {
+	return false;
+      }
+    }
+  }
+  return true;
+}
+// >>> END OF Swap2 CLASS IMPLEMENTATION <<<
+
+// >>> START OF TFRFME CLASS IMPLEMENTATION <<<
 TFRFME::TFRFME(int _lmode, int _lm, int _nkv, int _nxv, int _nyv, int _nzv) {
   lmode = _lmode;
   lm = _lm;
@@ -611,3 +962,4 @@ bool TFRFME::operator ==(TFRFME &other) {
   } // wi loop
   return true;
 }
+// >>> END OF TFRFME CLASS IMPLEMENTATION <<<