Interface for ELM->ATS coupling - WIP

src/executables/CMakeLists.txt

@@ -40,7 +40,7 @@ include_directories(${ATS_SOURCE_DIR}/src/pks)
 include_directories(${ATS_SOURCE_DIR}/src/pks/mpc)
 include_directories(${ATS_SOURCE_DIR}/src/pks/energy)
 include_directories(${ATS_SOURCE_DIR}/src/pks/flow)
-include_directories(${ATS_SOURCE_DIR}/src/pks/deformation)
+include_directories(${ATS_SOURCE_DIR}/src/pks/deform)
 include_directories(${ATS_SOURCE_DIR}/src/pks/transport)
 include_directories(${ATS_SOURCE_DIR}/src/operators/upwinding)
 include_directories(${ATS_SOURCE_DIR}/src/operators/advection)
@@ -182,3 +182,12 @@ add_amanzi_executable(ats
   LINK_LIBS ats_executable ${fates_link_libs} ${tpl_link_libs} ${ats_link_libs} ${amanzi_link_libs} 
   OUTPUT_NAME ats
   OUTPUT_DIRECTORY ${ATS_BINARY_DIR})
+
+
+# set this here for now
+# add option to bootstrap before completion
+set (BUILD_ELM_ATS_API true)
+if (BUILD_ELM_ATS_API)
+  message("building elm_ats api")
+  add_subdirectory(elm_ats_api)
+endif()

src/executables/elm_ats_api/CMakeLists.txt

@@ -0,0 +1,47 @@
+# -*- mode: cmake -*-
+#
+#  ELM_ATS_API
+#    library
+#
+# builds both dynamic and static libs for now
+# need to add build logic to make configurable
+
+# verify the compatibility of the C/Fortran and C++/Fortran compilers
+# Amanzi probably does this somewhere upstream, should check
+include(FortranCInterface)
+FortranCInterface_VERIFY(CXX)
+
+include_directories(${ATS_SOURCE_DIR}/src/executables)
+
+set(elm_ats_src_files
+  ${ATS_SOURCE_DIR}/src/executables/coordinator.cc
+  ${ATS_SOURCE_DIR}/src/executables/ats_mesh_factory.cc
+  elm_ats_driver.cc
+  elm_ats_api.cc
+  )
+
+set(elm_ats_inc_files
+  ${ATS_SOURCE_DIR}/src/executables/coordinator.hh
+  ${ATS_SOURCE_DIR}/src/executables/ats_mesh_factory.hh
+  elm_ats_driver.hh
+  elm_ats_api.h
+  )
+
+## build shared lib
+add_amanzi_library(elm_ats
+  SOURCE ${elm_ats_src_files}
+  HEADERS ${elm_ats_inc_files}
+  LINK_LIBS ${fates_link_libs} ${tpl_link_libs} ${ats_link_libs} ${amanzi_link_libs})
+if (APPLE AND BUILD_SHARED_LIBS)
+  set_target_properties(elm_ats PROPERTIES LINK_FLAGS "-Wl,-undefined,dynamic_lookup")
+endif()
+
+# ## build static lib
+# add_amanzi_library(elm_ats_static
+#   STATIC
+#   SOURCE ${elm_ats_src_files}
+#   HEADERS ${elm_ats_inc_files}
+#   LINK_LIBS ${fates_link_libs} ${tpl_link_libs} ${ats_link_libs} ${amanzi_link_libs})
+
+# re-enable later
+add_subdirectory(test)

src/executables/elm_ats_api/Indexer.hh

@@ -0,0 +1,108 @@
+/*
+  ATS is released under the three-clause BSD License.
+  The terms of use and "as is" disclaimer for this license are
+  provided in the top-level COPYRIGHT file.
+
+  Authors: Ethan Coon
+*/
+//! Tools for indexing arbitrary arrays in a variety of ways.
+
+#pragma once
+
+
+namespace ATS {
+namespace Utils {
+
+enum class Indexer_kind {
+  SCALAR = 0,
+  ELM,
+  ATS
+};
+
+enum class Domain_kind {
+  SURF,
+  SUBSURF
+};
+
+
+template<Indexer_kind ikind, Domain_kind dkind, typename T> struct Indexer;
+
+//
+// Indexer for scalars.
+//
+template<Domain_kind dkind, typename T>
+struct Indexer<Indexer_kind::SCALAR, dkind, T> {
+  template<typename D = T>
+  typename std::enable_if<dkind == Domain_kind::SUBSURF, D&>::type
+  get(T const * const& val, const int col, const int cic) const { return *val_; }
+
+  template<typename D = T>
+  typename std::enable_if<dkind == Domain_kind::SURF, D&>::type
+  get(T const * const& val, const int i) const { return *val_; }
+
+private:
+  T* val_;
+};
+
+
+//
+// Indexer for ELM
+//
+template<Domain_kind dkind, typename T>
+struct Indexer<Indexer_kind::ELM, dkind, T> {
+
+  Indexer(int ncells_per_col=-1)
+    : ncells_per_col_(ncells_per_col) {}
+
+  // for use by subsurface
+  template<typename D = T>
+  typename std::enable_if<dkind == Domain_kind::SUBSURF, D&>::type
+  get(T * const& val, const int col, const int cic) const {
+    return val[col * ncells_per_col_ + cic];
+  }
+
+  // for use by surface
+  template<typename D = T>
+  typename std::enable_if<dkind == Domain_kind::SURF, D&>::type
+  get(T * const& val, const int i) const {
+    return val[i];
+  }
+
+ private:
+  int ncells_per_col_;
+};
+
+
+//
+// Indexer for ATS
+//
+template<Domain_kind dkind, typename T>
+struct Indexer<Indexer_kind::ATS, dkind, T> {
+
+  Indexer(const Amanzi::AmanziMesh::Mesh& mesh)
+    : mesh_(mesh) {}
+
+  // for use by subsurface
+  template<typename D = T>
+  typename std::enable_if<dkind == Domain_kind::SUBSURF, T&>::type
+  get(T * const& val, const int col, const int cic) const {
+    return val[mesh_.cells_of_column(col)[cic]];
+  }
+
+  // for use by surface
+  template<typename D = T>
+  typename std::enable_if<dkind == Domain_kind::SURF, D&>::type
+  get(T * const& val, const int i) const {
+    return val[i];
+  }
+
+ private:
+  const Amanzi::AmanziMesh::Mesh& mesh_;
+};
+
+
+
+
+
+} // namespace Utils
+} // namespace ATS

