Commit 6a865040 authored by Giovanni La Mura's avatar Giovanni La Mura
Browse files

Implement ClusterOutputInfo::insert() function

parent 79829096

src/include/outputs.h

+9 −0
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ protected: 
  int _num_phi;

  //! \brief Number of scattered elevation calculations.

  int _num_phis;

  //! \brief ID of the first computed wavelength

  int _first_xi;

  

  /*! \brief Write the output to a HDF5 file.

   *
@@ -488,6 +490,13 @@ public: 
   */

  long compute_size();



  /*! \brief Insert in the current output data the data of another block.

   *

   * \param rhs: `const ClusterOutputData &` Reference to the source data block.

   * \return result: `int` Exit code (0 if successful).

   */

  int insert(const ClusterOutputInfo &rhs);



  /*! \brief Write the output to a file.

   *

   * \param output: `const string &` Path to the output to be written.

src/libnptm/outputs.cpp

+187 −5
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <cstdio>

#include <exception>

#include <string>

#include <cstring>

#include <hdf5.h>



#ifdef USE_MPI
@@ -104,7 +105,7 @@ ClusterOutputInfo::ClusterOutputInfo( 
  nxi = sc->number_of_scales;

  xi_block_size = (xi_length == 0) ? nxi : xi_length;

  vec_jxi = new int[xi_block_size]();

  vec_jxi[0] = first_xi;

  _first_xi = first_xi;

  vec_ier = new short[xi_block_size]();

  vec_vk = new double[xi_block_size]();

  vec_xi = new double[xi_block_size]();
@@ -439,7 +440,7 @@ long ClusterOutputInfo::compute_size( 
  int first_xi, int xi_length

) {

  long result = sizeof(np_int);

  result += 19 * sizeof(int);

  result += 20 * sizeof(int);

  result += 56 * sizeof(double);

  result += 121 * sizeof(long);

  int _nsph = gc->number_of_spheres;
@@ -494,7 +495,7 @@ long ClusterOutputInfo::compute_size( 


long ClusterOutputInfo::compute_size() {

  long result = sizeof(np_int);

  result += 19 * sizeof(int);

  result += 20 * sizeof(int);

  result += 56 * sizeof(double);

  result += 121 * sizeof(long);

  result += 3 * nsph * sizeof(double); // sphere coordinate vectors
@@ -526,6 +527,187 @@ long ClusterOutputInfo::compute_size() { 
  return result;

}



int ClusterOutputInfo::insert(const ClusterOutputInfo &rhs) {

  int result = 0;

  result += (rhs.inpol == inpol) ? 0 : 1;

  result += (rhs.iavm == iavm) ? 0 : 1;

  result += (rhs.isam == isam) ? 0 : 1;

  result += (rhs._num_theta == _num_theta) ? 0 : 1;

  result += (rhs._num_thetas == _num_thetas) ? 0 : 1;

  result += (rhs._num_phi == _num_phi) ? 0 : 1;

  result += (rhs._num_phis == _num_phis) ? 0 : 1;

  result += (rhs.ndirs == ndirs) ? 0 : 1;

  result += (rhs.exri == exri) ? 0 : 1;

  result += (rhs.idfc == idfc) ? 0 : 1;

  result += (rhs.configurations == configurations) ? 0 : 1;

  if (result == 0) {

    int offset, chunk_size, xi1;

    xi1 = rhs._first_xi;

    // Insert vectors whose size depends on wavelengths

    offset = xi1 - 1;

    chunk_size = rhs.xi_block_size;

    memcpy(vec_jxi + offset, rhs.vec_jxi, chunk_size * sizeof(int));

    memcpy(vec_ier + offset, rhs.vec_ier, chunk_size * sizeof(short));

    memcpy(vec_vk + offset, rhs.vec_vk, chunk_size * sizeof(double));

    memcpy(vec_xi + offset, rhs.vec_xi, chunk_size * sizeof(double));

    memcpy(vec_fsat + offset, rhs.vec_fsat, chunk_size * sizeof(dcomplex));

    memcpy(vec_qschut + offset, rhs.vec_qschut, chunk_size * sizeof(double));

    memcpy(vec_pschut + offset, rhs.vec_pschut, chunk_size * sizeof(double));

    memcpy(vec_s0magt + offset, rhs.vec_s0magt, chunk_size * sizeof(double));

    memcpy(vec_scc1 + offset, rhs.vec_scc1, chunk_size * sizeof(double));

    memcpy(vec_scc2 + offset, rhs.vec_scc2, chunk_size * sizeof(double));

    memcpy(vec_abc1 + offset, rhs.vec_abc1, chunk_size * sizeof(double));

    memcpy(vec_abc2 + offset, rhs.vec_abc2, chunk_size * sizeof(double));

    memcpy(vec_exc1 + offset, rhs.vec_exc1, chunk_size * sizeof(double));

    memcpy(vec_exc2 + offset, rhs.vec_exc2, chunk_size * sizeof(double));

    memcpy(vec_albedc1 + offset, rhs.vec_albedc1, chunk_size * sizeof(double));

    memcpy(vec_albedc2 + offset, rhs.vec_albedc2, chunk_size * sizeof(double));

    memcpy(vec_qscamc1 + offset, rhs.vec_qscamc1, chunk_size * sizeof(double));

    memcpy(vec_qscamc2 + offset, rhs.vec_qscamc2, chunk_size * sizeof(double));

    memcpy(vec_qabsmc1 + offset, rhs.vec_qabsmc1, chunk_size * sizeof(double));

    memcpy(vec_qabsmc2 + offset, rhs.vec_qabsmc2, chunk_size * sizeof(double));

    memcpy(vec_qextmc1 + offset, rhs.vec_qextmc1, chunk_size * sizeof(double));

    memcpy(vec_qextmc2 + offset, rhs.vec_qextmc2, chunk_size * sizeof(double));

    memcpy(vec_sccrt1 + offset, rhs.vec_sccrt1, chunk_size * sizeof(double));

    memcpy(vec_sccrt2 + offset, rhs.vec_sccrt2, chunk_size * sizeof(double));

    memcpy(vec_abcrt1 + offset, rhs.vec_abcrt1, chunk_size * sizeof(double));

    memcpy(vec_abcrt2 + offset, rhs.vec_abcrt2, chunk_size * sizeof(double));

    memcpy(vec_excrt1 + offset, rhs.vec_excrt1, chunk_size * sizeof(double));

    memcpy(vec_excrt2 + offset, rhs.vec_excrt2, chunk_size * sizeof(double));

    memcpy(vec_fsac11 + offset, rhs.vec_fsac11, chunk_size * sizeof(dcomplex));

    memcpy(vec_fsac21 + offset, rhs.vec_fsac21, chunk_size * sizeof(dcomplex));

    memcpy(vec_fsac22 + offset, rhs.vec_fsac22, chunk_size * sizeof(dcomplex));

    memcpy(vec_fsac12 + offset, rhs.vec_fsac12, chunk_size * sizeof(dcomplex));

    memcpy(vec_qschuc1 + offset, rhs.vec_qschuc1, chunk_size * sizeof(double));

    memcpy(vec_qschuc2 + offset, rhs.vec_qschuc2, chunk_size * sizeof(double));

    memcpy(vec_pschuc1 + offset, rhs.vec_pschuc1, chunk_size * sizeof(double));

    memcpy(vec_pschuc2 + offset, rhs.vec_pschuc2, chunk_size * sizeof(double));

    memcpy(vec_s0magc1 + offset, rhs.vec_s0magc1, chunk_size * sizeof(double));

    memcpy(vec_s0magc2 + offset, rhs.vec_s0magc2, chunk_size * sizeof(double));

    memcpy(vec_cosavc1 + offset, rhs.vec_cosavc1, chunk_size * sizeof(double));

    memcpy(vec_cosavc2 + offset, rhs.vec_cosavc2, chunk_size * sizeof(double));

    memcpy(vec_raprc1 + offset, rhs.vec_raprc1, chunk_size * sizeof(double));

    memcpy(vec_raprc2 + offset, rhs.vec_raprc2, chunk_size * sizeof(double));

    memcpy(vec_fkc1 + offset, rhs.vec_fkc1, chunk_size * sizeof(double));

    memcpy(vec_fkc2 + offset, rhs.vec_fkc2, chunk_size * sizeof(double));

    // Insert vectors of multiple configuration values per scale

    offset = (xi1 - 1) * configurations;

    chunk_size = rhs.xi_block_size * configurations;

    memcpy(vec_sphere_sizes + offset, rhs.vec_sphere_sizes, chunk_size * sizeof(double));

    memcpy(vec_sphere_ref_indices + offset, rhs.vec_sphere_ref_indices, chunk_size * sizeof(dcomplex));

    memcpy(vec_sphere_scs + offset, rhs.vec_sphere_scs, chunk_size * sizeof(double));

    memcpy(vec_sphere_abs + offset, rhs.vec_sphere_abs, chunk_size * sizeof(double));

    memcpy(vec_sphere_exs + offset, rhs.vec_sphere_exs, chunk_size * sizeof(double));

    memcpy(vec_sphere_albs + offset, rhs.vec_sphere_albs, chunk_size * sizeof(double));

    memcpy(vec_sphere_sqscs + offset, rhs.vec_sphere_sqscs, chunk_size * sizeof(double));

    memcpy(vec_sphere_sqabs + offset, rhs.vec_sphere_sqabs, chunk_size * sizeof(double));

    memcpy(vec_sphere_sqexs + offset, rhs.vec_sphere_sqexs, chunk_size * sizeof(double));

    memcpy(vec_fsas + offset, rhs.vec_fsas, chunk_size * sizeof(dcomplex));

    memcpy(vec_qschus + offset, rhs.vec_qschus, chunk_size * sizeof(double));

    memcpy(vec_pschus + offset, rhs.vec_pschus, chunk_size * sizeof(double));

    memcpy(vec_s0mags + offset, rhs.vec_s0mags, chunk_size * sizeof(double));

    memcpy(vec_cosavs + offset, rhs.vec_cosavs, chunk_size * sizeof(double));

    memcpy(vec_raprs + offset, rhs.vec_raprs, chunk_size * sizeof(double));

    memcpy(vec_tqek1 + offset, rhs.vec_tqek1, chunk_size * sizeof(double));

    memcpy(vec_tqsk1 + offset, rhs.vec_tqsk1, chunk_size * sizeof(double));

    memcpy(vec_tqek2 + offset, rhs.vec_tqek2, chunk_size * sizeof(double));

    memcpy(vec_tqsk2 + offset, rhs.vec_tqsk2, chunk_size * sizeof(double));

    // Insert vectors of multiple directions per configuration

    offset = (xi1 - 1) * configurations * ndirs;

    chunk_size = rhs.xi_block_size * configurations * ndirs;

    memcpy(vec_dir_sas11 + offset, rhs.vec_dir_sas11, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sas21 + offset, rhs.vec_dir_sas21, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sas12 + offset, rhs.vec_dir_sas12, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sas22 + offset, rhs.vec_dir_sas22, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_muls + 16 * offset, rhs.vec_dir_muls, 16 * chunk_size * sizeof(double));

    memcpy(vec_dir_mulslr + 16 * offset, rhs.vec_dir_mulslr, 16 * chunk_size * sizeof(double));

    // Insert vectors whose sizes depend on wavelengths and directions.

    offset = (xi1 - 1) * ndirs;

    chunk_size = rhs.xi_block_size * ndirs;

    memcpy(vec_dir_sat11 + offset, rhs.vec_dir_sat11, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sat21 + offset, rhs.vec_dir_sat21, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sat12 + offset, rhs.vec_dir_sat12, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sat22 + offset, rhs.vec_dir_sat22, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_scc1 + offset, rhs.vec_scc1, chunk_size * sizeof(double));

    memcpy(vec_dir_scc2 + offset, rhs.vec_scc2, chunk_size * sizeof(double));

    memcpy(vec_dir_abc1 + offset, rhs.vec_abc1, chunk_size * sizeof(double));

    memcpy(vec_dir_abc2 + offset, rhs.vec_abc2, chunk_size * sizeof(double));

    memcpy(vec_dir_exc1 + offset, rhs.vec_exc1, chunk_size * sizeof(double));

    memcpy(vec_dir_exc2 + offset, rhs.vec_exc2, chunk_size * sizeof(double));

    memcpy(vec_dir_albedc1 + offset, rhs.vec_albedc1, chunk_size * sizeof(double));

    memcpy(vec_dir_albedc2 + offset, rhs.vec_albedc2, chunk_size * sizeof(double));

    memcpy(vec_dir_qscc1 + offset, rhs.vec_dir_qscc1, chunk_size * sizeof(double));

    memcpy(vec_dir_qscc2 + offset, rhs.vec_dir_qscc2, chunk_size * sizeof(double));

    memcpy(vec_dir_qabc1 + offset, rhs.vec_dir_qabc1, chunk_size * sizeof(double));

    memcpy(vec_dir_qabc2 + offset, rhs.vec_dir_qabc2, chunk_size * sizeof(double));

    memcpy(vec_dir_qexc1 + offset, rhs.vec_dir_qexc1, chunk_size * sizeof(double));

    memcpy(vec_dir_qexc2 + offset, rhs.vec_dir_qexc2, chunk_size * sizeof(double));

    memcpy(vec_dir_sccrt1 + offset, rhs.vec_dir_sccrt1, chunk_size * sizeof(double));

    memcpy(vec_dir_sccrt2 + offset, rhs.vec_dir_sccrt2, chunk_size * sizeof(double));

    memcpy(vec_dir_abcrt1 + offset, rhs.vec_dir_abcrt1, chunk_size * sizeof(double));

    memcpy(vec_dir_abcrt2 + offset, rhs.vec_dir_abcrt2, chunk_size * sizeof(double));

    memcpy(vec_dir_excrt1 + offset, rhs.vec_dir_excrt1, chunk_size * sizeof(double));

    memcpy(vec_dir_excrt2 + offset, rhs.vec_dir_excrt2, chunk_size * sizeof(double));

    memcpy(vec_dir_fsac11 + offset, rhs.vec_dir_fsac11, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_fsac21 + offset, rhs.vec_dir_fsac21, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_fsac12 + offset, rhs.vec_dir_fsac12, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_fsac22 + offset, rhs.vec_dir_fsac22, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sac11 + offset, rhs.vec_dir_sac11, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sac21 + offset, rhs.vec_dir_sac21, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sac12 + offset, rhs.vec_dir_sac12, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_sac22 + offset, rhs.vec_dir_sac22, chunk_size * sizeof(dcomplex));

    memcpy(vec_dir_qschuc1 + offset, rhs.vec_qschuc1, chunk_size * sizeof(double));

    memcpy(vec_dir_qschuc2 + offset, rhs.vec_qschuc2, chunk_size * sizeof(double));

    memcpy(vec_dir_pschuc1 + offset, rhs.vec_pschuc1, chunk_size * sizeof(double));

    memcpy(vec_dir_pschuc2 + offset, rhs.vec_pschuc2, chunk_size * sizeof(double));

    memcpy(vec_dir_s0magc1 + offset, rhs.vec_s0magc1, chunk_size * sizeof(double));

    memcpy(vec_dir_s0magc2 + offset, rhs.vec_s0magc2, chunk_size * sizeof(double));

    memcpy(vec_dir_cosavc1 + offset, rhs.vec_cosavc1, chunk_size * sizeof(double));

    memcpy(vec_dir_cosavc2 + offset, rhs.vec_cosavc2, chunk_size * sizeof(double));

    memcpy(vec_dir_raprc1 + offset, rhs.vec_raprc1, chunk_size * sizeof(double));

    memcpy(vec_dir_raprc2 + offset, rhs.vec_raprc2, chunk_size * sizeof(double));

    memcpy(vec_dir_flc1 + offset, rhs.vec_dir_flc1, chunk_size * sizeof(double));

    memcpy(vec_dir_flc2 + offset, rhs.vec_dir_flc2, chunk_size * sizeof(double));

    memcpy(vec_dir_frc1 + offset, rhs.vec_dir_frc1, chunk_size * sizeof(double));

    memcpy(vec_dir_frc2 + offset, rhs.vec_dir_frc2, chunk_size * sizeof(double));

    memcpy(vec_dir_fkc1 + offset, rhs.vec_dir_fkc1, chunk_size * sizeof(double));

    memcpy(vec_dir_fkc2 + offset, rhs.vec_dir_fkc2, chunk_size * sizeof(double));

    memcpy(vec_dir_fxc1 + offset, rhs.vec_dir_fxc1, chunk_size * sizeof(double));

    memcpy(vec_dir_fxc2 + offset, rhs.vec_dir_fxc2, chunk_size * sizeof(double));

    memcpy(vec_dir_fyc1 + offset, rhs.vec_dir_fyc1, chunk_size * sizeof(double));

    memcpy(vec_dir_fyc2 + offset, rhs.vec_dir_fyc2, chunk_size * sizeof(double));

    memcpy(vec_dir_fzc1 + offset, rhs.vec_dir_fzc1, chunk_size * sizeof(double));

    memcpy(vec_dir_fzc2 + offset, rhs.vec_dir_fzc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqelc1 + offset, rhs.vec_dir_tqelc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqelc2 + offset, rhs.vec_dir_tqelc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqerc1 + offset, rhs.vec_dir_tqerc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqerc2 + offset, rhs.vec_dir_tqerc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqekc1 + offset, rhs.vec_dir_tqekc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqekc2 + offset, rhs.vec_dir_tqekc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqexc1 + offset, rhs.vec_dir_tqexc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqexc2 + offset, rhs.vec_dir_tqexc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqeyc1 + offset, rhs.vec_dir_tqeyc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqeyc2 + offset, rhs.vec_dir_tqeyc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqezc1 + offset, rhs.vec_dir_tqezc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqezc2 + offset, rhs.vec_dir_tqezc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqslc1 + offset, rhs.vec_dir_tqslc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqslc2 + offset, rhs.vec_dir_tqslc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqsrc1 + offset, rhs.vec_dir_tqsrc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqsrc2 + offset, rhs.vec_dir_tqsrc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqskc1 + offset, rhs.vec_dir_tqskc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqskc2 + offset, rhs.vec_dir_tqskc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqsxc1 + offset, rhs.vec_dir_tqsxc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqsxc2 + offset, rhs.vec_dir_tqsxc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqsyc1 + offset, rhs.vec_dir_tqsyc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqsyc2 + offset, rhs.vec_dir_tqsyc2, chunk_size * sizeof(double));

    memcpy(vec_dir_tqszc1 + offset, rhs.vec_dir_tqszc1, chunk_size * sizeof(double));

    memcpy(vec_dir_tqszc2 + offset, rhs.vec_dir_tqszc2, chunk_size * sizeof(double));

    memcpy(vec_dir_mulc + 16 * offset, rhs.vec_dir_mulc, 16 * chunk_size * sizeof(double));

    memcpy(vec_dir_mulclr + 16 * offset, rhs.vec_dir_mulclr, 16 * chunk_size * sizeof(double));

  }

  return result;

}



int ClusterOutputInfo::write(const std::string &output, const std::string &format) {

  int result = 0;

  if (format.compare("LEGACY") == 0) {
@@ -1188,7 +1370,7 @@ int ClusterOutputInfo::mpireceive(const mixMPI *mpidata, int pid) { 
    offset = xi1 - 1;

    // Receive vectors of single values per scale

    MPI_Recv(vec_jxi + offset, chunk_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

    MPI_Recv(vec_ier + offset, chunk_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

    MPI_Recv(vec_ier + offset, chunk_size, MPI_SHORT, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

    MPI_Recv(vec_vk + offset, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

    MPI_Recv(vec_xi + offset, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

    MPI_Recv(vec_fsat + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
@@ -1378,7 +1560,7 @@ int ClusterOutputInfo::mpisend(const mixMPI *mpidata) { 
    MPI_Send(vec_jxi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);

    MPI_Send(&xi_block_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);

    MPI_Send(vec_jxi, xi_block_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);

    MPI_Send(vec_ier, xi_block_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);

    MPI_Send(vec_ier, xi_block_size, MPI_SHORT, 0, 10, MPI_COMM_WORLD);

    MPI_Send(vec_vk, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);

    MPI_Send(vec_xi, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);

    MPI_Send(vec_fsat, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);