rename Gimmick to JSONResource and fake_spec_file to spec_file_pypartmc (#347)

slayoo · web-flow · commit c3d322cd5357 · 2024-03-20T23:57:40.000+01:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -49,7 +49,7 @@ add_definitions("-DSUNDIALS_INT64_T=1")
 ### sources ########################################################################################
 
 set(PyPartMC_sources 
-  pypartmc.cpp gimmicks.cpp fake_spec_file.cpp sys.cpp
+  pypartmc.cpp json_resource.cpp spec_file_pypartmc.cpp sys.cpp
   run_part.F90 run_part_opt.F90 util.F90 aero_data.F90 aero_state.F90 env_state.F90 gas_data.F90 
   gas_state.F90 scenario.F90 condense.F90 aero_particle.F90 bin_grid.F90
   camp_core.F90 photolysis.F90 aero_mode.F90 aero_dist.F90 bin_grid.cpp condense.cpp run_part.cpp
@@ -179,7 +179,7 @@ set(partmclib_SOURCES condense_solver.c aero_state.F90 integer_varray.F90 intege
   photolysis.F90
 )
 add_prefix(gitmodules/partmc/src/ partmclib_SOURCES)
-list(APPEND partmclib_SOURCES src/fake_spec_file.F90 src/sys.F90)
+list(APPEND partmclib_SOURCES src/spec_file_pypartmc.F90 src/sys.F90)
 
 set(klu_SOURCES
   KLU/Source/klu_analyze.c
diff --git a/README.md b/README.md
@@ -232,7 +232,7 @@ PyPartMC is used within the [test workflow of the PySDM project](https://github.
 - PartMC and selected parts of SUNDIALS are statically linked (and compiled in during `pip install` or `python -m build`) 
 - C (SUNDIALS, netCDF), C++ (pybind11, ...) and Fortran (PartMC, CAMP, netCDF-fortran) dependencies are linked through [git submodules](https://github.com/open-atmos/PyPartMC/blob/main/.gitmodules)
 - MOSAIC dependency is optionally linked through setting the environmental variable `MOSAIC_HOME`
-- a [drop-in replacement of the PartMC spec file routines](https://github.com/open-atmos/PyPartMC/blob/main/src/fake_spec_file.F90) is used for i/o from/to JSON 
+- a [drop-in replacement of the PartMC spec file routines](https://github.com/open-atmos/PyPartMC/blob/main/src/spec_file_pypartmc.F90) is used for i/o from/to JSON 
 
 ## Implementation architecture
 
@@ -255,10 +255,10 @@ flowchart TD
         PyPartMC --> ppmc_cpp["PyPartMC-C++"]
         ppmc_cpp --> pybind11_json
         pybind11_json ---> nlohmann::JSON
-        fake_spec_file_cpp --> nlohmann::JSON
+        spec_file_pypartmc_cpp --> nlohmann::JSON
     end
     subgraph C ["C"]
-        fake_spec_file_c --> fake_spec_file_cpp["SpecFile-C++"]
+        spec_file_pypartmc_c --> spec_file_pypartmc_cpp["SpecFile-C++"]
         ppmc_cpp --> ppmc_c["PyPartMC-C"]
         netCDF-C
         SUNDIALS
@@ -273,8 +273,8 @@ flowchart TD
         PartMC --> SUNDIALS
         PartMC ---> camp_f
         camp_f["CAMP"] --> camp_c
-        PartMC ----> fake_spec_file_f[SpecFile-F]
-        fake_spec_file_f --> fake_spec_file_c["SpecFile-C"]
+        PartMC ----> spec_file_pypartmc_f[SpecFile-F]
+        spec_file_pypartmc_f --> spec_file_pypartmc_c["SpecFile-C"]
     end
 
     style PartMC fill:#7ae7ff,stroke-width:2px,color:#2B2B2B
diff --git a/src/aero_data.hpp b/src/aero_data.hpp
@@ -7,7 +7,7 @@
 #pragma once
 
 #include "pmc_resource.hpp"
-#include "gimmicks.hpp"
+#include "json_resource.hpp"
 #include "pybind11/stl.h"
 #include "aero_data_parameters.hpp"
 
@@ -41,10 +41,10 @@ struct AeroData {
     AeroData(const nlohmann::json &json) :
         ptr(f_aero_data_ctor, f_aero_data_dtor)
     {
-        if (!InputGimmick::unique_keys(json))
+        if (!InputJSONResource::unique_keys(json))
             throw std::runtime_error("Species names must be unique");
 
-        GimmickGuard<InputGimmick> guard(json);
+        JSONResourceGuard<InputJSONResource> guard(json);
         f_aero_data_from_json(this->ptr.f_arg());
     }
 
diff --git a/src/aero_dist.hpp b/src/aero_dist.hpp
@@ -49,12 +49,12 @@ struct AeroDist {
         ptr(f_aero_dist_ctor, f_aero_dist_dtor),
         aero_data(aero_data)
     {
-        if (!InputGimmick::unique_keys(json))
+        if (!InputJSONResource::unique_keys(json))
             throw std::runtime_error("Mode names must be unique");
         for (const auto &mode : json)
             AeroMode::check_mode_json(mode.begin().value());
         
-        GimmickGuard<InputGimmick> guard(json, "", "mode_name", 1);
+        JSONResourceGuard<InputJSONResource> guard(json, "", "mode_name", 1);
         f_aero_dist_from_json(ptr.f_arg_non_const(), aero_data->ptr.f_arg_non_const());
     }
 
diff --git a/src/aero_mode.hpp b/src/aero_mode.hpp
@@ -131,7 +131,7 @@ struct AeroMode {
         if (json.size() != 1 || !json.is_object() || !json.begin().value().is_object())
             throw std::runtime_error("Single-element dict expected with mode name as key and mode params dict as value");
         check_mode_json(json.begin().value());
-        GimmickGuard<InputGimmick> guard(json, "", "mode_name");
+        JSONResourceGuard<InputJSONResource> guard(json, "", "mode_name");
         f_aero_mode_from_json(ptr.f_arg_non_const(), aero_data.ptr.f_arg_non_const());
     }
 
@@ -143,7 +143,7 @@ struct AeroMode {
             
         if (!mass_frac.is_array()) // TODO #320: check if all are single-element dicts
             throw std::runtime_error("mass_frac value must be a list of single-element dicts");
-        if (!InputGimmick::unique_keys(mass_frac))
+        if (!InputJSONResource::unique_keys(mass_frac))
             throw std::runtime_error("mass_frac keys must be unique");
     }
 
diff --git a/src/camp_core.hpp b/src/camp_core.hpp
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "gimmicks.hpp"
+#include "json_resource.hpp"
 #include "pmc_resource.hpp"
 
 extern "C" void f_camp_core_ctor(void *ptr) noexcept;
diff --git a/src/env_state.hpp b/src/env_state.hpp
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "gimmicks.hpp"
+#include "json_resource.hpp"
 #include "pmc_resource.hpp"
 
 extern "C" void f_env_state_ctor(void *ptr) noexcept;
@@ -30,7 +30,7 @@ struct EnvState {
     EnvState(const nlohmann::json &json) :
         ptr(f_env_state_ctor, f_env_state_dtor)
     {
-        GimmickGuard<InputGimmick> guard(json);
+        JSONResourceGuard<InputJSONResource> guard(json);
         f_env_state_from_json(this->ptr.f_arg());
     }
 
diff --git a/src/gas_data.hpp b/src/gas_data.hpp
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "gimmicks.hpp" // TODO #119: rename to something like json_resource.hpp?
+#include "json_resource.hpp"
 #include "pmc_resource.hpp"
 #include "gas_data_parameters.hpp"
 #include "pybind11/stl.h"
@@ -37,7 +37,7 @@ struct GasData {
                 nlohmann::json::array()
             }}));
 
-        GimmickGuard<InputGimmick> guard(json_array);
+        JSONResourceGuard<InputJSONResource> guard(json_array);
         f_gas_data_from_json(this->ptr.f_arg());
     }
 
diff --git a/src/gas_state.hpp b/src/gas_state.hpp
@@ -8,7 +8,7 @@
 #include <string>
 #include "pybind11_json/pybind11_json.hpp"
 #include "nlohmann/json.hpp"
-#include "gimmicks.hpp"
+#include "json_resource.hpp"
 #include "pmc_resource.hpp"
 #include "gas_data.hpp"
 
@@ -59,10 +59,10 @@ struct GasState {
     }
 
     static auto __str__(const GasState &self) {
-        GimmickGuard<OutputGimmick> guard;
+        JSONResourceGuard<OutputJSONResource> guard;
 
         f_gas_state_to_json(self.ptr.f_arg());
-        auto str = gimmick_ptr()->str();
+        auto str = json_resource_ptr()->str();
 
         return str;
     }
@@ -120,7 +120,7 @@ struct GasState {
         if (json.size() == 0)
             throw std::runtime_error("Non-empty sequence of mixing ratios expected");
 
-        GimmickGuard<InputGimmick> guard(json);
+        JSONResourceGuard<InputJSONResource> guard(json);
         f_gas_state_from_json(
             self.ptr.f_arg(),
             self.gas_data->ptr.f_arg()
diff --git a/src/json_resource.cpp b/src/json_resource.cpp
@@ -4,7 +4,7 @@
 # Authors: https://github.com/open-atmos/PyPartMC/graphs/contributors                              #
 ##################################################################################################*/
 
-#include "gimmicks.hpp"
+#include "json_resource.hpp"
 
 template <class X>
 X& singleton()
@@ -13,7 +13,7 @@ X& singleton()
     return x;
 }
 
-std::unique_ptr<Gimmick> &gimmick_ptr() {
-    return singleton<std::unique_ptr<Gimmick>>();
+std::unique_ptr<JSONResource> &json_resource_ptr() {
+    return singleton<std::unique_ptr<JSONResource>>();
 }
 
diff --git a/src/json_resource.hpp b/src/json_resource.hpp
@@ -14,7 +14,7 @@
 #include <tcb/span.hpp>
 #include <bpstd/string_view.hpp>
 
-struct Gimmick {
+struct JSONResource {
   private:
     std::set<std::string> vars;
     const nlohmann::json *json;
@@ -28,9 +28,9 @@ struct Gimmick {
   protected:
     size_t index = 0;
 
-    Gimmick() {}
+    JSONResource() {}
 
-    Gimmick(const nlohmann::json &json) {
+    JSONResource(const nlohmann::json &json) {
         this->set_current_json_ptr(&json);
         for (auto &entry : this->json->items()) {
             this->vars.insert(entry.key());
@@ -67,9 +67,9 @@ struct Gimmick {
         }
         return key;
     }
- 
+
   public:
-    virtual ~Gimmick() {}
+    virtual ~JSONResource() {}
 
     void zoom_in(const bpstd::string_view &sub) noexcept {
         auto it = this->json->is_array() 
@@ -211,28 +211,28 @@ struct Gimmick {
     virtual std::string str() const = 0;
 
     virtual bool read_line(std::string &name, std::string &data) = 0;
-    
+
     virtual int read_line_data_size_and_start_enumerating() = 0;
 };
 
-struct InputGimmick: Gimmick {
+struct InputJSONResource: JSONResource {
   private:
     std::string key_cond, key_name;
     std::string last_read_line_key = "";
     std::size_t max_zoom_level;
 
   public:
-    InputGimmick(
+    InputJSONResource(
         const nlohmann::json &json,
         const std::string key_cond = "",
         const std::string key_name = "",
         const std::size_t max_zoom_level = 3
-    ) : Gimmick(json), key_cond(key_cond), key_name(key_name), max_zoom_level(max_zoom_level)
+    ) : JSONResource(json), key_cond(key_cond), key_name(key_name), max_zoom_level(max_zoom_level)
     {
     }
 
     std::string str() const {
-        throw std::logic_error("str() called on InputGimmick!");
+        throw std::logic_error("str() called on InputJSONResource!");
     }
 
     bool read_line(std::string &name, std::string &data) {
@@ -286,10 +286,10 @@ struct InputGimmick: Gimmick {
     }
 };
 
-struct OutputGimmick: Gimmick {
+struct OutputJSONResource: JSONResource {
     std::unique_ptr<nlohmann::json> guard;
 
-    OutputGimmick() : guard(std::make_unique<nlohmann::json>()) {
+    OutputJSONResource() : guard(std::make_unique<nlohmann::json>()) {
         this->set_current_json_ptr(this->guard.get());
     }
 
@@ -298,45 +298,45 @@ struct OutputGimmick: Gimmick {
     }
 
     bool read_line(std::string &, std::string &) {
-        throw std::logic_error("read_line() called on OutputGimmick!");
+        throw std::logic_error("read_line() called on OutputJSONResource!");
     }
 
     int read_line_data_size_and_start_enumerating() {
-        throw std::logic_error("read_line_data_size_and_start_enumerating() called on OutputGimmick!");
+        throw std::logic_error("read_line_data_size_and_start_enumerating() called on OutputJSONResource!");
     }
 };
 
-std::unique_ptr<Gimmick> &gimmick_ptr();
+std::unique_ptr<JSONResource> &json_resource_ptr();
 
 template <typename T>
-struct GimmickGuard {
-    GimmickGuard() {
-        gimmick_ptr() = std::make_unique<T>();
-    }   
+struct JSONResourceGuard {
+    JSONResourceGuard() {
+        json_resource_ptr() = std::make_unique<T>();
+    }
 
-    GimmickGuard(const nlohmann::json & json) {
-        gimmick_ptr() = std::make_unique<T>(json);
+    JSONResourceGuard(const nlohmann::json & json) {
+        json_resource_ptr() = std::make_unique<T>(json);
     }
 
-    GimmickGuard(
+    JSONResourceGuard(
         const nlohmann::json & json,
         const std::string key_cond,
         const std::string key_name
     ) {
-        gimmick_ptr() = std::make_unique<T>(json, key_cond, key_name);
+        json_resource_ptr() = std::make_unique<T>(json, key_cond, key_name);
     }
 
-    GimmickGuard(
+    JSONResourceGuard(
         const nlohmann::json & json,
         const std::string key_cond,
         const std::string key_name,
         const int max_zoom_level
     ) {
-        gimmick_ptr() = std::make_unique<T>(json, key_cond, key_name, max_zoom_level);
+        json_resource_ptr() = std::make_unique<T>(json, key_cond, key_name, max_zoom_level);
     }
 
-    ~GimmickGuard() {
-        gimmick_ptr().reset();
-    }   
+    ~JSONResourceGuard() {
+        json_resource_ptr().reset();
+    }
 };
 
diff --git a/src/photolysis.hpp b/src/photolysis.hpp
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "gimmicks.hpp"
+#include "json_resource.hpp"
 #include "pmc_resource.hpp"
 
 extern "C" void f_photolysis_ctor(void *ptr) noexcept;
diff --git a/src/run_part_opt.hpp b/src/run_part_opt.hpp
@@ -7,7 +7,7 @@
 #pragma once
 
 #include "pmc_resource.hpp"
-#include "gimmicks.hpp"
+#include "json_resource.hpp"
 #include "pybind11_json/pybind11_json.hpp"
 
 extern "C" void f_run_part_opt_ctor(void *ptr) noexcept;
@@ -46,7 +46,7 @@ struct RunPartOpt {
             if (json_copy.find(key) == json_copy.end())
                 json_copy[key] = 0;
 
-        GimmickGuard<InputGimmick> guard(json_copy);
+        JSONResourceGuard<InputJSONResource> guard(json_copy);
         f_run_part_opt_from_json(this->ptr.f_arg());
     }
 
diff --git a/src/scenario.hpp b/src/scenario.hpp
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include "gimmicks.hpp"
+#include "json_resource.hpp"
 #include "pmc_resource.hpp"
 #include "aero_data.hpp"
 #include "aero_dist.hpp"
@@ -123,7 +123,7 @@ struct Scenario {
             }
         }
 
-        GimmickGuard<InputGimmick> guard(json, "dist", "mode_name");
+        JSONResourceGuard<InputJSONResource> guard(json, "dist", "mode_name");
         f_scenario_from_json(
             gas_data.ptr.f_arg(),
             aero_data.ptr.f_arg(),
diff --git a/src/spec_file_pypartmc.F90 b/src/spec_file_pypartmc.F90
diff --git a/src/spec_file_pypartmc.cpp b/src/spec_file_pypartmc.cpp

Original file line number	Diff line number	Diff line change
`@@ -49,12 +49,12 @@ struct AeroDist {`
`49`	`49`	`ptr(f_aero_dist_ctor, f_aero_dist_dtor),`
`50`	`50`	`aero_data(aero_data)`
`51`	`51`	`{`
`52`		`- if (!InputGimmick::unique_keys(json))`
	`52`	`+ if (!InputJSONResource::unique_keys(json))`
`53`	`53`	`throw std::runtime_error("Mode names must be unique");`
`54`	`54`	`for (const auto &mode : json)`
`55`	`55`	`AeroMode::check_mode_json(mode.begin().value());`
`56`	`56`
`57`		`- GimmickGuard<InputGimmick> guard(json, "", "mode_name", 1);`
	`57`	`+ JSONResourceGuard<InputJSONResource> guard(json, "", "mode_name", 1);`
`58`	`58`	`f_aero_dist_from_json(ptr.f_arg_non_const(), aero_data->ptr.f_arg_non_const());`
`59`	`59`	`}`
`60`	`60`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ struct AeroMode {`
`131`	`131`	`if (json.size() != 1 \|\| !json.is_object() \|\| !json.begin().value().is_object())`
`132`	`132`	`throw std::runtime_error("Single-element dict expected with mode name as key and mode params dict as value");`
`133`	`133`	`check_mode_json(json.begin().value());`
`134`		`- GimmickGuard<InputGimmick> guard(json, "", "mode_name");`
	`134`	`+ JSONResourceGuard<InputJSONResource> guard(json, "", "mode_name");`
`135`	`135`	`f_aero_mode_from_json(ptr.f_arg_non_const(), aero_data.ptr.f_arg_non_const());`
`136`	`136`	`}`
`137`	`137`
`@@ -143,7 +143,7 @@ struct AeroMode {`
`143`	`143`
`144`	`144`	`if (!mass_frac.is_array()) // TODO #320: check if all are single-element dicts`
`145`	`145`	`throw std::runtime_error("mass_frac value must be a list of single-element dicts");`
`146`		`- if (!InputGimmick::unique_keys(mass_frac))`
	`146`	`+ if (!InputJSONResource::unique_keys(mass_frac))`
`147`	`147`	`throw std::runtime_error("mass_frac keys must be unique");`
`148`	`148`	`}`
`149`	`149`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`#pragma once`
`8`	`8`
`9`		`-#include "gimmicks.hpp"`
	`9`	`+#include "json_resource.hpp"`
`10`	`10`	`#include "pmc_resource.hpp"`
`11`	`11`
`12`	`12`	`extern "C" void f_env_state_ctor(void *ptr) noexcept;`
`@@ -30,7 +30,7 @@ struct EnvState {`
`30`	`30`	`EnvState(const nlohmann::json &json) :`
`31`	`31`	`ptr(f_env_state_ctor, f_env_state_dtor)`
`32`	`32`	`{`
`33`		`- GimmickGuard<InputGimmick> guard(json);`
	`33`	`+ JSONResourceGuard<InputJSONResource> guard(json);`
`34`	`34`	`f_env_state_from_json(this->ptr.f_arg());`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`# Authors: https://github.com/open-atmos/PyPartMC/graphs/contributors #`
`5`	`5`	`##################################################################################################*/`
`6`	`6`
`7`		`-#include "gimmicks.hpp"`
	`7`	`+#include "json_resource.hpp"`
`8`	`8`
`9`	`9`	`template <class X>`
`10`	`10`	`X& singleton()`
`@@ -13,7 +13,7 @@ X& singleton()`
`13`	`13`	`return x;`
`14`	`14`	`}`
`15`	`15`
`16`		`-std::unique_ptr<Gimmick> &gimmick_ptr() {`
`17`		`- return singleton<std::unique_ptr<Gimmick>>();`
	`16`	`+std::unique_ptr<JSONResource> &json_resource_ptr() {`
	`17`	`+ return singleton<std::unique_ptr<JSONResource>>();`
`18`	`18`	`}`
`19`	`19`