rnsf_phase_fn.h (4701B)
1 /* Copyright (C) 2022, 2023 Centre National de la Recherche Scientifique 2 * Copyright (C) 2022, 2023 Institut Pierre-Simon Laplace 3 * Copyright (C) 2022, 2023 Institut de Physique du Globe de Paris 4 * Copyright (C) 2022, 2023 |Méso|Star> (contact@meso-star.com) 5 * Copyright (C) 2022, 2023 Observatoire de Paris 6 * Copyright (C) 2022, 2023 Université de Reims Champagne-Ardenne 7 * Copyright (C) 2022, 2023 Université de Versaille Saint-Quentin 8 * Copyright (C) 2022, 2023 Université Paul Sabatier 9 * 10 * This program is free software: you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation, either version 3 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #ifndef RNSF_PHASE_FN_H 24 #define RNSF_PHASE_FN_H 25 26 #include "rnsf.h" 27 #include <rsys/dynamic_array.h> 28 29 struct phase_fn_hg { 30 double g; /* Asymmetric parameter in [-1, 1] */ 31 }; 32 33 /* Generate the dynamic array of discrete items */ 34 #define DARRAY_NAME discrete_item 35 #define DARRAY_DATA struct rnsf_discrete_item 36 #include <rsys/dynamic_array.h> 37 38 struct phase_fn_discrete { 39 struct darray_discrete_item items; 40 }; 41 42 static INLINE res_T 43 phase_fn_discrete_init 44 (struct mem_allocator* allocator, 45 struct phase_fn_discrete* phase) 46 { 47 ASSERT(phase); 48 darray_discrete_item_init(allocator, &phase->items); 49 return RES_OK; 50 } 51 52 static INLINE void 53 phase_fn_discrete_release(struct phase_fn_discrete* phase) 54 { 55 ASSERT(phase); 56 darray_discrete_item_release(&phase->items); 57 } 58 59 static INLINE res_T 60 phase_fn_discrete_copy 61 (struct phase_fn_discrete* dst, 62 const struct phase_fn_discrete* src) 63 { 64 ASSERT(src && dst); 65 return darray_discrete_item_copy(&dst->items, &src->items); 66 } 67 68 static INLINE res_T 69 phase_fn_discrete_copy_and_release 70 (struct phase_fn_discrete* dst, 71 struct phase_fn_discrete* src) 72 { 73 ASSERT(src && dst); 74 return darray_discrete_item_copy_and_release(&dst->items, &src->items); 75 } 76 77 struct rnsf_phase_fn { 78 double wlen[2]; /* In nanometers */ 79 enum rnsf_phase_fn_type type; 80 union { 81 struct phase_fn_hg hg; 82 struct phase_fn_discrete discrete; 83 } param; 84 }; 85 86 static INLINE res_T 87 phase_fn_init 88 (struct mem_allocator* allocator, 89 struct rnsf_phase_fn* phase) 90 { 91 ASSERT(phase); 92 (void)allocator; 93 phase->wlen[0] = 0; 94 phase->wlen[1] = 0; 95 phase->type = RNSF_PHASE_FN_NONE__; 96 return RES_OK; 97 } 98 99 static INLINE void 100 phase_fn_release(struct rnsf_phase_fn* phase) 101 { 102 ASSERT(phase); 103 switch(phase->type) { 104 case RNSF_PHASE_FN_HG: 105 case RNSF_PHASE_FN_NONE__: 106 /* Do nothing */ 107 break; 108 case RNSF_PHASE_FN_DISCRETE: 109 phase_fn_discrete_release(&phase->param.discrete); 110 break; 111 default: FATAL("Unreachable code.\n"); break; 112 } 113 } 114 115 static INLINE res_T 116 phase_fn_copy 117 (struct rnsf_phase_fn* dst, 118 const struct rnsf_phase_fn* src) 119 { 120 res_T res = RES_OK; 121 dst->wlen[0] = src->wlen[0]; 122 dst->wlen[1] = src->wlen[1]; 123 dst->type = src->type; 124 switch(src->type) { 125 case RNSF_PHASE_FN_HG: 126 dst->param.hg.g = src->param.hg.g; 127 break; 128 case RNSF_PHASE_FN_DISCRETE: 129 res = phase_fn_discrete_copy 130 (&dst->param.discrete, 131 &src->param.discrete); 132 break; 133 case RNSF_PHASE_FN_NONE__: /* Do nothing */ break; 134 default: FATAL("Unreachable code.\n"); break; 135 } 136 return res; 137 } 138 139 static INLINE res_T 140 phase_fn_copy_and_release 141 (struct rnsf_phase_fn* dst, 142 struct rnsf_phase_fn* src) 143 { 144 res_T res = RES_OK; 145 dst->wlen[0] = src->wlen[0]; 146 dst->wlen[1] = src->wlen[1]; 147 dst->type = src->type; 148 switch(src->type) { 149 case RNSF_PHASE_FN_HG: 150 dst->param.hg.g = src->param.hg.g; 151 break; 152 case RNSF_PHASE_FN_DISCRETE: 153 res = phase_fn_discrete_copy_and_release 154 (&dst->param.discrete, 155 &src->param.discrete); 156 break; 157 case RNSF_PHASE_FN_NONE__: /* Do nothing */ break; 158 default: FATAL("Unreachable code.\n"); break; 159 } 160 return res; 161 } 162 163 /* Generate the dynamic array of phase functions */ 164 #define DARRAY_NAME phase_fn 165 #define DARRAY_DATA struct rnsf_phase_fn 166 #define DARRAY_FUNCTOR_INIT phase_fn_init 167 #define DARRAY_FUNCTOR_RELEASE phase_fn_release 168 #define DARRAY_FUNCTOR_COPY phase_fn_copy 169 #define DARRAY_FUNCTOR_COPY_AND_RELEASE phase_fn_copy_and_release 170 #include <rsys/dynamic_array.h> 171 172 #endif /* RNSF_PHASE_FN_H */