diff --git a/src/clib/CMakeLists.txt b/src/clib/CMakeLists.txt index 6e3b757c8..1d5f0c1d7 100644 --- a/src/clib/CMakeLists.txt +++ b/src/clib/CMakeLists.txt @@ -109,6 +109,7 @@ add_library(Grackle_Grackle calc_temp_cloudy_g.cpp calc_temp_cloudy_g.h ceiling_species.hpp collisional_rate_props.cpp collisional_rate_props.hpp + cool1d_cloudy_g.cpp cool1d_cloudy_g.hpp cool1d_multi_g.cpp cool1d_multi_g.hpp cool_multi_time_g.cpp cool_multi_time_g.h dust_props.hpp @@ -137,7 +138,6 @@ add_library(Grackle_Grackle calc_all_tdust_gasgr_1d_g.F calc_tdust_1d_g.F calc_temp1d_cloudy_g.F - cool1d_cloudy_g.F cool1d_cloudy_old_tables_g.F interpolators_g.F solve_rate_cool_g.F diff --git a/src/clib/cool1d_cloudy_g.F b/src/clib/cool1d_cloudy_g.F deleted file mode 100644 index 35f1623a9..000000000 --- a/src/clib/cool1d_cloudy_g.F +++ /dev/null @@ -1,261 +0,0 @@ -!======================================================================= -!//////////////////// SUBROUTINE COOL1D_CLOUDY_G \\\\\\\\\\\\\\\\\\\\\ - - subroutine cool1d_cloudy_g(d, rhoH, metallicity, - & in, jn, kn, is, ie, j, k, - & logtem, edot, comp2, dom, zr, - & icmbTfloor, iClHeat, iZscale, - & clGridRank, clGridDim, - & clPar1, clPar2, clPar3, - & clDataSize, clCooling, clHeating, - & itmask) - -! -! SOLVE CLOUDY METAL COOLING -! -! written by: Britton Smith -! date: September, 2009 -! -! PURPOSE: -! Solve cloudy cooling by interpolating from the data. -! -! INPUTS: -! in,jn,kn - dimensions of 3D fields -! -! d - total density field -! -! rhoH - total H mass density -! metallicity - metallicity -! -! is,ie - start and end indices of active region (zero based) -! logtem - natural log of temperature values -! -! dom - unit conversion to proper number density in code units -! zr - current redshift -! -! icmbTfloor - flag to include temperature floor from cmb -! iClHeat - flag to include cloudy heating -! iZscale - flag to scale cooling by metallicity -! clGridRank - rank of cloudy cooling data grid -! clGridDim - array containing dimensions of cloudy data -! clPar1, clPar2, clPar3 - arrays containing cloudy grid parameter values -! clDataSize - total size of flattened 1D cooling data array -! clCooling - cloudy cooling data -! clHeating - cloudy heating data -! -! itmask - iteration mask -! -! OUTPUTS: -! update edot with heating/cooling contributions from metals -! -! PARAMETERS: -! -!----------------------------------------------------------------------- - - implicit NONE -#include "grackle_fortran_types.def" - -! General Arguments - - integer in, jn, kn, is, ie, j, k - - real*8 comp2, dom, zr - R_PREC d(in,jn,kn) - real*8 rhoH(in), metallicity(in), logtem(in), - & edot(in) - -! Cloudy parameters and data - - integer icmbTfloor, iClHeat, iZscale - integer*8 clGridRank, clDataSize, - & clGridDim(clGridRank) - real*8 clPar1(clGridDim(1)), clPar2(clGridDim(2)), - & clPar3(clGridDim(3)), - & clCooling(clDataSize), clHeating(clDataSize) - -! Iteration mask - - MASK_TYPE itmask(in) - -! Parameters - -! Locals - - integer i, get_heat - integer*8 zindex, zmidpt, zhighpt - real*8 dclPar(clGridRank), inv_log10, log10_tCMB - integer*8 end_int - -! Slice locals - - real*8 log_n_h(in), - & log_cool(in), log_cool_cmb(in), log_heat(in), - & edot_met(in), log10tem(in) - -!\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\///////////////////////////////// -!======================================================================= - - end_int = 0 - get_heat = iClHeat - - inv_log10 = 1._DKIND / log(10._DKIND) - log10_tCMB = log10(comp2) - -! Calculate parameter value slopes - - dclPar(1) = (clPar1(clGridDim(1)) - clPar1(1)) / - & real(clGridDim(1) - 1, DKIND) - if (clGridRank .gt. 1) then - dclPar(2) = (clPar2(clGridDim(2)) - clPar2(1)) / - & real(clGridDim(2) - 1, DKIND) - endif - if (clGridRank .gt. 2) then - dclPar(3) = (clPar3(clGridDim(3)) - clPar3(1)) / - & real(clGridDim(3) - 1, DKIND) - endif - - do i=is+1, ie+1 - if (itmask(i) .ne. MASK_FALSE) then - - log10tem(i) = logtem(i) * inv_log10 - -! Calculate proper log(n_H) - - log_n_h(i) = log10(rhoH(i) * dom) - -! Calculate index for redshift dimension - - if (clGridRank .gt. 2) then - -! Get index for redshift dimension via bisection - - if (zr .le. clPar2(1)) then - zindex = 1 - else if (zr .ge. clPar2(clGridDim(2)-1)) then - zindex = clGridDim(2) - end_int = 1 - get_heat = 0 - else if (zr .ge. clPar2(clGridDim(2)-2)) then - zindex = clGridDim(2) - 2 - else - zindex = 1 - zhighpt = clGridDim(2) - 2 - do while ((zhighpt - zindex) .gt. 1) - zmidpt = int((zhighpt + zindex) / 2) - if (zr .ge. clPar2(zmidpt)) then - zindex = zmidpt - else - zhighpt = zmidpt - endif - enddo - endif - - endif - -! Call interpolation functions to get heating/cooling - -! Interpolate over temperature. - if (clGridRank .eq. 1) then - call interpolate_1D_g(log10tem(i), clGridDim, clPar1, - & dclPar(1), clDataSize, clCooling, log_cool(i)) - edot_met(i) = -10._DKIND**log_cool(i) - -! Ignore CMB term if T >> T_CMB - if ((icmbTfloor .eq. 1) .and. - & ((log10tem(i) - log10_tCMB) .lt. 2._DKIND)) then - call interpolate_1D_g(log10_tCMB, clGridDim, clPar1, - & dclPar(1), clDataSize, clCooling, - & log_cool_cmb(i)) - edot_met(i) = edot_met(i) + 10._DKIND**log_cool_cmb(i) - endif - - if (get_heat .eq. 1) then - call interpolate_1D_g(log10tem(i), clGridDim, clPar1, - & dclPar(1), clDataSize, clHeating, - & log_heat(i)) - edot_met(i) = edot_met(i) + 10._DKIND**log_heat(i) - endif - -! Interpolate over density and temperature. - else if (clGridRank .eq. 2) then - call interpolate_2D_g(log_n_h(i), log10tem(i), clGridDim, - & clPar1, dclPar(1), clPar2, dclPar(2), - & clDataSize, clCooling, log_cool(i)) - edot_met(i) = -10._DKIND**log_cool(i) - -! Ignore CMB term if T >> T_CMB - if ((icmbTfloor .eq. 1) .and. - & ((log10tem(i) - log10_tCMB) .lt. 2._DKIND)) then - call interpolate_2D_g(log_n_h(i), log10_tCMB, - & clGridDim, clPar1, dclPar(1), clPar2, dclPar(2), - & clDataSize, clCooling, log_cool_cmb(i)) - edot_met(i) = edot_met(i) + 10._DKIND**log_cool_cmb(i) - endif - - if (get_heat .eq. 1) then - call interpolate_2D_g(log_n_h(i), log10tem(i), clGridDim, - & clPar1, dclPar(1), clPar2, dclPar(2), - & clDataSize, clHeating, log_heat(i)) - edot_met(i) = edot_met(i) + 10._DKIND**log_heat(i) - endif - -! Interpolate over density, redshift, and temperature. - else if (clGridRank .eq. 3) then - call interpolate_3Dz_g(log_n_h(i), zr, log10tem(i), - & clGridDim, - & clPar1, dclPar(1), - & clPar2, zindex, - & clPar3, dclPar(3), - & clDataSize, clCooling, - & end_int, log_cool(i)) - edot_met(i) = -10._DKIND**log_cool(i) - -! Ignore CMB term if T >> T_CMB - if ((icmbTfloor .eq. 1) .and. - & ((log10tem(i) - log10_tCMB) .lt. 2._DKIND)) then - call interpolate_3Dz_g(log_n_h(i), zr, log10_tCMB, - & clGridDim, - & clPar1, dclPar(1), - & clPar2, zindex, - & clPar3, dclPar(3), - & clDataSize, clCooling, - & end_int, log_cool_cmb(i)) - edot_met(i) = edot_met(i) + 10._DKIND**log_cool_cmb(i) - endif - - if (get_heat .eq. 1) then - call interpolate_3Dz_g(log_n_h(i), zr, log10tem(i), - & clGridDim, - & clPar1, dclPar(1), - & clPar2, zindex, - & clPar3, dclPar(3), - & clDataSize, clHeating, - & end_int, log_heat(i)) - edot_met(i) = edot_met(i) + 10._DKIND**log_heat(i) - endif - - else -#ifdef _OPENMP -!$omp critical -#endif - write(*,*) "Maximum cooling data grid rank is 3!" -#ifdef _OPENMP -!$omp end critical -#endif - return - endif - -! Scale cooling by metallicity. - - if (iZscale .eq. 1) then - edot_met(i) = edot_met(i) * metallicity(i) - endif - - edot(i) = edot(i) + - & (edot_met(i) * rhoH(i) * rhoH(i)) - - end if - enddo - - return - end diff --git a/src/clib/cool1d_cloudy_g.cpp b/src/clib/cool1d_cloudy_g.cpp new file mode 100644 index 000000000..1d5b8375b --- /dev/null +++ b/src/clib/cool1d_cloudy_g.cpp @@ -0,0 +1,221 @@ +//===----------------------------------------------------------------------===// +// +// See the LICENSE file for license and copyright information +// SPDX-License-Identifier: NCSA AND BSD-3-Clause +// +//===----------------------------------------------------------------------===// +/// +/// @file +/// Implements the cool1d_cloudy_g function +/// +//===----------------------------------------------------------------------===// + +// This file was initially generated automatically during conversion of the +// cool1d_cloudy_g function from FORTRAN to C++ + +#include +#include +#include + +#include "grackle.h" +#include "fortran_func_wrappers.hpp" +#include "utils-cpp.hpp" + +#include "cool1d_cloudy_g.hpp" + +void grackle::impl::cool1d_cloudy_g( + const double* rhoH, const double* metallicity, const double* logtem, + double* edot, double comp2, double dom, double zr, int icmbTfloor, + int iClHeat, int iZscale, const gr_mask_type* itmask, + cloudy_data cloudy_table, IndexRange idx_range) { + // Locals + + int i, get_heat; + long long zindex, zmidpt, zhighpt; + double inv_log10, log10_tCMB; + std::vector dclPar(cloudy_table.grid_rank); + long long end_int; + + // Slice locals + + std::vector log_n_h(idx_range.i_stop); + std::vector log_cool(idx_range.i_stop); + std::vector log_cool_cmb(idx_range.i_stop); + std::vector log_heat(idx_range.i_stop); + std::vector edot_met(idx_range.i_stop); + std::vector log10tem(idx_range.i_stop); + + // \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\///////////////////////////////// + // ======================================================================= + + end_int = 0; + get_heat = iClHeat; + + inv_log10 = 1. / std::log(10.); + log10_tCMB = std::log10(comp2); + + // Calculate parameter value slopes + + dclPar[0] = + (cloudy_table.grid_parameters[0][cloudy_table.grid_dimension[0] - 1] - + cloudy_table.grid_parameters[0][0]) / + (double)(cloudy_table.grid_dimension[0] - 1); + if (cloudy_table.grid_rank > 1) { + dclPar[1] = + (cloudy_table.grid_parameters[1][cloudy_table.grid_dimension[1] - 1] - + cloudy_table.grid_parameters[1][0]) / + (double)(cloudy_table.grid_dimension[1] - 1); + } + if (cloudy_table.grid_rank > 2) { + dclPar[2] = + (cloudy_table.grid_parameters[2][cloudy_table.grid_dimension[2] - 1] - + cloudy_table.grid_parameters[2][0]) / + (double)(cloudy_table.grid_dimension[2] - 1); + } + + for (i = idx_range.i_start; i <= idx_range.i_end; i++) { + if (itmask[i] != MASK_FALSE) { + log10tem[i] = logtem[i] * inv_log10; + + // Calculate proper log(n_H) + + log_n_h[i] = std::log10(rhoH[i] * dom); + + // Calculate index for redshift dimension + + if (cloudy_table.grid_rank > 2) { + // Get index for redshift dimension via bisection + + if (zr <= cloudy_table.grid_parameters[1][0]) { + zindex = 1; + } else if (zr >= + cloudy_table + .grid_parameters[1][cloudy_table.grid_dimension[1] - 1 - + 1]) { + zindex = cloudy_table.grid_dimension[1]; + end_int = 1; + get_heat = 0; + } else if (zr >= + cloudy_table + .grid_parameters[1][cloudy_table.grid_dimension[1] - 2 - + 1]) { + zindex = cloudy_table.grid_dimension[1] - 2; + } else { + zindex = 1; + zhighpt = cloudy_table.grid_dimension[1] - 2; + while ((zhighpt - zindex) > 1) { + zmidpt = int((zhighpt + zindex) / 2); + if (zr >= cloudy_table.grid_parameters[1][zmidpt - 1]) { + zindex = zmidpt; + } else { + zhighpt = zmidpt; + } + } + } + } + + // Call interpolation functions to get heating/cooling + + // Interpolate over temperature. + if (cloudy_table.grid_rank == 1) { + log_cool[i] = grackle::impl::fortran_wrapper::interpolate_1d_g( + log10tem[i], cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], cloudy_table.data_size, + cloudy_table.cooling_data); + edot_met[i] = -std::pow(10., log_cool[i]); + + // Ignore CMB term if T >> T_CMB + if ((icmbTfloor == 1) && ((log10tem[i] - log10_tCMB) < 2.)) { + log_cool_cmb[i] = grackle::impl::fortran_wrapper::interpolate_1d_g( + log10_tCMB, cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], + cloudy_table.data_size, cloudy_table.cooling_data); + edot_met[i] = edot_met[i] + std::pow(10., log_cool_cmb[i]); + } + + if (get_heat == 1) { + log_cool[i] = grackle::impl::fortran_wrapper::interpolate_1d_g( + log10tem[i], cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], + cloudy_table.data_size, cloudy_table.heating_data); + edot_met[i] = edot_met[i] + std::pow(10., log_heat[i]); + } + + // Interpolate over density and temperature. + } else if (cloudy_table.grid_rank == 2) { + log_cool[i] = grackle::impl::fortran_wrapper::interpolate_2d_g( + log_n_h[i], log10tem[i], cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], + cloudy_table.grid_parameters[1], dclPar[1], cloudy_table.data_size, + cloudy_table.cooling_data); + edot_met[i] = -std::pow(10., log_cool[i]); + + // Ignore CMB term if T >> T_CMB + if ((icmbTfloor == 1) && ((log10tem[i] - log10_tCMB) < 2.)) { + log_cool_cmb[i] = grackle::impl::fortran_wrapper::interpolate_2d_g( + log_n_h[i], log10_tCMB, cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], + cloudy_table.grid_parameters[1], dclPar[1], + cloudy_table.data_size, cloudy_table.cooling_data); + edot_met[i] = edot_met[i] + std::pow(10., log_cool_cmb[i]); + } + + if (get_heat == 1) { + log_heat[i] = grackle::impl::fortran_wrapper::interpolate_2d_g( + log_n_h[i], log10tem[i], cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], + cloudy_table.grid_parameters[1], dclPar[1], + cloudy_table.data_size, cloudy_table.heating_data); + edot_met[i] = edot_met[i] + std::pow(10., log_heat[i]); + } + + // Interpolate over density, redshift, and temperature. + } else if (cloudy_table.grid_rank == 3) { + log_cool[i] = grackle::impl::fortran_wrapper::interpolate_3dz_g( + log_n_h[i], zr, log10tem[i], cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], + cloudy_table.grid_parameters[1], zindex, + cloudy_table.grid_parameters[2], dclPar[2], cloudy_table.data_size, + cloudy_table.cooling_data, end_int); + edot_met[i] = -std::pow(10., log_cool[i]); + + // Ignore CMB term if T >> T_CMB + if ((icmbTfloor == 1) && ((log10tem[i] - log10_tCMB) < 2.)) { + log_cool_cmb[i] = grackle::impl::fortran_wrapper::interpolate_3dz_g( + log_n_h[i], zr, log10_tCMB, cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], + cloudy_table.grid_parameters[1], zindex, + cloudy_table.grid_parameters[2], dclPar[2], + cloudy_table.data_size, cloudy_table.cooling_data, end_int); + edot_met[i] = edot_met[i] + std::pow(10., log_cool_cmb[i]); + } + + if (get_heat == 1) { + log_heat[i] = grackle::impl::fortran_wrapper::interpolate_3dz_g( + log_n_h[i], zr, log10tem[i], cloudy_table.grid_dimension, + cloudy_table.grid_parameters[0], dclPar[0], + cloudy_table.grid_parameters[1], zindex, + cloudy_table.grid_parameters[2], dclPar[2], + cloudy_table.data_size, cloudy_table.heating_data, end_int); + edot_met[i] = edot_met[i] + std::pow(10., log_heat[i]); + } + + } else { + OMP_PRAGMA_CRITICAL { + printf("Maximum cooling data grid rank is 3!\n"); + } + return; + } + + // Scale cooling by metallicity. + + if (iZscale == 1) { + edot_met[i] = edot_met[i] * metallicity[i]; + } + + edot[i] = edot[i] + (edot_met[i] * rhoH[i] * rhoH[i]); + } + } + + return; +} diff --git a/src/clib/cool1d_cloudy_g.hpp b/src/clib/cool1d_cloudy_g.hpp new file mode 100644 index 000000000..9e4b8771a --- /dev/null +++ b/src/clib/cool1d_cloudy_g.hpp @@ -0,0 +1,60 @@ +//===----------------------------------------------------------------------===// +// +// See the LICENSE file for license and copyright information +// SPDX-License-Identifier: NCSA AND BSD-3-Clause +// +//===----------------------------------------------------------------------===// +/// +/// @file +/// Declares the cool1d_cloudy_g function +/// +//===----------------------------------------------------------------------===// + +// This file was initially generated automatically during conversion of the +// cool1d_cloudy_g function from FORTRAN to C++ + +#ifndef COOL1D_CLOUDY_G_HPP +#define COOL1D_CLOUDY_G_HPP + +#include "grackle.h" // gr_float +#include "fortran_func_decls.h" // gr_mask_int +#include "index_helper.h" // IndexRange + +namespace grackle::impl { + +/// Solve cloudy metal cooling/heating +/// +/// Solve cloudy cooling by interpolating from the data. +/// +/// @param[in] rhoH 1D array to hold the computed Hydrogen mass density for the +/// @p idx_range +/// @param[in] metallicity 1D array to hold the computed metallicity for the @p +/// idx_range +/// @param[in] logtem Natural log of temperature values +/// @param[out] edot 1D array to hold the computed the time derivative of the +/// internal energy in the @p idx_range +/// @param[in] comp2 Constant factor to convert cooling rates to code units +/// @param[in] dom Unit conversion to proper number density in code units +/// @param[in] zr Current redshift +/// @param[in] icmbTfloor Flag to include temperature floor from cmb +/// @param[in] iClHeat Flag to include cloudy heating +/// @param[in] iZscale Flag to scale cooling by metallicity +/// @param[in] itmask Iteration mask +/// @param[in] cloudy_table Cloudy cooling table data +/// @param[in] my_fields Grackle field data +/// @param[in] idx_range Index range specifying the portion of the grid to +/// operate on +/// +/// @par History +/// written by: Britton Smith, 2009 +/// modified1: November, 2025 by Christopher Bignamini & Matthew Abruzzo; C++ +/// port +void cool1d_cloudy_g(const double* rhoH, const double* metallicity, + const double* logtem, double* edot, double comp2, + double dom, double zr, int icmbTfloor, int iClHeat, + int iZscale, const gr_mask_type* itmask, + cloudy_data cloudy_table, IndexRange idx_range); + +} // namespace grackle::impl + +#endif /* COOL1D_CLOUDY_G_HPP */ diff --git a/src/clib/cool1d_multi_g.cpp b/src/clib/cool1d_multi_g.cpp index 02793cc90..58cba3ff6 100644 --- a/src/clib/cool1d_multi_g.cpp +++ b/src/clib/cool1d_multi_g.cpp @@ -17,6 +17,7 @@ #include #include +#include "cool1d_cloudy_g.hpp" #include "cool1d_multi_g.hpp" #include "grackle.h" #include "fortran_func_decls.h" @@ -1485,20 +1486,10 @@ void grackle::impl::cool1d_multi_g( if (my_chemistry->primordial_chemistry == 0) { iZscale = 0; mycmbTfloor = 0; - FORTRAN_NAME(cool1d_cloudy_g)( - d.data(), rhoH, metallicity, &my_fields->grid_dimension[0], - &my_fields->grid_dimension[1], &my_fields->grid_dimension[2], - &idx_range.i_start, &idx_range.i_end, &idx_range.jp1, &idx_range.kp1, - logTlininterp_buf.logtem, edot, &comp2, &dom, &zr, &mycmbTfloor, - &my_chemistry->UVbackground, &iZscale, - &my_rates->cloudy_primordial.grid_rank, - my_rates->cloudy_primordial.grid_dimension, - my_rates->cloudy_primordial.grid_parameters[0], - my_rates->cloudy_primordial.grid_parameters[1], - my_rates->cloudy_primordial.grid_parameters[2], - &my_rates->cloudy_primordial.data_size, - my_rates->cloudy_primordial.cooling_data, - my_rates->cloudy_primordial.heating_data, itmask); + grackle::impl::cool1d_cloudy_g(rhoH, metallicity, logTlininterp_buf.logtem, + edot, comp2, dom, zr, mycmbTfloor, + my_chemistry->UVbackground, iZscale, itmask, + my_rates->cloudy_primordial, idx_range); // Calculate electron density from mean molecular weight @@ -1658,20 +1649,10 @@ void grackle::impl::cool1d_multi_g( if (my_rates->cloudy_data_new == 1) { iZscale = 1; - FORTRAN_NAME(cool1d_cloudy_g)( - d.data(), rhoH, metallicity, &my_fields->grid_dimension[0], - &my_fields->grid_dimension[1], &my_fields->grid_dimension[2], - &idx_range.i_start, &idx_range.i_end, &idx_range.jp1, &idx_range.kp1, - logTlininterp_buf.logtem, edot, &comp2, &dom, &zr, - &my_chemistry->cmb_temperature_floor, &my_chemistry->UVbackground, - &iZscale, &my_rates->cloudy_metal.grid_rank, - my_rates->cloudy_metal.grid_dimension, - my_rates->cloudy_metal.grid_parameters[0], - my_rates->cloudy_metal.grid_parameters[1], - my_rates->cloudy_metal.grid_parameters[2], - &my_rates->cloudy_metal.data_size, - my_rates->cloudy_metal.cooling_data, - my_rates->cloudy_metal.heating_data, itmask_tab.data()); + grackle::impl::cool1d_cloudy_g( + rhoH, metallicity, logTlininterp_buf.logtem, edot, comp2, dom, zr, + my_chemistry->cmb_temperature_floor, my_chemistry->UVbackground, + iZscale, itmask_tab.data(), my_rates->cloudy_metal, idx_range); } else { FORTRAN_NAME(cool1d_cloudy_old_tables_g)( diff --git a/src/clib/fortran_func_decls.h b/src/clib/fortran_func_decls.h index ff6fd5755..cf5e3f6fb 100644 --- a/src/clib/fortran_func_decls.h +++ b/src/clib/fortran_func_decls.h @@ -130,15 +130,6 @@ void FORTRAN_NAME(calc_temp1d_cloudy_g)( double* clPar3, long long* clDataSize, double* clMMW, gr_mask_type* itmask ); -void FORTRAN_NAME(cool1d_cloudy_g)( - gr_float* d_data_ptr, double* rhoH, double* metallicity, int* in, int* jn, - int* kn, int* is, int* ie, int* j, int* k, double* logtem, double* edot, - double* comp2, double* dom, double* zr, int* icmbTfloor, int* iClHeat, - int* iZscale, long long* clGridRank, long long* clGridDim, double* clPar1, - double* clPar2, double* clPar3, long long* clDataSize, double* clCooling, - double* clHeating, gr_mask_type* itmask -); - void FORTRAN_NAME(cool1d_cloudy_old_tables_g)( gr_float* d_data_ptr, gr_float* de_data_ptr, double* rhoH, double* metallicity, int* in, int* jn, int* kn, int* is, int* ie, int* j,