[newchem-cpp] transcribe: solve_rate_cool_g to C++

src/clib/CMakeLists.txt

@@ -109,7 +109,9 @@ add_library(Grackle_Grackle
   # C++ Source (and Private Header Files)
   cool_multi_time_g-cpp.C cool_multi_time_g-cpp.h
   internal_types.C internal_types.hpp
+  solve_rate_cool_g-cpp.C solve_rate_cool_g-cpp.h
   utils-cpp.C utils-cpp.hpp
+  fortran_func_wrappers.hpp
 
   # Fortran Source Files
   calc_all_tdust_gasgr_1d_g.F

src/clib/LUT.hpp

@@ -0,0 +1,168 @@
+// See LICENSE file for license and copyright information
+
+/// @file LUT.hpp
+/// @brief Declares some lookup-tables (LUTs) used internally by Grackle
+
+#ifndef LUT_HPP
+#define LUT_HPP
+
+#ifndef __cplusplus
+#error "This file can only be read by a c++ compiler"
+#endif
+
+// once we have transcribed more code, we should really put this header's
+// contents inside of the grackle::impl namespace
+// - if a lookup-table is called {name}, then its fully qualified name will be
+//   `grackle::impl::{name}`.
+// - when using the LUT in a function, we can shorten its name, within the
+//   function to just {name} by inserting `using grackle::impl::{name};` near
+//   the start of the function
+// - we should hold off on doing this until more code is transcribed (since it
+//   will be hard for the transcription tools to automatically handle the
+//   shortenning of the fully qualified name)
+
+
+
+/// This is collection of enumerators (localized to the `SpLUT::` scope), with
+/// an enumerator named for EVERY species (primordial-species, metal-species,
+/// grain-species, etc). The enumerator values are intended to be used in a
+/// compile-time lookup table (LUT), that incur no overhead at runtime.
+///
+/// To understand this entity's purpose, imagine that we want to temporarily
+/// track data for all N species known to Grackle (the data for each species is
+/// stored in a buffer of common size determined at runtime). Consider the
+/// following 3 ways we could accomplish this:
+///   1. define a separate variable holding a pointer for every single species
+///      - this is what the fortran routines historically did
+///      - this won't scale well with N (e.g. a function that requires all of
+///        this info needs to take N arguments)
+///   2. define a single struct with a separate data member holding a pointer
+///      for every single species.
+///      - still doesn't scale well if for applying a common operation to the
+///        data of each species (e.g. allocating/deallocating/zeroing-out)
+///   3. track each data-member in a statically sized array that holds pointers
+///      for each species
+///      - the array length is `SpLUT::NUM_ENTRIES` (known at compile time)
+///      - it is now trivial to apply a common operation to each pointer
+///      - we use the enumerator values in this LUT to lookup the value
+///        corresponding to a given species (for example, we could use
+///        `SpLUT::HI` to look up values related to HI)
+///
+/// > [!important]
+/// > This is a private implementation detail. We should never unintentionally
+/// > expose this information directly in the public API (i.e. we want to
+/// > maintain our flexibility). With that said, there are hypothetical
+/// > scenarios where we might deliberately expose it (for performance purposes)
+/// > -- but we should think long and hard about it before we do
+///
+/// Implementation
+/// --------------
+/// We implement choose to implement this entity by defining the enumerators
+/// within a "stateless struct" (i.e. has a size of 0) that won't be
+/// instantiated. The enclosing struct acts exactly like a pseudo-namespace
+///  - doing this lets us use short/simple names for each enumerator without
+///    fear of collision
+///  - there are 2 advantages of using a struct over a namespace:
+///    1. it forces us to localize the definition in 1 location (in comparison,
+///       C++ lets us add identifiers to a namespace in other files)
+///    2. it provides the flexibility to experiment with passing the LUT as a
+///       template parameter
+///       - a function that take accepts a specialized LUT (e.g. picked based
+///         on primordial_chemistry) could reduce branching within loops and
+///         and plausibly produce faster code.
+///       - **WE DON'T CURRENTLY HAVE PLANS TO PURSUE THIS.** There are
+///         much more immediately useful things to pursue first
+///
+/// Other Thoughts
+/// --------------
+/// - maybe we should store the dust species in a separate lookup table?
+/// - adopting data-structures that leverage this LUT, is probably an important
+///   stepping stone to implementing a system where reaction rates are
+///   dynamically specified. After adopting such a system, we may not even need
+///   a lookup table any more (this all assumes, of course, that such a system
+///   is adequately performant)
+struct SpLUT {
+
+  // in the future, we may want to reimplement the following in terms of the
+  // XMacros provided in grackle_field_data_fdatamembers.def (or we may need to
+  // slightly revise the system?)
+  enum {
+    e,
+    HI,
+    HII,
+    HeI,
+    HeII,
+    HeIII,
+
+    HM,
+    H2I,
+    H2II,
+
+    DI,
+    DII,
+    HDI,
+
+    DM,
+    HDII,
+    HeHII,
+
+    CI,
+    CII,
+    CO,
+    CO2,
+    OI,
+    OH,
+    H2O,
+    O2,
+    SiI,
+    SiOI,
+    SiO2I,
+    CH,
+    CH2,
+    COII,
+    OII,
+    OHII,
+    H2OII,
+    H3OII,
+    O2II,
+
+    Mg,
+    Al,
+    S,
+    Fe,
+
+    SiM,
+    FeM,
+    Mg2SiO4,
+    MgSiO3,
+    Fe3O4,
+    AC,
+    SiO2D,
+    MgO,
+    FeS,
+    Al2O3,
+    reforg,
+    volorg,
+    H2Oice,
+
+    NUM_ENTRIES // <- always last (so it specifies the number of species)
+  }; // enum
+
+}; // SpLUT struct
+
+
+/// Defines the LUT for Standard Collisional reaction rates
+struct CollisionalRxnLUT {
+
+  enum {
+    #define ENTRY(NAME) NAME,
+    #include "collisional_rxn_rate_members.def"
+    #undef ENTRY
+
+    NUM_ENTRIES // <- always last (so it specifies the number of species)
+  }; // enum
+
+}; // CollisionalRxnLUT struct
+
+
+#endif /* LUT_HPP */

src/clib/Make.config.objects

@@ -38,6 +38,7 @@ OBJS_CONFIG_LIB = \
         set_default_chemistry_parameters.lo \
         solve_chemistry.lo \
         solve_rate_cool_g.lo \
+        solve_rate_cool_g-cpp.lo \
         status_reporting.lo \
         update_UVbackground_rates.lo \
         lookup_cool_rates0d.lo \

src/clib/collisional_rxn_rate_members.def

@@ -0,0 +1,132 @@
+/***********************************************************************
+/
+/ this file lists each member of the collisional species reaction rates
+/ that we interpolate in 1d as a function of temperature. This list is
+/ intended to be used with X-Macros (to reduce the amount of code
+/ required to interact with these data-members)
+/
+/ Currently, we just specify each rate name. In the future, we will
+/ probably add other metadata to track the initializer function.
+/
+/ Copyright (c) 2013, Enzo/Grackle Development Team.
+/
+/ Distributed under the terms of the Enzo Public Licence.
+/
+/ The full license is in the file LICENSE, distributed with this
+/ software.
+************************************************************************/
+
+
+/**********************************
+ * primordial chemistry rate data *
+ **********************************/
+
+/* 6 species rates */
+ENTRY(k1)
+ENTRY(k2)
+ENTRY(k3)
+ENTRY(k4)
+ENTRY(k5)
+ENTRY(k6)
+
+/* 9 species rates (including H2) */
+ENTRY(k7)
+ENTRY(k8)
+ENTRY(k9)
+ENTRY(k10)
+ENTRY(k11)
+ENTRY(k12)
+ENTRY(k13)
+ENTRY(k14)
+ENTRY(k15)
+ENTRY(k16)
+ENTRY(k17)
+ENTRY(k18)
+ENTRY(k19)
+ENTRY(k20)  /* currently not used */
+ENTRY(k21)  /* currently not used */
+ENTRY(k22)  /* 3-body H2 formation */
+ENTRY(k23)  /* H2-H2 dissociation */
+
+// k13dd is currently omitted from this list. It holds the density dependent
+// version of k13 (collisional H2 dissociation)
+
+// radiative rates for 6-species (k24, k25, k26) are omitted
+// radiative rates for 9-species (k27, k28, k29, k30, k31) are omitted
+
+// 12 species rates (with Deuterium)
+ENTRY(k50)
+ENTRY(k51)
+ENTRY(k52)
+ENTRY(k53)
+ENTRY(k54)
+ENTRY(k55)
+ENTRY(k56)
+
+// New H-ionizing reactions, used for 6, 9 & 12 species chemistry
+ENTRY(k57)
+ENTRY(k58)
+
+// 15 species rates (with DM, HDII, HeHII)
+ENTRY(k125)
+ENTRY(k129)
+ENTRY(k130)
+ENTRY(k131)
+ENTRY(k132)
+ENTRY(k133)
+ENTRY(k134)
+ENTRY(k135)
+ENTRY(k136)
+ENTRY(k137)
+ENTRY(k148)
+ENTRY(k149)
+ENTRY(k150)
+ENTRY(k151)
+ENTRY(k152)
+ENTRY(k153)
+
+// Metal species chemistry rate data
+// ---------------------------------
+
+ENTRY(kz15)
+ENTRY(kz16)
+ENTRY(kz17)
+ENTRY(kz18)
+ENTRY(kz19)
+ENTRY(kz20)
+ENTRY(kz21)
+ENTRY(kz22)
+ENTRY(kz23)
+ENTRY(kz24)
+ENTRY(kz25)
+ENTRY(kz26)
+ENTRY(kz27)
+ENTRY(kz28)
+ENTRY(kz29)
+ENTRY(kz30)
+ENTRY(kz31)
+ENTRY(kz32)
+ENTRY(kz33)
+ENTRY(kz34)
+ENTRY(kz35)
+ENTRY(kz36)
+ENTRY(kz37)
+ENTRY(kz38)
+ENTRY(kz39)
+ENTRY(kz40)
+ENTRY(kz41)
+ENTRY(kz42)
+ENTRY(kz43)
+ENTRY(kz44)
+ENTRY(kz45)
+ENTRY(kz46)
+ENTRY(kz47)
+ENTRY(kz48)
+ENTRY(kz49)
+ENTRY(kz50)
+ENTRY(kz51)
+ENTRY(kz52)
+ENTRY(kz53)
+ENTRY(kz54)
+
+