src/executables/elm_ats_api/elm_ats_api.cc

@@ -0,0 +1,146 @@
+/*
+  ATS is released under the three-clause BSD License.
+  The terms of use and "as is" disclaimer for this license are
+  provided in the top-level COPYRIGHT file.
+
+  Authors: Joe Beisman
+           Fenming Yuan
+           Ethan Coon
+*/
+//! Wrapper for driving ATS from ELM.
+
+#include "elm_ats_driver.hh"
+#include "elm_ats_api.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+// allocate, call constructor and cast ptr to opaque ELM_ATSDriver_ptr
+ELM_ATSDriver_ptr ats_create(MPI_Fint *f_comm, const char *input_filename)
+{
+  return reinterpret_cast<ELM_ATSDriver_ptr>(ATS::createELM_ATSDriver(f_comm, input_filename));
+}
+
+// reinterpret as elm_ats_driver and delete (calls destructor)
+void ats_delete(ELM_ATSDriver_ptr ats)
+{
+  auto ats_ptr = reinterpret_cast<ATS::ELM_ATSDriver*>(ats);
+  ats_ptr->finalize();
+  delete ats_ptr;
+}
+
+// call driver advance()
+void ats_advance(ELM_ATSDriver_ptr ats,
+                   double const * const dt,
+                   bool const * const checkpoint,
+                   bool const * const visualize)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)->advance(*dt, *checkpoint, *visualize);
+}
+
+// call driver advance_test()
+void ats_advance_test(ELM_ATSDriver_ptr ats)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)->advance_test();
+}
+
+void ats_get_mesh_info(ELM_ATSDriver_ptr ats,
+                         int * const ncols_local,
+                         int * const ncols_global,
+                         double * const lat,
+                         double * const lon,
+                         double * const elev,
+                         double * const surf_area,
+                         int * const pft,
+                         int * const nlevgrnd,
+                         double * const depth)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)->get_mesh_info(*ncols_local, *ncols_global,
+          lat, lon, elev, surf_area, pft, *nlevgrnd, depth);
+}
+
+
+// call driver setup()
+void ats_setup(ELM_ATSDriver_ptr ats)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)->setup();
+}
+
+// call driver initialize()
+void ats_initialize(ELM_ATSDriver_ptr ats,
+                      double const * const start_time,
+                      double const * const soil_water_content,
+                      double const * const soil_pressure)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)->initialize(*start_time, soil_water_content, soil_pressure);
+}
+
+
+void ats_set_soil_hydrologic_parameters(ELM_ATSDriver_ptr ats,
+        double const * const base_porosity,
+        double const * const hydraulic_conductivity,
+        double const * const clapp_horn_b,
+        double const * const clapp_horn_smpsat,
+        double const * const clapp_horn_sr)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)
+    ->set_soil_hydrologic_parameters(base_porosity, hydraulic_conductivity,
+            clapp_horn_b, clapp_horn_smpsat, clapp_horn_sr);
+}
+
+
+void ats_set_soil_hydrologic_properties(ELM_ATSDriver_ptr ats,
+        double const * const effective_porosity)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)
+    ->set_soil_hydrologic_properties(effective_porosity);
+}
+
+
+// set veg properties, non-constant in time
+void ats_set_veg_properties(ELM_ATSDriver_ptr ats,
+        double const * const rooting_fraction)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)
+    ->set_veg_properties(rooting_fraction);
+}
+
+
+// call driver set_sources()
+void ats_set_sources(ELM_ATSDriver_ptr ats,
+        double const * const surface_source,
+        double const * const potential_evaporation,
+        double const * const potential_transpiration)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)
+    ->set_potential_sources(surface_source, potential_evaporation, potential_transpiration);
+}
+
+
+void ats_get_waterstate(ELM_ATSDriver_ptr ats,
+                          double * const ponded_depth,
+                          double * const water_table_depth,
+                          double * const mass_water_content)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)
+    ->get_waterstate(ponded_depth, water_table_depth, mass_water_content);
+}
+
+
+void ats_get_water_fluxes(ELM_ATSDriver_ptr ats,
+                            double * const infiltration,
+                            double * const evaporation,
+                            double * const transpiration,
+                            double * const root_flux,
+                            double * net_subsurface_fluxes,
+                            double * net_runon)
+{
+  reinterpret_cast<ATS::ELM_ATSDriver*>(ats)
+    ->get_water_fluxes(infiltration, evaporation, transpiration,
+                       root_flux, net_subsurface_fluxes, net_runon);
+}
+
+#ifdef __cplusplus
+}
+#endif