CR2RE Pipeline Reference Manual 1.6.10
hdrl_response-test.c
1/*
2 * This file is part of the HDRL
3 * Copyright (C) 2017 European Southern Observatory
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20#ifdef HAVE_CONFIG_H
21#include <config.h>
22#endif
23
24/*-----------------------------------------------------------------------------
25 Includes
26 -----------------------------------------------------------------------------*/
27
28#include "hdrl.h"
29
30#include <math.h>
31#include <cpl.h>
32
33
34/*-----------------------------------------------------------------------------
35 Define
36 -----------------------------------------------------------------------------*/
37
38#define HDRL_DELTA_COMPARE_VALUE HDRL_EPS_DATA * 1.
39
40
41const hdrl_spectrum1D_wave_scale scale = hdrl_spectrum1D_wave_scale_linear;
42
43hdrl_spectrum1D * create_spectrum(double * wavs,
44 double * flux, double * flux_e, const cpl_size sz){
45 cpl_image * flx = cpl_image_wrap_double(sz, 1, flux);
46 cpl_image * flx_e = cpl_image_wrap_double(sz, 1, flux_e);
47 cpl_array * wav = cpl_array_wrap_double(wavs, sz);
48
49 hdrl_spectrum1D * s = hdrl_spectrum1D_create(flx, flx_e, wav, scale);
50
51 cpl_image_unwrap(flx);
52 cpl_image_unwrap(flx_e);
53 cpl_array_unwrap(wav);
54
55 return s;
56}
57
58cpl_bivector * create_windows(const double * w1, const double * w2,
59 const cpl_size sz){
60
61 cpl_bivector * ret = cpl_bivector_new(sz);
62 cpl_vector * v1 = cpl_bivector_get_x(ret);
63 cpl_vector * v2 = cpl_bivector_get_y(ret);
64
65 for(cpl_size i = 0; i < sz; ++i){
66 cpl_vector_set(v1, i, w1[i]);
67 cpl_vector_set(v2, i, w2[i]);
68 }
69
70 return ret;
71}
72
73cpl_array * create_array(const double * els, const cpl_size sz){
74 cpl_array * to_ret = cpl_array_new(sz, HDRL_TYPE_DATA);
75 for(cpl_size i = 0; i < sz; ++i){
76 cpl_array_set(to_ret, i, els[i]);
77 }
78 return to_ret;
79}
80
81static cpl_error_code get_error_and_reset(void){
82 cpl_error_code r = cpl_error_get_code();
83 cpl_error_reset();
84 return r;
85}
86
87#define cpl_ensure_no_error cpl_test_eq(get_error_and_reset(), CPL_ERROR_NONE);
88
89#define cpl_ensure_error cpl_test_noneq(get_error_and_reset(), CPL_ERROR_NONE);
90
91/*----------------------------------------------------------------------------*/
95/*----------------------------------------------------------------------------*/
96void test_response_basic(void)
97{
98 double flx[] = {1,2,3,4,5};
99 double flx_e[] = {.1, .2, .1, .1, .05};
100 double wlen[] = {3,5,7,9,11};
101 hdrl_spectrum1D * s = create_spectrum(wlen, flx, flx_e, 5);
102
103 hdrl_response_result * r =
104 hdrl_response_compute(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
105 cpl_ensure_error;
106 cpl_test_null(r);
107
108 r = hdrl_response_compute(s, NULL, NULL, NULL, NULL, NULL, NULL);
109 cpl_ensure_error;
110 cpl_test_null(r);
111
112 r = hdrl_response_compute(s, s, s, NULL, NULL, NULL, NULL);
113 cpl_ensure_error;
114 cpl_test_null(r);
115
116 hdrl_parameter * calc_par =
117 hdrl_response_parameter_create((hdrl_value){1,.2},
118 (hdrl_value){2,.3},
119 (hdrl_value){5,.2},
120 (hdrl_value){7,.1});
121
122 double aPoints[5] = {3.1, 3.2, 3.3, 6.9, 7.0};
123 cpl_array * fit_points = create_array(aPoints, 5);
124
125 hdrl_parameter * fit_par =
126 hdrl_response_fit_parameter_create(11, fit_points, 1.0, NULL);
127
128 r = hdrl_response_compute(s, s, s, NULL, NULL, NULL, NULL);
129 cpl_ensure_error;
130 cpl_test_null(r);
132
133 r = hdrl_response_compute(s, s, s, NULL, NULL, calc_par, NULL);
134 cpl_ensure_error;
135 cpl_test_null(r);
137
138 r = hdrl_response_compute(s, s, s, NULL, NULL, NULL, fit_par);
139 cpl_ensure_error;
140 cpl_test_null(r);
142
143 r = hdrl_response_compute(s, s, s, NULL, NULL, fit_par, calc_par);
144 cpl_ensure_error;
145 cpl_test_null(r);
147
148 r = hdrl_response_compute(s, s, s, NULL, NULL, calc_par, fit_par);
149 cpl_ensure_no_error;
150 cpl_test_nonnull(r);
151
152 const hdrl_spectrum1D * raw_resp = hdrl_response_result_get_raw_response(r);
153
154 int rej = 0;
155 hdrl_value val = hdrl_spectrum1D_get_flux_value(raw_resp, 1, &rej);
156
157 cpl_test_eq(rej, 0);
158 cpl_test_eq(val.data, 5);
159 cpl_test_eq(val.error, 4);
160
161 const hdrl_spectrum1D * sel_resp = hdrl_response_result_get_selected_response(r);
162
163 rej = 0;
164 val = hdrl_spectrum1D_get_flux_value(sel_resp, 1, &rej);
165
166 cpl_test_eq(rej, 0);
167 cpl_test_eq(val.data, 2);
168 cpl_test_eq(val.error, 1);
169
170 const hdrl_spectrum1D * resp = hdrl_response_result_get_final_response(r);
171
172 rej = 0;
173 val = hdrl_spectrum1D_get_flux_value(resp, 1, &rej);
174
175 cpl_test_eq(rej, 0);
176 cpl_test_eq(val.data, 2);
177 cpl_test_eq(val.error, 1);
178
179
181
182 hdrl_parameter_delete(fit_par);
183 hdrl_parameter_delete(calc_par);
184 cpl_array_delete(fit_points);
186}
187
188
189void test_truncation(void){
190
191 hdrl_spectrum1D * obs_s = NULL;
192 hdrl_spectrum1D * ref_s = NULL;
193 hdrl_spectrum1D * E_x = NULL;
194
195 {
196 double flx[] = {1,2,3,4,5};
197 double flx_e[] = {.1, .2, .1, .1, .05};
198 double wlen[] = {3,5,7,9,11};
199 obs_s = create_spectrum(wlen, flx, flx_e, 5);
200 }
201
202 {
203 double flx[] = {1,2,3,4,5};
204 double flx_e[] = {.1, .2, .1, .1, .05};
205 double wlen[] = {3.5,5,7,9,11};
206 ref_s = create_spectrum(wlen, flx, flx_e, 5);
207 }
208
209 {
210 double flx[] = {1,2,3,4,5};
211 double flx_e[] = {.1, .2, .1, .1, .05};
212 double wlen[] = {3,5,7,9,10.5};
213 E_x = create_spectrum(wlen, flx, flx_e, 5);
214 }
215
216 hdrl_parameter * calc_par =
217 hdrl_response_parameter_create((hdrl_value){1,.2},
218 (hdrl_value){2,.3},
219 (hdrl_value){5,.2},
220 (hdrl_value){7,.1});
221
222 cpl_array * fit_points = create_array((double[]){3.1, 6.8, 6.9, 7.0, 7.5, 9.0, 11.0}, 7);
223 cpl_bivector * high_abs_regions = NULL;
224
225 hdrl_parameter * fit_par =
226 hdrl_response_fit_parameter_create(11, fit_points, 1.0, high_abs_regions);
227
228 hdrl_response_result * r = hdrl_response_compute(obs_s,
229 ref_s, E_x, NULL, NULL, calc_par, fit_par);
230 cpl_ensure_no_error;
231 cpl_test_nonnull(r);
232
233 const hdrl_spectrum1D * sel_resp =
235 const hdrl_spectrum1D * final_resp = hdrl_response_result_get_final_response(r);
236
237 const cpl_array * wlens_dest = hdrl_spectrum1D_get_wavelength(final_resp).wavelength;
238
239 const double wmin = cpl_array_get_min(wlens_dest);
240 const double wmax = cpl_array_get_max(wlens_dest);
241
242 cpl_test_rel(wmin, 5, 1e-10);
243 cpl_test_rel(wmax, 9, 1e-10);
244
245 cpl_test_eq(hdrl_spectrum1D_get_size(sel_resp), 5);
246
247 const cpl_array * wlens_sel = hdrl_spectrum1D_get_wavelength(sel_resp).wavelength;
248
249 cpl_test_rel(cpl_array_get(wlens_sel, 0, NULL), 6.8, HDRL_DELTA_COMPARE_VALUE);
250 cpl_test_rel(cpl_array_get(wlens_sel, 1, NULL), 6.9, HDRL_DELTA_COMPARE_VALUE);
251 cpl_test_rel(cpl_array_get(wlens_sel, 2, NULL), 7.0, HDRL_DELTA_COMPARE_VALUE);
252 cpl_test_rel(cpl_array_get(wlens_sel, 3, NULL), 7.5, HDRL_DELTA_COMPARE_VALUE);
253 cpl_test_rel(cpl_array_get(wlens_sel, 4, NULL), 9.0, HDRL_DELTA_COMPARE_VALUE);
254
259 hdrl_parameter_delete(calc_par);
260 hdrl_parameter_delete(fit_par);
261 cpl_array_delete(fit_points);
262 cpl_bivector_delete(high_abs_regions);
263}
264
265
266void test_edges_of_response_outside_fit_points(void){
267
268 hdrl_spectrum1D * obs_s = NULL;
269 hdrl_spectrum1D * ref_s = NULL;
270 hdrl_spectrum1D * E_x = NULL;
271
272 {
273 double flx[] = {1,2,3,4,5};
274 double flx_e[] = {.1, .2, .1, .1, .05};
275 double wlen[] = {3,5,7,9,11};
276 obs_s = create_spectrum(wlen, flx, flx_e, 5);
277 }
278
279 {
280 double flx[] = {1,2,3,4,5};
281 double flx_e[] = {.1, .2, .1, .1, .05};
282 double wlen[] = {3,5,7,9,11};
283 ref_s = create_spectrum(wlen, flx, flx_e, 5);
284 }
285
286 {
287 double flx[] = {1,2,3,4,5};
288 double flx_e[] = {.1, .2, .1, .1, .05};
289 double wlen[] = {3,5,7,9,11};
290 E_x = create_spectrum(wlen, flx, flx_e, 5);
291 }
292
293 hdrl_parameter * calc_par =
294 hdrl_response_parameter_create((hdrl_value){1,.2},
295 (hdrl_value){2,.3},
296 (hdrl_value){5,.2},
297 (hdrl_value){7,.1});
298
299 cpl_array * fit_points = create_array((double[]){3.1, 6.8, 6.9, 7.0, 7.5, 9.0, 11.0}, 7);
300 cpl_bivector * high_abs_regions = NULL;
301
302 hdrl_parameter * fit_par =
303 hdrl_response_fit_parameter_create(11, fit_points, 1.0, high_abs_regions);
304
305 hdrl_response_result * r = hdrl_response_compute(obs_s,
306 ref_s, E_x, NULL, NULL, calc_par, fit_par);
307 cpl_ensure_no_error;
308 cpl_test_nonnull(r);
309
310 const hdrl_spectrum1D * sel_resp =
312
313 const cpl_array * wlens_selected = hdrl_spectrum1D_get_wavelength(sel_resp).wavelength;
314
315 cpl_test_eq(cpl_array_get_size(wlens_selected), 7);
316
317 cpl_test_rel(cpl_array_get(wlens_selected, 0, NULL), 3.1, HDRL_DELTA_COMPARE_VALUE);
318 cpl_test_rel(cpl_array_get(wlens_selected, 1, NULL), 6.8, HDRL_DELTA_COMPARE_VALUE);
319 cpl_test_rel(cpl_array_get(wlens_selected, 2, NULL), 6.9, HDRL_DELTA_COMPARE_VALUE);
320 cpl_test_rel(cpl_array_get(wlens_selected, 3, NULL), 7.0, HDRL_DELTA_COMPARE_VALUE);
321 cpl_test_rel(cpl_array_get(wlens_selected, 4, NULL), 7.5, HDRL_DELTA_COMPARE_VALUE);
322 cpl_test_rel(cpl_array_get(wlens_selected, 5, NULL), 9.0, HDRL_DELTA_COMPARE_VALUE);
323 cpl_test_rel(cpl_array_get(wlens_selected, 6, NULL), 11.0, HDRL_DELTA_COMPARE_VALUE);
324
325 const hdrl_spectrum1D * final_resp = hdrl_response_result_get_final_response(r);
326
327 const cpl_array * wlens_dest = hdrl_spectrum1D_get_wavelength(final_resp).wavelength;
328 const cpl_array * wlens_obs = hdrl_spectrum1D_get_wavelength(obs_s).wavelength;
329
330 cpl_test_eq(cpl_array_get_size(wlens_dest), cpl_array_get_size(wlens_obs));
331 /*Must be defined on all the wavelengths (unless the models do not overlap, see test_truncation)*/
332 for(cpl_size i = 0; i < cpl_array_get_size(wlens_dest); ++i){
333 const double w_d = cpl_array_get(wlens_dest, i, NULL);
334 const double w_o = cpl_array_get(wlens_obs, i, NULL);
335 cpl_test_rel(w_d, w_o, 1e-10);
336 }
337
338 int rej = 0;
339 /*wlen = 3.0 outside the fit points, rejected*/
340 hdrl_spectrum1D_get_flux_value(final_resp, 0, & rej);
341 cpl_test_eq(rej, 1);
342
343 /*wlen = 7.0 is also the last fit point, NOT rejected*/
344 hdrl_spectrum1D_get_flux_value(final_resp, cpl_array_get_size(wlens_dest) - 1, & rej);
345 cpl_test_eq(rej, 0);
346
351 hdrl_parameter_delete(calc_par);
352 hdrl_parameter_delete(fit_par);
353 cpl_array_delete(fit_points);
354 cpl_bivector_delete(high_abs_regions);
355
356}
357
358void test_telluric(void){
359
360 hdrl_spectrum1D * t1 = NULL;
361 hdrl_spectrum1D * t2 = NULL;
362
363 {
364 double flx[] = {1, 2, 3, 4, 0, 1};
365 double flx_e[] = {.1, .2, .1, .1, .05, .3, .83};
366 double wlen[] = {3.1,5,7,9,10.9, 10.95};
367 t1 = create_spectrum(wlen, flx, flx_e, 6);
368 }
369
370 {
371 double flx[] = {2, 4, 6, 8, 0, 1};
372 double flx_e[] = {.1, .2, .1, .1, .05, 3.3};
373 double wlen[] = {3.1, 5, 7, 9, 10.9, 10.95};
374 t2 = create_spectrum(wlen, flx, flx_e, 6);
375 }
376
377 hdrl_spectrum1Dlist * ts = hdrl_spectrum1Dlist_new();
378
379 hdrl_spectrum1Dlist_set(ts, t2, 0);
380 hdrl_spectrum1Dlist_set(ts, t1, 1);
381
382 cpl_bivector * areas = cpl_bivector_new(3);
383
384 cpl_vector_set(cpl_bivector_get_x(areas), 0, 3);
385 cpl_vector_set(cpl_bivector_get_y(areas), 0, 5.1);
386
387 cpl_vector_set(cpl_bivector_get_x(areas), 1, 6.9);
388 cpl_vector_set(cpl_bivector_get_y(areas), 1, 7.1);
389
390 cpl_vector_set(cpl_bivector_get_x(areas), 2, 10.0);
391 cpl_vector_set(cpl_bivector_get_y(areas), 2, 11.0);
392
393 hdrl_parameter * tell_par =
395 CPL_FALSE, areas , areas, 3, 11);
396
397 hdrl_parameter * calc_par =
398 hdrl_response_parameter_create((hdrl_value){1,.2},
399 (hdrl_value){2,.3},
400 (hdrl_value){5,.2},
401 (hdrl_value){7,.1});
402
403 cpl_array * fit_points = create_array((double[]){3.1, 6.8, 6.9, 7.0, 7.5, 9.0, 11.0}, 7);
404 cpl_bivector * high_abs_regions = create_windows((double[]){8.9}, (double[]){9.1}, 1);
405
406 hdrl_parameter * fit_par =
407 hdrl_response_fit_parameter_create(11, fit_points, 1.0, high_abs_regions);
408
409 hdrl_response_result * r = hdrl_response_compute(t1,
410 t1, t1, tell_par, NULL, calc_par, fit_par);
411
413 cpl_test_eq(idx, 1);
414
416 double stddev = hdrl_response_result_get_stddev(r);
418 double doppler = hdrl_response_result_get_doppler_shift(r);
419
420 cpl_test_rel(mean, 0.0041, 1e-2);
421 cpl_test_rel(stddev, 0.707, 1e-2);
422 cpl_test((fabs(shift) < 1e-10));
423 cpl_test(doppler >= 0.);
424
425 const hdrl_spectrum1D * obs_corr =
427
428 cpl_test_eq(hdrl_spectrum1D_get_size(obs_corr), hdrl_spectrum1D_get_size(t1));
429
430 hdrl_value v = hdrl_spectrum1D_get_flux_value(obs_corr, 2, NULL);
431 cpl_test_rel(v.data, 1, 1e-5);
432
433 cpl_ensure_no_error;
434 cpl_test_nonnull(r);
435 cpl_bivector_delete(areas);
438 hdrl_parameter_delete(calc_par);
439 hdrl_parameter_delete(fit_par);
440 hdrl_parameter_delete(tell_par);
441 cpl_array_delete(fit_points);
442 cpl_bivector_delete(high_abs_regions);
443}
444
445void test_ignore_abs_regions(void){
446
447 hdrl_spectrum1D * obs_s = NULL;
448 hdrl_spectrum1D * ref_s = NULL;
449 hdrl_spectrum1D * E_x = NULL;
450
451 {
452 double flx[] = {1,2,3,4,5};
453 double flx_e[] = {.1, .2, .1, .1, .05};
454 double wlen[] = {3,5,7,9,11};
455 obs_s = create_spectrum(wlen, flx, flx_e, 5);
456 }
457
458 {
459 double flx[] = {1,2,3,4,5};
460 double flx_e[] = {.1, .2, .1, .1, .05};
461 double wlen[] = {3,5,7,9,11};
462 ref_s = create_spectrum(wlen, flx, flx_e, 5);
463 }
464
465 {
466 double flx[] = {1,2,3,4,5};
467 double flx_e[] = {.1, .2, .1, .1, .05};
468 double wlen[] = {3,5,7,9,11};
469 E_x = create_spectrum(wlen, flx, flx_e, 5);
470 }
471
472 hdrl_parameter * calc_par =
473 hdrl_response_parameter_create((hdrl_value){1,.2},
474 (hdrl_value){2,.3},
475 (hdrl_value){5,.2},
476 (hdrl_value){7,.1});
477
478 cpl_array * fit_points = create_array((double[]){3.1, 6.8, 6.9, 7.0, 7.5, 9.0, 11.0}, 7);
479 cpl_bivector * high_abs_regions = create_windows((double[]){8.9}, (double[]){9.1}, 1);
480
481
482 hdrl_parameter * fit_par_no_abs =
483 hdrl_response_fit_parameter_create(11, fit_points, 1.0, NULL);
484
485 hdrl_parameter * fit_par_abs =
486 hdrl_response_fit_parameter_create(11, fit_points, 1.0, high_abs_regions);
487
488 hdrl_response_result * r_no_abs = hdrl_response_compute(obs_s,
489 ref_s, E_x, NULL, NULL, calc_par, fit_par_no_abs);
490 cpl_ensure_no_error;
491 cpl_test_nonnull(r_no_abs);
492
493 hdrl_response_result * r_abs = hdrl_response_compute(obs_s,
494 ref_s, E_x, NULL, NULL, calc_par, fit_par_abs);
495 cpl_ensure_no_error;
496 cpl_test_nonnull(r_abs);
497
498 const hdrl_spectrum1D * resp_selected_abs = hdrl_response_result_get_selected_response(r_abs);
499 const hdrl_spectrum1D * resp_selected_no_abs = hdrl_response_result_get_selected_response(r_no_abs);
500
501 cpl_test_eq(hdrl_spectrum1D_get_size(resp_selected_abs), hdrl_spectrum1D_get_size(resp_selected_no_abs) - 1);
502
503 int rej = 0;
504 cpl_test_rel(hdrl_spectrum1D_get_wavelength_value(resp_selected_abs, 0, &rej),
505 hdrl_spectrum1D_get_wavelength_value(resp_selected_no_abs, 0, &rej), 1e-10);
506 cpl_test_rel(hdrl_spectrum1D_get_wavelength_value(resp_selected_abs, 1, &rej),
507 hdrl_spectrum1D_get_wavelength_value(resp_selected_no_abs, 1, &rej), 1e-10);
508 cpl_test_rel(hdrl_spectrum1D_get_wavelength_value(resp_selected_abs, 2, &rej),
509 hdrl_spectrum1D_get_wavelength_value(resp_selected_no_abs, 2, &rej), 1e-10);
510 cpl_test_rel(hdrl_spectrum1D_get_wavelength_value(resp_selected_abs, 3, &rej),
511 hdrl_spectrum1D_get_wavelength_value(resp_selected_no_abs, 3, &rej), 1e-10);
512 cpl_test_rel(hdrl_spectrum1D_get_wavelength_value(resp_selected_abs, 4, &rej),
513 hdrl_spectrum1D_get_wavelength_value(resp_selected_no_abs, 4, &rej), 1e-10);
514 cpl_test_rel(hdrl_spectrum1D_get_wavelength_value(resp_selected_abs, 5, &rej),
515 hdrl_spectrum1D_get_wavelength_value(resp_selected_no_abs, 6, &rej), 1e-10);
516
522 hdrl_parameter_delete(calc_par);
523 hdrl_parameter_delete(fit_par_no_abs);
524 hdrl_parameter_delete(fit_par_abs);
525 cpl_array_delete(fit_points);
526 cpl_bivector_delete(high_abs_regions);
527}
528
529/*----------------------------------------------------------------------------*/
533/*----------------------------------------------------------------------------*/
534int main(void)
535{
536 cpl_test_init(PACKAGE_BUGREPORT, CPL_MSG_WARNING);
537
538 test_response_basic();
539
540 test_truncation();
541
542 test_edges_of_response_outside_fit_points();
543
544 test_ignore_abs_regions();
545
546 test_telluric();
547
548 cpl_test_error(CPL_ERROR_NONE);
549
550 return cpl_test_end(0);
551}
552
hdrl_parameter * hdrl_response_parameter_create(const hdrl_value Ap, const hdrl_value Am, const hdrl_value G, const hdrl_value Tex)
ctor for the hdrl_parameter for response
void hdrl_parameter_delete(hdrl_parameter *obj)
shallow delete of a parameter
hdrl_data_t hdrl_response_result_get_stddev(const hdrl_response_result *res)
Getter of the standard deviation of the ratio between the corrected observed spectrum and its smoothe...
const hdrl_spectrum1D * hdrl_response_result_get_final_response(const hdrl_response_result *res)
Getter for the final response contained inside the hdrl_response_result.
const hdrl_spectrum1D * hdrl_response_result_get_selected_response(const hdrl_response_result *res)
Getter for the selected response contained inside the hdrl_response_result.
hdrl_parameter * hdrl_response_fit_parameter_create(const cpl_size radius, const cpl_array *fit_points, const hdrl_data_t wrange, const cpl_bivector *high_abs_regions)
ctor for the hdrl_parameter for the final interpolation of the response
cpl_size hdrl_response_result_get_best_telluric_model_idx(const hdrl_response_result *res)
Getter of the index of the telluric model used for telluric correction contained in hdrl_response_res...
hdrl_data_t hdrl_response_result_get_doppler_shift(const hdrl_response_result *res)
Getter of the doppler shift used to correct the model.
void hdrl_response_result_delete(hdrl_response_result *res)
Destructor for hdrl_response_result.
hdrl_response_result * hdrl_response_compute(const hdrl_spectrum1D *obs_s, const hdrl_spectrum1D *ref_s, const hdrl_spectrum1D *E_x, const hdrl_parameter *telluric_par, const hdrl_parameter *velocity_par, const hdrl_parameter *calc_par, const hdrl_parameter *fit_par)
Computation of the response.
hdrl_parameter * hdrl_response_telluric_evaluation_parameter_create(const hdrl_spectrum1Dlist *telluric_models, hdrl_data_t w_step, cpl_size half_win, cpl_boolean normalize, cpl_boolean shift_in_log_scale, const cpl_bivector *quality_areas, const cpl_bivector *fit_areas, hdrl_data_t lmin, hdrl_data_t lmax)
ctor for the hdrl_parameter for the telluric evaluation
const hdrl_spectrum1D * hdrl_response_result_get_raw_response(const hdrl_response_result *res)
Getter for the raw response contained inside the hdrl_response_result.
hdrl_data_t hdrl_response_result_get_avg_diff_from_1(const hdrl_response_result *res)
Getter of the value |mean - 1|, where mean is the average of the ratio between the corrected observed...
hdrl_data_t hdrl_response_result_get_telluric_shift(const hdrl_response_result *res)
Getter of the shift applied to the telluric model.
const hdrl_spectrum1D * hdrl_response_result_get_corrected_obs_spectrum(const hdrl_response_result *res)
Getter for the corrected observed spectrum contained in hdrl_response_result.
hdrl_spectrum1Dlist * hdrl_spectrum1Dlist_new(void)
hdrl_spectrum1Dlist default constructor
cpl_size hdrl_spectrum1D_get_size(const hdrl_spectrum1D *self)
hdrl_spectrum1D getter for size
void hdrl_spectrum1D_delete(hdrl_spectrum1D **p_self)
hdrl_spectrum1D destructor
cpl_error_code hdrl_spectrum1Dlist_set(hdrl_spectrum1Dlist *self, hdrl_spectrum1D *s, const cpl_size idx)
hdrl_spectrum1Dlist setter of the i-th element
void hdrl_spectrum1Dlist_delete(hdrl_spectrum1Dlist *l)
hdrl_spectrum1Dlist destructor
hdrl_spectrum1D * hdrl_spectrum1D_create(const cpl_image *arg_flux, const cpl_image *arg_flux_e, const cpl_array *wavelength, hdrl_spectrum1D_wave_scale wave_scale)
hdrl_spectrum1D default constructor
hdrl_spectrum1D_wavelength hdrl_spectrum1D_get_wavelength(const hdrl_spectrum1D *self)
hdrl_spectrum1D getter for wavelengths
hdrl_data_t hdrl_spectrum1D_get_wavelength_value(const hdrl_spectrum1D *self, int idx, int *rej)
hdrl_spectrum1D getter for a wavelength value
hdrl_value hdrl_spectrum1D_get_flux_value(const hdrl_spectrum1D *self, int idx, int *rej)
hdrl_spectrum1D getter for a flux value