Introduce update_scan_paths

Author: masterleinad

application/adamantine.hh

@@ -775,10 +775,10 @@ run(MPI_Comm const &communicator, boost::property_tree::ptree const &database,
     heat_sources = thermal_physics->get_heat_sources();
     // Store the current end time of each heat source and set a flag that the
     // scan path has changed
-    for (auto const &source : heat_sources)
+    auto const& scan_paths = heat_sources.get_scan_paths();
+    for (auto const &scan_path : scan_paths)
     {
-      scan_path_end.emplace_back(
-          source->get_scan_path().get_segment_list().back().end_time, true);
+      scan_path_end.emplace_back(scan_path.get_segment_list().back().end_time, true);
     }
     post_processor_database.put("thermal_output", true);
   }
@@ -1026,14 +1026,15 @@ run(MPI_Comm const &communicator, boost::property_tree::ptree const &database,
       }
       if (scan_path_updated)
       {
+        adamantine::HeatSources<dim, dealii::MemorySpace::Host> host_heat_sources = heat_sources.copy_to(dealii::MemorySpace::Host{});
+        host_heat_sources.update_scan_paths();
+        heat_sources = host_heat_sources.copy_to(MemorySpaceType{});
+  
+    auto const& scan_paths = heat_sources.get_scan_paths();
         for (unsigned int s = 0; s < scan_path_end.size(); ++s)
         {
-          // Read the scan path file
-          heat_sources[s]->get_scan_path().read_file();
-
           // Update scan_path_end
-          double new_end_time = heat_sources[s]
-                                    ->get_scan_path()
+          double new_end_time = scan_paths[s]
                                     .get_segment_list()
                                     .back()
                                     .end_time;
@@ -1044,7 +1045,7 @@ run(MPI_Comm const &communicator, boost::property_tree::ptree const &database,
         std::tie(material_deposition_boxes, deposition_times, deposition_cos,
                  deposition_sin) =
             adamantine::create_material_deposition_boxes<dim>(geometry_database,
-                                                              heat_sources);
+                                                              host_heat_sources);
       }
 
       auto activation_start =

source/DataAssimilator.hh

@@ -14,7 +14,6 @@
 #include <deal.II/fe/mapping_q1_eulerian.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/la_parallel_block_vector.h>
-#include <deal.II/lac/la_vector.h>
 #include <deal.II/lac/solver_gmres.h>
 #include <deal.II/lac/sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparse_matrix.h>

source/ElectronBeamHeatSource.hh

@@ -53,6 +53,11 @@ public:
    */
   ScanPath<MemorySpaceType> const &get_scan_path() const;
 
+  void set_scan_path(ScanPath<MemorySpaceType> const scan_path)
+  {
+    _scan_path = scan_path;
+  }
+
   /**
    * Compute the current height of the where the heat source meets the material
    * (i.e. the current scan path height).

source/GoldakHeatSource.hh

@@ -53,6 +53,11 @@ public:
    */
   ScanPath<MemorySpaceType> const &get_scan_path() const;
 
+  void set_scan_path(ScanPath<MemorySpaceType> const scan_path)
+  {
+    _scan_path = scan_path;
+  }
+
   /**
    * Compute the current height of the where the heat source meets the material
    * (i.e. the current scan path height).

source/HeatSources.hh

@@ -43,6 +43,14 @@ public:
    */
   void update_time(double time);
 
+  /**
+   * Update the scan paths for all heat sources reading again from the
+   * respective files.
+   */
+  template <typename Dummy = MemorySpaceType>
+  std::enable_if_t<std::is_same_v<Dummy, dealii::MemorySpace::Host>>
+  update_scan_paths();
+
   /**
    * Compute the cumulative heat source at a given point at a given time given
    * the current height of the object being manufactured.
@@ -77,6 +85,11 @@ private:
   friend class HeatSources<dim, dealii::MemorySpace::Default>;
   friend class HeatSources<dim, dealii::MemorySpace::Host>;
 
+  /**
+   * Private helper for update_scan_paths
+   */
+  void internal_update_scan_paths();
+
   /**
    * Private constructor used by copy_to_host.
    */
@@ -117,17 +130,70 @@ private:
   std::vector<int> _electron_beam_indices;
   std::vector<int> _cube_indices;
   std::vector<int> _goldak_indices;
+
+  std::vector<std::string> _goldak_scan_files;
+  std::vector<std::string> _electron_beam_scan_files;
+  std::vector<std::string> _goldak_scan_formats;
+  std::vector<std::string> _electron_beam_scan_formats;
 };
 
