htgop_layer.h (8245B)
1 /* Copyright (C) 2018-2021, 2023 |Méso|Star> (contact@meso-star.com) 2 * 3 * This program is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published by 5 * the Free Software Foundation, either version 3 of the License, or 6 * (at your option) any later version. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. */ 15 16 #ifndef HTGOP_LAYER_H 17 #define HTGOP_LAYER_H 18 19 #include "htgop_dbllst.h" 20 #include <rsys/dynamic_array.h> 21 22 /******************************************************************************* 23 * Long wave spectral interval of a layer. Each data are defined per quadrature 24 * point. 25 ******************************************************************************/ 26 struct layer_lw_spectral_interval { 27 struct darray_double ka_nominal; /* Nominal absorption coef */ 28 struct darray_dbllst ka_tab; /* Tabulated absorption coef */ 29 }; 30 31 static INLINE void 32 layer_lw_spectral_interval_init 33 (struct mem_allocator* allocator, struct layer_lw_spectral_interval* inter) 34 { 35 ASSERT(inter); 36 darray_double_init(allocator, &inter->ka_nominal); 37 darray_dbllst_init(allocator, &inter->ka_tab); 38 } 39 40 static INLINE void 41 layer_lw_spectral_interval_release(struct layer_lw_spectral_interval* inter) 42 { 43 ASSERT(inter); 44 darray_double_release(&inter->ka_nominal); 45 darray_dbllst_release(&inter->ka_tab); 46 } 47 48 static INLINE res_T 49 layer_lw_spectral_interval_copy 50 (struct layer_lw_spectral_interval* dst, 51 const struct layer_lw_spectral_interval* src) 52 { 53 res_T res = RES_OK; 54 ASSERT(dst && src); 55 #define CALL(Func) { if(RES_OK != (res = Func)) return res; } (void)0 56 CALL(darray_double_copy(&dst->ka_nominal, &src->ka_nominal)); 57 CALL(darray_dbllst_copy(&dst->ka_tab, &src->ka_tab)); 58 #undef CALL 59 return RES_OK; 60 } 61 62 static INLINE res_T 63 layer_lw_spectral_interval_copy_and_release 64 (struct layer_lw_spectral_interval* dst, 65 struct layer_lw_spectral_interval* src) 66 { 67 res_T res = RES_OK; 68 ASSERT(dst && src); 69 #define CALL(Func) { if(RES_OK != (res = Func)) return res; } (void)0 70 CALL(darray_double_copy_and_release(&dst->ka_nominal, &src->ka_nominal)); 71 CALL(darray_dbllst_copy_and_release(&dst->ka_tab, &src->ka_tab)); 72 #undef CALL 73 layer_lw_spectral_interval_release(src); 74 return RES_OK; 75 } 76 77 /* Generate the darray_lay_lw_specint dynamic array */ 78 #define DARRAY_NAME lay_lw_specint 79 #define DARRAY_DATA struct layer_lw_spectral_interval 80 #define DARRAY_FUNCTOR_INIT layer_lw_spectral_interval_init 81 #define DARRAY_FUNCTOR_RELEASE layer_lw_spectral_interval_release 82 #define DARRAY_FUNCTOR_COPY layer_lw_spectral_interval_copy 83 #define DARRAY_FUNCTOR_COPY_AND_RELEASE \ 84 layer_lw_spectral_interval_copy_and_release 85 #include <rsys/dynamic_array.h> 86 87 /******************************************************************************* 88 * Short wave spectral interval of a layer. Each data are defined per 89 * quadrature point. 90 ******************************************************************************/ 91 struct layer_sw_spectral_interval { 92 struct darray_double ka_nominal; /* Nominal absorption coef */ 93 struct darray_double ks_nominal; /* Nominal diffusion coef */ 94 struct darray_dbllst ka_tab; /* Tabulated absorption coef */ 95 struct darray_dbllst ks_tab; /* Tabulated diffusion coef */ 96 }; 97 98 static INLINE void 99 layer_sw_spectral_interval_init 100 (struct mem_allocator* allocator, struct layer_sw_spectral_interval* inter) 101 { 102 ASSERT(inter); 103 darray_double_init(allocator, &inter->ka_nominal); 104 darray_double_init(allocator, &inter->ks_nominal); 105 darray_dbllst_init(allocator, &inter->ka_tab); 106 darray_dbllst_init(allocator, &inter->ks_tab); 107 } 108 109 static INLINE void 110 layer_sw_spectral_interval_release(struct layer_sw_spectral_interval* inter) 111 { 112 ASSERT(inter); 113 darray_double_release(&inter->ka_nominal); 114 darray_double_release(&inter->ks_nominal); 115 darray_dbllst_release(&inter->ka_tab); 116 darray_dbllst_release(&inter->ks_tab); 117 } 118 119 static INLINE res_T 120 layer_sw_spectral_interval_copy 121 (struct layer_sw_spectral_interval* dst, 122 const struct layer_sw_spectral_interval* src) 123 { 124 res_T res = RES_OK; 125 ASSERT(dst && src); 126 #define CALL(Func) { if(RES_OK != (res = Func)) return res; } (void)0 127 CALL(darray_double_copy(&dst->ka_nominal, &src->ka_nominal)); 128 CALL(darray_double_copy(&dst->ks_nominal, &src->ks_nominal)); 129 CALL(darray_dbllst_copy(&dst->ka_tab, &src->ka_tab)); 130 CALL(darray_dbllst_copy(&dst->ks_tab, &src->ks_tab)); 131 #undef CALL 132 return RES_OK; 133 } 134 135 static INLINE res_T 136 layer_sw_spectral_interval_copy_and_release 137 (struct layer_sw_spectral_interval* dst, 138 struct layer_sw_spectral_interval* src) 139 { 140 res_T res = RES_OK; 141 ASSERT(dst && src); 142 #define CALL(Func) { if(RES_OK != (res = Func)) return res; } (void)0 143 CALL(darray_double_copy_and_release(&dst->ka_nominal, &src->ka_nominal)); 144 CALL(darray_double_copy_and_release(&dst->ks_nominal, &src->ks_nominal)); 145 CALL(darray_dbllst_copy_and_release(&dst->ka_tab, &src->ka_tab)); 146 CALL(darray_dbllst_copy_and_release(&dst->ks_tab, &src->ks_tab)); 147 #undef CALL 148 layer_sw_spectral_interval_release(src); 149 return RES_OK; 150 } 151 152 /* Generate the darray_lay_sw_specint dynamic array */ 153 #define DARRAY_NAME lay_sw_specint 154 #define DARRAY_DATA struct layer_sw_spectral_interval 155 #define DARRAY_FUNCTOR_INIT layer_sw_spectral_interval_init 156 #define DARRAY_FUNCTOR_RELEASE layer_sw_spectral_interval_release 157 #define DARRAY_FUNCTOR_COPY layer_sw_spectral_interval_copy 158 #define DARRAY_FUNCTOR_COPY_AND_RELEASE \ 159 layer_sw_spectral_interval_copy_and_release 160 #include <rsys/dynamic_array.h> 161 162 /******************************************************************************* 163 * Per layer data 164 ******************************************************************************/ 165 struct layer { 166 double x_h2o_nominal; /* Nominal molar fraction of water vapor */ 167 struct darray_double x_h2o_tab; /* Tabulated xH2O */ 168 struct darray_lay_lw_specint lw_specints; /* Long wave spectral interval data */ 169 struct darray_lay_sw_specint sw_specints; /* Short wave spectral interval data */ 170 }; 171 172 static INLINE void 173 layer_init(struct mem_allocator* allocator, struct layer* layer) 174 { 175 ASSERT(layer); 176 darray_double_init(allocator, &layer->x_h2o_tab); 177 darray_lay_lw_specint_init(allocator, &layer->lw_specints); 178 darray_lay_sw_specint_init(allocator, &layer->sw_specints); 179 } 180 181 static INLINE void 182 layer_release(struct layer* layer) 183 { 184 ASSERT(layer); 185 darray_double_release(&layer->x_h2o_tab); 186 darray_lay_lw_specint_release(&layer->lw_specints); 187 darray_lay_sw_specint_release(&layer->sw_specints); 188 } 189 190 static INLINE res_T 191 layer_copy(struct layer* dst, const struct layer* src) 192 { 193 res_T res = RES_OK; 194 ASSERT(dst && src); 195 dst->x_h2o_nominal = src->x_h2o_nominal; 196 #define CALL(Func) { if(RES_OK != (res = Func)) return res; } (void)0 197 CALL(darray_double_copy(&dst->x_h2o_tab, &src->x_h2o_tab)); 198 CALL(darray_lay_lw_specint_copy(&dst->lw_specints, &src->lw_specints)); 199 CALL(darray_lay_sw_specint_copy(&dst->sw_specints, &src->sw_specints)); 200 #undef CALL 201 return RES_OK; 202 } 203 204 static INLINE res_T 205 layer_copy_and_release(struct layer* dst, struct layer* src) 206 { 207 res_T res = RES_OK; 208 ASSERT(dst && src); 209 dst->x_h2o_nominal = src->x_h2o_nominal; 210 #define CALL(Func) { if(RES_OK != (res = Func)) return res; } (void)0 211 CALL(darray_double_copy_and_release(&dst->x_h2o_tab, &src->x_h2o_tab)); 212 CALL(darray_lay_lw_specint_copy_and_release(&dst->lw_specints, &src->lw_specints)); 213 CALL(darray_lay_sw_specint_copy_and_release(&dst->sw_specints, &src->sw_specints)); 214 #undef CALL 215 layer_release(src); 216 return RES_OK; 217 } 218 219 /* Generate the darray_layer dynamic array */ 220 #define DARRAY_NAME layer 221 #define DARRAY_DATA struct layer 222 #define DARRAY_FUNCTOR_INIT layer_init 223 #define DARRAY_FUNCTOR_RELEASE layer_release 224 #define DARRAY_FUNCTOR_COPY layer_copy 225 #define DARRAY_FUNCTOR_COPY_AND_RELEASE layer_copy_and_release 226 #include <rsys/dynamic_array.h> 227 228 #endif /* HTGOP_LAYER_H */ 229