Implements computation kernels [Part 1]

include/IO/seismogram/writer.hpp

@@ -27,10 +27,11 @@ class seismogram_writer : public writer {
    * sampling (seismogram sampling frequency)
    */
   seismogram_writer(const specfem::enums::seismogram::format type,
+                    const specfem::enums::elastic_wave wave_type,
                     const std::string output_folder, const type_real dt,
                     const type_real t0, const int nstep_between_samples)
-      : type(type), output_folder(output_folder), dt(dt), t0(t0),
-        nstep_between_samples(nstep_between_samples){};
+      : type(type), wave_type(wave_type), output_folder(output_folder), dt(dt),
+        t0(t0), nstep_between_samples(nstep_between_samples){};
   /**
    * @brief Write seismograms
    *
@@ -46,6 +47,9 @@ class seismogram_writer : public writer {
                              ///< stored
   type_real dt;              ///< Time interval between subsequent timesteps
   type_real t0;              ///< Solver start time
+  specfem::enums::elastic_wave wave_type; ///< Type of wavefield (Writes
+                                          ///< .BXY for SH waves and .BXX,
+                                          ///< .BXZ for SV waves)
   int nstep_between_samples; ///< number of timesteps between seismogram
                              ///< sampling (seismogram sampling frequency)
 };

include/IO/wavefield/reader.tpp

@@ -10,23 +10,40 @@ specfem::IO::wavefield_reader<IOLibrary>::wavefield_reader(
     : output_folder(output_folder) {}
 
 template <typename IOLibrary>
-void specfem::IO::wavefield_reader<IOLibrary>::read(specfem::compute::assembly &assembly) {
+void specfem::IO::wavefield_reader<IOLibrary>::read(
+    specfem::compute::assembly &assembly) {
   auto &buffer = assembly.fields.buffer;
   auto &boundary_values = assembly.boundary_values;
 
   typename IOLibrary::File file(output_folder + "/ForwardWavefield");
 
-  typename IOLibrary::Group elastic = file.openGroup("/Elastic");
+  typename IOLibrary::Group elastic_sv = file.openGroup("/ElasticSV");
 
-  elastic.openDataset("Displacement", buffer.elastic.h_field).read();
-  elastic.openDataset("Velocity", buffer.elastic.h_field_dot).read();
-  elastic.openDataset("Acceleration", buffer.elastic.h_field_dot_dot).read();
+  const auto &elastic_sv_field =
+      buffer.get_field<specfem::element::medium_tag::elastic_sv>();
+
+  elastic_sv.openDataset("Displacement", elastic_sv_field.h_field).read();
+  elastic_sv.openDataset("Velocity", elastic_sv_field.h_field_dot).read();
+  elastic_sv.openDataset("Acceleration", elastic_sv_field.h_field_dot_dot)
+      .read();
+
+  typename IOLibrary::Group elastic_sh = file.openGroup("/ElasticSH");
+
+  const auto &elastic_sh_field =
+      buffer.get_field<specfem::element::medium_tag::elastic_sh>();
+
+  elastic_sh.openDataset("Displacement", elastic_sh_field.h_field).read();
+  elastic_sh.openDataset("Velocity", elastic_sh_field.h_field_dot).read();
+  elastic_sh.openDataset("Acceleration", elastic_sh_field.h_field_dot_dot)
+      .read();
 
   typename IOLibrary::Group acoustic = file.openGroup("/Acoustic");
+  const auto &acoustic_field =
+      buffer.get_field<specfem::element::medium_tag::acoustic>();
 
-  acoustic.openDataset("Potential", buffer.acoustic.h_field).read();
-  acoustic.openDataset("PotentialDot", buffer.acoustic.h_field_dot).read();
-  acoustic.openDataset("PotentialDotDot", buffer.acoustic.h_field_dot_dot)
+  acoustic.openDataset("Potential", acoustic_field.h_field).read();
+  acoustic.openDataset("PotentialDot", acoustic_field.h_field_dot).read();
+  acoustic.openDataset("PotentialDotDot", acoustic_field.h_field_dot_dot)
       .read();
 
   typename IOLibrary::Group boundary = file.openGroup("/Boundary");

include/IO/wavefield/writer.tpp

@@ -1,16 +1,17 @@
 #pragma once
 
+#include "IO/wavefield/writer.hpp"
 #include "compute/interface.hpp"
 #include "enumerations/interface.hpp"
-#include "IO/wavefield/writer.hpp"
 
 template <typename OutputLibrary>
 specfem::IO::wavefield_writer<OutputLibrary>::wavefield_writer(
     const std::string output_folder)
     : output_folder(output_folder) {}
 
 template <typename OutputLibrary>
-void specfem::IO::wavefield_writer<OutputLibrary>::write(specfem::compute::assembly &assembly) {
+void specfem::IO::wavefield_writer<OutputLibrary>::write(
+    specfem::compute::assembly &assembly) {
   auto &forward = assembly.fields.forward;
   auto &boundary_values = assembly.boundary_values;
 
@@ -19,20 +20,32 @@ void specfem::IO::wavefield_writer<OutputLibrary>::write(specfem::compute::assem
 
   typename OutputLibrary::File file(output_folder + "/ForwardWavefield");
 
-  typename OutputLibrary::Group elastic = file.createGroup("/Elastic");
+  typename OutputLibrary::Group elastic_sv = file.createGroup("/ElasticSV");
+  const auto &elastic_sv_field =
+      forward.get_field<specfem::element::medium_tag::elastic_sv>();
+  typename OutputLibrary::Group elastic_sh = file.createGroup("/ElasticSH");
+  const auto &elastic_sh_field =
+      forward.get_field<specfem::element::medium_tag::elastic_sh>();
   typename OutputLibrary::Group acoustic = file.createGroup("/Acoustic");
+  const auto &acoustic_field =
+      forward.get_field<specfem::element::medium_tag::acoustic>();
   typename OutputLibrary::Group boundary = file.createGroup("/Boundary");
   typename OutputLibrary::Group stacey = boundary.createGroup("/Stacey");
 
-  elastic.createDataset("Displacement", forward.elastic.h_field).write();
-  elastic.createDataset("Velocity", forward.elastic.h_field_dot).write();
-  elastic.createDataset("Acceleration", forward.elastic.h_field_dot_dot).write();
+  elastic_sv.createDataset("Displacement", elastic_sv_field.h_field).write();
+  elastic_sv.createDataset("Velocity", elastic_sv_field.h_field_dot).write();
+  elastic_sv.createDataset("Acceleration", elastic_sv_field.h_field_dot_dot)
+      .write();
 
-  acoustic.createDataset("Potential", forward.acoustic.h_field).write();
-  acoustic.createDataset("PotentialDot", forward.acoustic.h_field_dot).write();
-  acoustic.createDataset("PotentialDotDot", forward.acoustic.h_field_dot_dot)
+  elastic_sh.createDataset("Displacement", elastic_sh_field.h_field).write();
+  elastic_sh.createDataset("Velocity", elastic_sh_field.h_field_dot).write();
+  elastic_sh.createDataset("Acceleration", elastic_sh_field.h_field_dot_dot)
       .write();
 
+  acoustic.createDataset("Potential", acoustic_field.h_field).write();
+  acoustic.createDataset("PotentialDot", acoustic_field.h_field_dot).write();
+  acoustic.createDataset("PotentialDotDot", acoustic_field.h_field_dot_dot).write();
+
   stacey
       .createDataset("IndexMapping",
                      boundary_values.stacey.h_property_index_mapping)