+template <int dim, typename MemorySpaceType>
+void HeatSources<dim, MemorySpaceType>::internal_update_scan_paths()
+{
+  std::vector<ScanPathSegment> scan_path_segments;
+  _goldak_scan_path_segments.clear();
+  for (unsigned int i = 0; i < _goldak_indices.size(); ++i)
+  {
+    scan_path_segments = ScanPath<MemorySpaceType>::extract_scan_paths(
+        _goldak_scan_files[i], _goldak_scan_formats[i]);
+    _goldak_scan_path_segments.emplace_back(
+        Kokkos::view_alloc(Kokkos::WithoutInitializing,
+                           "goldak_scan_path_segments_" + std::to_string(i)),
+        scan_path_segments.size());
+    Kokkos::deep_copy(
+        _goldak_scan_path_segments.back(),
+        Kokkos::View<ScanPathSegment *, Kokkos::HostSpace>(
+            scan_path_segments.data(), scan_path_segments.size()));
+  }
+  _electron_beam_scan_path_segments.clear();
+  for (unsigned int i = 0; i < _electron_beam_indices.size(); ++i)
+  {
+    scan_path_segments = ScanPath<MemorySpaceType>::extract_scan_paths(
+        _electron_beam_scan_files[i], _electron_beam_scan_formats[i]);
+    _electron_beam_scan_path_segments.emplace_back(
+        Kokkos::view_alloc(Kokkos::WithoutInitializing,
+                           "electron_beam_scan_path_segments_" +
+                               std::to_string(i)),
+        scan_path_segments.size());
+    Kokkos::deep_copy(
+        _electron_beam_scan_path_segments.back(),
+        Kokkos::View<ScanPathSegment *, Kokkos::HostSpace>(
+            scan_path_segments.data(), scan_path_segments.size()));
+  }
+}
+
+template <int dim, typename MemorySpaceType>
+template <typename Dummy>
+std::enable_if_t<std::is_same_v<Dummy, dealii::MemorySpace::Host>>
+HeatSources<dim, MemorySpaceType>::update_scan_paths()
+{
+  internal_update_scan_paths();
+
+  for (unsigned int i = 0; i < _goldak_heat_sources.size(); ++i)
+    _goldak_heat_sources(i).set_scan_path(
+        ScanPath<MemorySpaceType>{_goldak_scan_path_segments[i]});
+  for (unsigned int i = 0; i < _electron_beam_heat_sources.size(); ++i)
+    _electron_beam_heat_sources(i).set_scan_path(
+        ScanPath<MemorySpaceType>{_electron_beam_scan_path_segments[i]});
+}
+
 template <int dim, typename MemorySpaceType>
 HeatSources<dim, MemorySpaceType>::HeatSources(
     boost::property_tree::ptree const &source_database)
 {
   unsigned int const n_beams = source_database.get<unsigned int>("n_beams");
   std::vector<BeamHeatSourceProperties> goldak_beams;
   std::vector<BeamHeatSourceProperties> electron_beam_beams;
-  std::vector<std::vector<ScanPathSegment>> goldak_scan_path_segments;
-  std::vector<std::vector<ScanPathSegment>> electron_beam_scan_path_segments;
   std::vector<CubeHeatSource<dim>> cube_heat_sources;
 
   for (unsigned int i = 0; i < n_beams; ++i)
@@ -138,20 +204,20 @@ HeatSources<dim, MemorySpaceType>::HeatSources(
     if (type == "goldak")
     {
       goldak_beams.emplace_back(beam_database);
-      goldak_scan_path_segments.push_back(
-          ScanPath<MemorySpaceType>::extract_scan_paths(
-              beam_database.get<std::string>("scan_path_file"),
-              beam_database.get<std::string>("scan_path_file_format")));
       _goldak_indices.push_back(i);
+      _goldak_scan_files.push_back(
+          beam_database.get<std::string>("scan_path_file"));
+      _goldak_scan_formats.push_back(
+          beam_database.get<std::string>("scan_path_file_format"));
     }
     else if (type == "electron_beam")
     {
       electron_beam_beams.emplace_back(beam_database);
-      electron_beam_scan_path_segments.push_back(
-          ScanPath<MemorySpaceType>::extract_scan_paths(
-              beam_database.get<std::string>("scan_path_file"),
-              beam_database.get<std::string>("scan_path_file_format")));
       _electron_beam_indices.push_back(i);
+      _electron_beam_scan_files.push_back(
+          beam_database.get<std::string>("scan_path_file"));
+      _electron_beam_scan_formats.push_back(
+          beam_database.get<std::string>("scan_path_file_format"));
     }
     else if (type == "cube")
     {
@@ -166,35 +232,20 @@ HeatSources<dim, MemorySpaceType>::HeatSources(
     }
   }
 
+  internal_update_scan_paths();
+
   std::vector<GoldakHeatSource<dim, MemorySpaceType>> goldak_heat_sources;
-  for (unsigned int i = 0; i < goldak_scan_path_segments.size(); ++i)
+  for (unsigned int i = 0; i < goldak_beams.size(); ++i)
   {
-    _goldak_scan_path_segments.emplace_back(
-        Kokkos::view_alloc(Kokkos::WithoutInitializing,
-                           "goldak_scan_path_segments_" + std::to_string(i)),
-        goldak_scan_path_segments[i].size());
-    Kokkos::deep_copy(_goldak_scan_path_segments.back(),
-                      Kokkos::View<ScanPathSegment *, Kokkos::HostSpace>(
-                          goldak_scan_path_segments[i].data(),
-                          goldak_scan_path_segments[i].size()));
     goldak_heat_sources.emplace_back(
         goldak_beams[i],
         ScanPath<MemorySpaceType>(_goldak_scan_path_segments.back()));
   }
 
   std::vector<ElectronBeamHeatSource<dim, MemorySpaceType>>
       electron_beam_heat_sources;
-  for (unsigned int i = 0; i < electron_beam_scan_path_segments.size(); ++i)
+  for (unsigned int i = 0; i < electron_beam_beams.size(); ++i)
   {
-    _electron_beam_scan_path_segments.emplace_back(
-        Kokkos::view_alloc(Kokkos::WithoutInitializing,
-                           "electron_beam_scan_path_segments_" +
-                               std::to_string(i)),
-        electron_beam_scan_path_segments[i].size());
-    Kokkos::deep_copy(_electron_beam_scan_path_segments.back(),
-                      Kokkos::View<ScanPathSegment *, Kokkos::HostSpace>(
-                          electron_beam_scan_path_segments[i].data(),
-                          electron_beam_scan_path_segments[i].size()));
     electron_beam_heat_sources.emplace_back(
         electron_beam_beams[i],
         ScanPath<MemorySpaceType>(_electron_beam_scan_path_segments.back()));

source/MaterialProperty.hh

@@ -22,7 +22,6 @@
 #include <deal.II/fe/fe_dgq.h>
 #include <deal.II/grid/filtered_iterator.h>
 #include <deal.II/lac/la_parallel_vector.h>
-#include <deal.II/lac/la_vector.h>
 
 #include <boost/property_tree/ptree.hpp>
 

source/ScanPath.cc

@@ -9,6 +9,7 @@
 #include <utils.hh>
 
 #include <deal.II/base/memory_space.h>
+
 #include <boost/algorithm/string.hpp>
 
 #include <fstream>
@@ -21,36 +22,31 @@ std::vector<ScanPathSegment>
 ScanPath<MemorySpaceType>::extract_scan_paths(std::string scan_path_file,
                                               std::string file_format)
 {
-  ASSERT_THROW((_file_format == "segment") || (_file_format == "event_series"),
+  ASSERT_THROW((file_format == "segment") || (file_format == "event_series"),
                "Error: Format of scan path file not recognized.");
 
-  wait_for_file(_scan_path_file,
-                "Waiting for scan path file: " + _scan_path_file);
-
-  read_file();
-}
+  wait_for_file(scan_path_file,
+                "Waiting for scan path file: " + scan_path_file);
 
-void ScanPath::read_file()
-{
-  if (_file_format == "segment")
+  if (file_format == "segment")
   {
-    load_segment_scan_path(scan_path_file);
+    return load_segment_scan_path(scan_path_file);
   }
   else
   {
-    load_event_series_scan_path();
+    return load_event_series_scan_path(scan_path_file);
   }
 
   return {};
 }
 
 template <typename MemorySpaceType>
 std::vector<ScanPathSegment>
-ScanPath<MemorySpaceType>::load_segment_scan_path()
+ScanPath<MemorySpaceType>::load_segment_scan_path(std::string scan_path_file)
 {
-  _segment_list.clear();
+  std::vector<ScanPathSegment> segment_list;
   std::ifstream file;
-  file.open(_scan_path_file);
+  file.open(scan_path_file);
   std::string line;
   unsigned int data_index = 0;
   // Skip first line
@@ -127,11 +123,12 @@ ScanPath<MemorySpaceType>::load_segment_scan_path()
 
 template <typename MemorySpaceType>
 std::vector<ScanPathSegment>
-ScanPath<MemorySpaceType>::load_event_series_scan_path()
+ScanPath<MemorySpaceType>::load_event_series_scan_path(
+    std::string scan_path_file)
 {
-  _segment_list.clear();
+  std::vector<ScanPathSegment> segment_list;
   std::ifstream file;
-  file.open(_scan_path_file);
+  file.open(scan_path_file);
   std::string line;
 
   double last_power = 0.0;

source/ScanPath.hh

@@ -1,5 +1,5 @@
 /* Copyright (c) 2016 - 2024, the adamantine authors.
-*
+ *
  * This file is subject to the Modified BSD License and may not be distributed
  * without copyright and license information. Please refer to the file LICENSE
  * for the text and further information on this license.
@@ -65,11 +65,11 @@ public:
    */
   ScanPath() = default;
 
-  ScanPath(
+  KOKKOS_FUNCTION ScanPath(
       Kokkos::View<ScanPathSegment *, typename MemorySpaceType::kokkos_space,
                    Kokkos::MemoryTraits<Kokkos::Unmanaged>>
           scan_path_segments)
-      : _segment_list(scan_path_segments)
+      : _segment_list(scan_path_segments.data(), scan_path_segments.size())
   {
   }
 
@@ -98,18 +98,6 @@ public:
   void read_file();
 
 private:
-  /**
-   * The list of information about each segment in the scan path.
-   */
-  Kokkos::View<ScanPathSegment *, typename MemorySpaceType::kokkos_space,
-               Kokkos::MemoryTraits<Kokkos::Unmanaged>>
-      _segment_list;
-
-  /**
-   * The index of the current segment in the scan path.
-   */
-  mutable unsigned int _current_segment = 0;
-
   /**
    * Method to load a "segment" scan path file
    */
@@ -129,18 +117,13 @@ private:
                                    dealii::Point<3> &segment_start_point,
                                    double &segment_start_time) const;
 
-  /**
-   * File name of the scan path
-   */
-  std::string _scan_path_file;
-  /**
-   * Format of the scan path file, either segment of event_series.
-   */
-  std::string _file_format;
   /**
    * The list of information about each segment in the scan path.
    */
-  std::vector<ScanPathSegment> _segment_list;
+  Kokkos::View<ScanPathSegment *, typename MemorySpaceType::kokkos_space,
+               Kokkos::MemoryTraits<Kokkos::Unmanaged>>
+      _segment_list;
+
   /**
    * The index of the current segment in the scan path.
    */