GRAVI Pipeline Reference Manual 1.9.0
Loading...
Searching...
No Matches
gravi_dfs.c
Go to the documentation of this file.
1/* $Id: gravi_dfs.c,v 1.6 2011/04/31 06:10:40 llundin Exp $
2 *
3 * This file is part of the GRAVI Pipeline
4 * Copyright (C) 2002,2003 European Southern Observatory
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
35/*
36 * History :
37 * 12/11/2018 add gravi_frameset_extract_static_param
38 * 04/12/2018 add gravi_frameset_extract_wave_param
39 */
40
41/*-----------------------------------------------------------------------------
42 Includes
43 -----------------------------------------------------------------------------*/
44
45#ifdef HAVE_CONFIG_H
46#include <config.h>
47#endif
48
49#include "time.h"
50#include <string.h>
51#include <math.h>
52#include <cpl.h>
53
54#include "gravi_dfs.h"
55#include "gravi_utils.h"
56
57/*-----------------------------------------------------------------------------
58 Functions code
59 -----------------------------------------------------------------------------*/
60
62{
63 cpl_msg_info(__func__, "**********************************************");
64 cpl_msg_info(__func__, " Welcome to GRAVITY Pipeline release %s",
65 PACKAGE_VERSION);
66 cpl_msg_info(__func__, " Last rebuilt at %s %s",__DATE__,__TIME__);
67 cpl_msg_info(__func__, "**********************************************");
68}
69
70/*----------------------------------------------------------------------------*/
76/*----------------------------------------------------------------------------*/
77
78cpl_error_code gravi_dfs_set_groups(cpl_frameset * set)
79{
80 cpl_ensure_code (set, CPL_ERROR_NULL_INPUT);
81
82 cpl_errorstate prestate = cpl_errorstate_get();
83 cpl_frame * frame = NULL;
84 int i, nb_frame;
85 nb_frame = cpl_frameset_get_size(set);
86
87
88 /* Loop on frames */
89 for (i = 0; i < nb_frame; i++) {
90
91 frame = cpl_frameset_get_position(set, i);
92 const char * tag = cpl_frame_get_tag(frame);
93
94 if (tag == NULL) {
95 cpl_msg_warning(cpl_func, "Frame %d has no tag", i);
96 } else if ((!strcmp(tag, GRAVI_DARK_RAW)) ||
97 (!strcmp(tag, GRAVI_FLAT_RAW)) ||
98 (!strcmp(tag, GRAVI_WAVE_RAW)) ||
99 (!strcmp(tag, GRAVI_WAVELAMP_RAW)) ||
100 (!strcmp(tag, GRAVI_P2VM_RAW)) ||
101 (!strcmp(tag, GRAVI_PIEZOTF_RAW)) ||
102 (!strcmp(tag, GRAVI_SINGLE_SCIENCE_RAW)) ||
103 (!strcmp(tag, GRAVI_SINGLE_CALIB_RAW)) ||
104 (!strcmp(tag, GRAVI_DUAL_SCIENCE_RAW)) ||
105 (!strcmp(tag, GRAVI_DUAL_CALIB_RAW))||
106 (!strcmp(tag, GRAVI_DUAL_SKY_RAW)) ||
107 (!strcmp(tag, GRAVI_SINGLE_SKY_RAW))||
108 (!strcmp(tag, GRAVI_VIS_SINGLE_CALIB)) ||
109 (!strcmp(tag, GRAVI_VISPHI_SINGLE_CALIB)) ||
110 (!strcmp(tag, GRAVI_VIS_SINGLE_SCIENCE)) ||
111 (!strcmp(tag, GRAVI_VIS_DUAL_CALIB)) ||
112 (!strcmp(tag, GRAVI_VISPHI_DUAL_CALIB)) ||
113 (!strcmp(tag, GRAVI_VIS_DUAL_SCIENCE)) ||
114 (!strcmp(tag, GRAVI_P2VMRED_SINGLE_CALIB)) ||
115 (!strcmp(tag, GRAVI_P2VMRED_SINGLE_SCIENCE)) ||
116 (!strcmp(tag, GRAVI_P2VMRED_DUAL_CALIB)) ||
117 (!strcmp(tag, GRAVI_P2VMRED_DUAL_SCIENCE)) ||
118 (!strcmp(tag, GRAVI_MIRA_INPUT_PROCATG))||
119 (!strcmp(tag, GRAVI_VIS_SINGLE_CALIBRATED)) ||
120 (!strcmp(tag, GRAVI_VIS_DUAL_CALIBRATED)) ||
121 (!strcmp(tag, GRAVI_DISP_RAW)) ){
122 /* RAW frames */
123 cpl_frame_set_group(frame, CPL_FRAME_GROUP_RAW);
124 }else if ((!strcmp(tag, GRAVI_DARK_MAP)) ||
125 (!strcmp(tag, GRAVI_FLAT_MAP)) ||
126 (!strcmp(tag, GRAVI_WAVE_MAP)) ||
127 (!strcmp(tag, GRAVI_P2VM_MAP)) ||
128 (!strcmp(tag, GRAVI_BAD_MAP)) ||
129 (!strcmp(tag, GRAVI_BIASMASK_MAP)) ||
130 (!strcmp(tag, GRAVI_PIEZOTF_MAP)) ||
131 (!strcmp(tag, GRAVI_PREPROC)) ||
132 (!strcmp(tag, GRAVI_TF_SINGLE_SCIENCE)) ||
133 (!strcmp(tag, GRAVI_TF_SINGLE_CALIB)) ||
134 (!strcmp(tag, GRAVI_VISPHI_TF_SINGLE_CALIB)) ||
135 (!strcmp(tag, GRAVI_WAVELAMP_MAP)) ||
136 (!strcmp(tag, GRAVI_TF_DUAL_SCIENCE)) ||
137 (!strcmp(tag, GRAVI_TF_DUAL_CALIB)) ||
138 (!strcmp(tag, GRAVI_VISPHI_TF_DUAL_CALIB)) ||
139 (!strcmp(tag, GRAVI_ZP_CAL)) ||
140 (!strcmp(tag, GRAVI_DISP_VIS)) ||
141 (!strcmp(tag, GRAVI_DIAMETER_CAT)) ||
142 (!strcmp(tag, GRAVI_DISP_MODEL)) ||
143 (!strcmp(tag, GRAVI_DIODE_POSITION))||
144 (!strcmp(tag, GRAVI_KEY_PATCH)) ||
145 (!strcmp(tag, GRAVI_ASTRO_CAL_PHASEREF)) ||
146 (!strcmp(tag, GRAVI_ASTRO_TARGET)) ||
147 (!strcmp(tag, GRAVI_ASTRO_SWAP))){
148 /* CALIB frames */
149 cpl_frame_set_group(frame, CPL_FRAME_GROUP_CALIB);
150 }else if (
151 (!strcmp(tag, GRAVI_MIRA_OUTPUT_PROCATG)) ||
152 (!strcmp(tag, GRAVI_NAB_CAL)) ){
153 /* PRODUCT frames */
154 cpl_frame_set_group(frame, CPL_FRAME_GROUP_PRODUCT);
155 }
156
157 }
158
159 if (!cpl_errorstate_is_equal(prestate)) {
160 return cpl_error_set_message(cpl_func, cpl_error_get_code(),
161 "Could not identify RAW and CALIB "
162 "frames");
163 }
164
165 return CPL_ERROR_NONE;
166}
167/*----------------------------------------------------------------------------*/
174/*----------------------------------------------------------------------------*/
175
176cpl_error_code gravi_parameter_disable (cpl_parameter * p)
177{
178 cpl_ensure_code (p, CPL_ERROR_NULL_INPUT);
179 cpl_parameter_disable (p, CPL_PARAMETER_MODE_CLI);
180 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
181 cpl_parameter_disable (p, CPL_PARAMETER_MODE_CFG);
182 return CPL_ERROR_NONE;
183}
184
185/*----------------------------------------------------------------------------*/
192/*----------------------------------------------------------------------------*/
193
194cpl_parameter * gravi_parameter_add_badpix (cpl_parameterlist *self)
195{
196 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
197
198 cpl_parameter *p;
199 p = cpl_parameter_new_value ("gravity.calib.bad-dark-threshold", CPL_TYPE_INT,
200 "the rms factor for "
201 "dark bad pixel threshold",
202 "gravity.calib", 10);
203 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "bad-dark-threshold");
204 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
205 cpl_parameterlist_append (self, p);
206
207 p = cpl_parameter_new_value ("gravity.calib.lowflux-pixels-ft", CPL_TYPE_BOOL,
208 "Flag as bad pixels all pixels on the FT which "
209 "have a non-sgnificant flux "
210 "(less than 33% of neighbouring pixel)"
211 "to increase SNR on faint targets",
212 "gravity.calib", FALSE);
213 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "lowflux-pixels-ft");
214 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
215 cpl_parameterlist_append (self, p);
216
217 p = cpl_parameter_new_value ("gravity.calib.bad-pixel-A-ft", CPL_TYPE_INT,
218 "flag a given pixel as bad on the FT detector"
219 "value is position of pixel (starting at 1)"
220 "a position of 0 means no pixel is flagged",
221 "gravity.calib", 0);
222 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "bad-pixel-A-ft");
223 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
224 cpl_parameterlist_append (self, p);
225
226 p = cpl_parameter_new_value ("gravity.calib.bad-pixel-B-ft", CPL_TYPE_INT,
227 "flag a second pixel as bad on the FT detector"
228 "value is position of pixel (starting at 1)"
229 "a position of 0 means no pixel is flagged",
230 "gravity.calib", 0);
231 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "bad-pixel-B-ft");
232 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
233 cpl_parameterlist_append (self, p);
234
235 return p;
236}
237
238/*----------------------------------------------------------------------------*/
245/*----------------------------------------------------------------------------*/
246
247cpl_parameter * gravi_parameter_add_pcacalib (cpl_parameterlist *self)
248{
249 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
250
251 cpl_parameter *p;
252
253 /* Number of PCA components */
254 p = cpl_parameter_new_value("gravity.calib.pca-components", CPL_TYPE_INT,
255 "The number of PCA components to compute.",
256 "gravity.calib", 1);
257 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "pca-components");
258 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
259 cpl_parameterlist_append (self, p);
260
261 /* Tracking ratio threshold */
262 p = cpl_parameter_new_value("gravity.calib.pca-tracking-ratio", CPL_TYPE_INT,
263 "The minimum tracking ratio to accept calibration frames for.",
264 "gravity.calib", 90);
265 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "pca-tracking-ratio");
266 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
267 cpl_parameterlist_append (self, p);
268
269 /* Outlier cleaning window size */
270 p = cpl_parameter_new_value("gravity.calib.pca-clean-size", CPL_TYPE_INT,
271 "The window size to use for outlier cleaning.",
272 "gravity.calib", 20);
273 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "pca-clean-size");
274 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
275 cpl_parameterlist_append (self, p);
276
277 /* Tracking ratio threshold */
278 p = cpl_parameter_new_value("gravity.calib.pca-clean-nstd", CPL_TYPE_DOUBLE,
279 "The sigma-clip n_std for outlier cleaning.",
280 "gravity.calib", 5.0);
281 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "pca-clean-nstd");
282 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
283 cpl_parameterlist_append (self, p);
284
285 /* method for fitting PCA components */
286 const char *PCA_FIT_TYPES[2] = {"POLYNOMIAL", "SPLINE"};
287 p = cpl_parameter_new_enum("gravity.calib.pca-fit-type", CPL_TYPE_STRING,
288 "The method to use for fitting the PCA components.",
289 "gravity.calib",
290 PCA_FIT_TYPES[1], 2, PCA_FIT_TYPES[0], PCA_FIT_TYPES[1]
291 );
292 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "pca-fit-type");
293 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
294 cpl_parameterlist_append (self, p);
295
296 /* degree of model for fitting PCA components */
297 p = cpl_parameter_new_value("gravity.calib.pca-fit-degree", CPL_TYPE_INT,
298 "The polynomial fit degree, or number of spline coefficients.",
299 "gravity.calib", 20);
300 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "pca-fit-degree");
301 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
302 cpl_parameterlist_append (self, p);
303
304 /* whether to output the phase residuals for inspection */
305 p = cpl_parameter_new_value("gravity.calib.pca-save-residuals", CPL_TYPE_BOOL,
306 "Also save the residuals from the PCA fitting for inspection.",
307 "gravity.calib", CPL_FALSE);
308 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "pca-save-residuals");
309 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
310 cpl_parameterlist_append (self, p);
311
312 return p;
313}
314
315/*----------------------------------------------------------------------------*/
322/*----------------------------------------------------------------------------*/
323
324cpl_parameter * gravi_parameter_add_pca (cpl_parameterlist *self)
325{
326 /* Whether to use PCA method to remove VISPHI systematics */
327 cpl_parameter *p = cpl_parameter_new_value ("gravity.vis.flatten-visphi", CPL_TYPE_BOOL,
328 "Use the PCA calibrator to flatten the VISPHI.",
329 "gravity.vis", CPL_FALSE);
330 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "flatten-visphi");
331 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
332 cpl_parameterlist_append (self, p);
333
334 return p;
335}
336
337/*----------------------------------------------------------------------------*/
344/*----------------------------------------------------------------------------*/
345
346cpl_parameter * gravi_parameter_add_profile (cpl_parameterlist *self)
347{
348 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
349
350 cpl_parameter *p;
351
352 /* Method for profile */
353 p = cpl_parameter_new_enum ("gravity.calib.profile-mode", CPL_TYPE_STRING,
354 "Method to compute the extraction profile. "
355 "PROFILE corresponds to the pixel intensities measured in the "
356 "FLAT files (Gaussian like with FWHM of approx 1.5 pixel). "
357 "This is the AUTO option for the Low and Med spectral resolution. "
358 "GAUSS corresponds to a Gaussian fit of the (non-zero) pixel intensities measured "
359 "in the FLAT files. BOX corresponds to a box-card of 6 pixels centered "
360 "on the spectra measured in the FLAT files. This is the AUTO option for High "
361 "spectral resolution",
362 "gravity.calib", "AUTO",
363 4, "AUTO", "PROFILE", "GAUSS", "BOX");
364 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "profile-mode");
365 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
366 cpl_parameterlist_append (self, p);
367
368 /* How to deal with bad-pixels */
369 p = cpl_parameter_new_value ("gravity.calib.force-badpix-to-zero", CPL_TYPE_BOOL,
370 "Force the badpixel to zero in profile",
371 "gravity.calib", TRUE);
372 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "force-badpix-to-zero");
373 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
374 cpl_parameterlist_append (self, p);
375
376 /* The width of the profile element */
377 p = cpl_parameter_new_value ("gravity.calib.profile-width", CPL_TYPE_INT,
378 "Width of the detector window extracted around the default "
379 "position of each spectrum, and on which the profile "
380 "will be applied to perform the extraction.",
381 "gravity.calib", 6);
382 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "profile-width");
383 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
384 cpl_parameterlist_append (self, p);
385
386 return p;
387}
388
389/*----------------------------------------------------------------------------*/
396/*----------------------------------------------------------------------------*/
397cpl_parameter * gravi_parameter_add_preproc (cpl_parameterlist *self)
398{
399 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
400
401 cpl_parameter *p = NULL;
402
403 /* Method for interpolation */
404// p = cpl_parameter_new_value ("gravity.preproc.interp-3pixels", CPL_TYPE_BOOL,
405// "Interpolate with 3 pixels",
406// "gravity.calib", FALSE);
407// cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "interp-3pixels");
408// cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
409// cpl_parameterlist_append (self, p);
410
411 return p;
412}
413
414
415/*----------------------------------------------------------------------------*/
422/*----------------------------------------------------------------------------*/
423cpl_parameter * gravi_parameter_add_wave (cpl_parameterlist *self)
424{
425 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
426
427 cpl_parameter *p;
428
429 /* Method for profile */
430 p = cpl_parameter_new_value ("gravity.calib.force-wave-ft-equal", CPL_TYPE_BOOL,
431 "Force the spatial order of the wavelength 2D fit for FT to "
432 "zero (so all region share the same calibration). "
433 "This is used to build the P2VM calibration of the TAC "
434 "real-time code running on the instrument ifself.",
435 "gravity.calib", FALSE);
436 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "force-wave-ft-equal");
437 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
438 cpl_parameterlist_append (self, p);
439
440 /* Spectral order of 2D wave fit */
441// p = cpl_parameter_new_value ("gravity.calib.wave-spectral-order", CPL_TYPE_INT,
442// "Set the spatial order of the wavelength 2D fit for SC.",
443// "gravity.calib", 3);
444// cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "wave-spectral-order");
445// cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
446// cpl_parameterlist_append (self, p);
447
448 /* Wave determination */
449// p = cpl_parameter_new_enum ("gravity.calib.wave-mode", CPL_TYPE_STRING,
450// "Define the way the wavelength are computed.\n "
451// "PIXEL to compute the wavelength per pixels\n "
452// "BASELINE to compute the wavelength per baseline (ABCD)\n "
453// "AUTO to compute the wavelength per pixels in LOW, and per baseline otherwise",
454// "gravity.calib", "AUTO", 3,
455// "PIXEL","BASELINE","AUTO");
456// cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "wave-mode");
457// cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
458// cpl_parameterlist_append (self, p);
459
460 return p;
461}
462
463
464cpl_parameter * gravi_parameter_add_static_name (cpl_parameterlist *self)
465{
466 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
467
468 cpl_parameter *p;
469 p = cpl_parameter_new_value ("gravity.dfs.static-name", CPL_TYPE_BOOL,
470 "Use static names for the products (for ESO)",
471 "gravity.dfs", FALSE);
472 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "static-name");
473 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
474 cpl_parameterlist_append (self, p);
475
476 return p;
477}
478
479cpl_parameter * gravi_parameter_add_debug_file (cpl_parameterlist *self)
480{
481 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
482
483 cpl_parameter *p;
484 p = cpl_parameter_new_value ("gravity.dfs.debug-file", CPL_TYPE_BOOL,
485 "Save additional debug file(s)",
486 "gravity.dfs", FALSE);
487 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "debug-file");
488 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
489 cpl_parameterlist_append (self, p);
490
491 return p;
492}
493
494cpl_parameter * gravi_parameter_add_biassub_file (cpl_parameterlist *self)
495{
496 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
497
498 cpl_parameter *p;
499 p = cpl_parameter_new_value ("gravity.dfs.bias-subtracted-file", CPL_TYPE_BOOL,
500 "Save the BIAS_SUBTRACTED intermediate product",
501 "gravity.dfs", FALSE);
502 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "bias-subtracted-file");
503 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
504 cpl_parameterlist_append (self, p);
505
506 return p;
507}
508
509cpl_parameter * gravi_parameter_add_spectrum_file (cpl_parameterlist *self)
510{
511 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
512
513 cpl_parameter *p;
514 p = cpl_parameter_new_value ("gravity.dfs.spectrum-file", CPL_TYPE_BOOL,
515 "Save the SPECTRUM intermediate product",
516 "gravity.dfs", FALSE);
517 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "spectrum-file");
518 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
519 cpl_parameterlist_append (self, p);
520
521 return p;
522}
523
524cpl_parameter * gravi_parameter_add_preproc_file (cpl_parameterlist *self)
525{
526 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
527
528 cpl_parameter *p;
529 p = cpl_parameter_new_value ("gravity.dfs.preproc-file", CPL_TYPE_BOOL,
530 "Save the PREPROC intermediate product",
531 "gravity.dfs", FALSE);
532 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "preproc-file");
533 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
534 cpl_parameterlist_append (self, p);
535
536 return p;
537}
538
539cpl_parameter * gravi_parameter_add_p2vmred_file (cpl_parameterlist *self)
540{
541 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
542
543 cpl_parameter *p;
544 p = cpl_parameter_new_value ("gravity.dfs.p2vmred-file", CPL_TYPE_BOOL,
545 "Save the P2VMRED intermediate product",
546 "gravity.dfs", FALSE);
547 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "p2vmreduced-file");
548 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
549 cpl_parameterlist_append (self, p);
550
551 return p;
552}
553
554cpl_parameter * gravi_parameter_add_vis_file (cpl_parameterlist *self)
555{
556 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
557
558 cpl_parameter *p;
559 p = cpl_parameter_new_value ("gravity.dfs.vis-file", CPL_TYPE_BOOL,
560 "Save the VIS intermediate product",
561 "gravity.dfs", FALSE);
562 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vis-file");
563 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
564 cpl_parameterlist_append (self, p);
565
566 return p;
567}
568
569cpl_parameter * gravi_parameter_add_astro_file (cpl_parameterlist *self)
570{
571 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
572
573 cpl_parameter *p;
574 p = cpl_parameter_new_value ("gravity.dfs.astro-file", CPL_TYPE_BOOL,
575 "Save the ASTROREDUCED intermediate product",
576 "gravity.dfs", FALSE);
577 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "astro-file");
578 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
579 cpl_parameterlist_append (self, p);
580
581 return p;
582}
583
584cpl_parameter * gravi_parameter_add_biasmethod (cpl_parameterlist *self)
585{
586 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
587
588 cpl_parameter *p;
589 p = cpl_parameter_new_enum ("gravity.preproc.bias-method", CPL_TYPE_STRING,
590 "Method to average the biaspixels when cleaning-up\n "
591 "the SC detector (only applied to MED and LOW). Ideally\n "
592 "the same value shall be used when reducing the DARK\n "
593 "with gravity_dark and the OBJECT with gravity_vis. \n"
594 "AUTO is equivalent to MASKED_MEDIAN_PER_COLUMN if the data\n"
595 "contains in the IMAGING_DETECTOR_SC extension the\n"
596 "LEFT, HALFLEFT, CENTER, HALFRIGHT and RIGHT columns.\n"
597 "Otherwise it is like MEDIAN.\n",
598 "gravity.preproc", "AUTO",
599 4, "AUTO", "MEDIAN", "MEDIAN_PER_COLUMN",
600 "MASKED_MEDIAN_PER_COLUMN");
601 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "bias-method");
602 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
603 cpl_parameterlist_append (self, p);
604
605 p = cpl_parameter_new_value ("gravity.preproc.remove-cosmicrays", CPL_TYPE_BOOL,
606 "Remove the cosmicrays with the statiscal method",
607 "gravity.preproc", TRUE);
608 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "remove-cosmicrays");
609 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
610 cpl_parameterlist_append (self, p);
611
612 return p;
613}
614
615cpl_parameter * gravi_parameter_add_metrology (cpl_parameterlist *self)
616{
617 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
618
619 cpl_parameter *p;
620 p = cpl_parameter_new_value ("gravity.metrology.acq-correction-delay",
621 CPL_TYPE_DOUBLE,
622 "Delay between the end of ACQ frame and correction\n "
623 "offset seen by the metrology diodes, in seconds.",
624 "gravity.metrology", 0.25);
625 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "acq-correction-delay");
626 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
627 cpl_parameterlist_append (self, p);
628
629 p = cpl_parameter_new_value ("gravity.metrology.use-fiber-dxy", CPL_TYPE_BOOL,
630 "Use the fiber position when computing OPD_TEL_CORR.",
631 "gravity.metrology", FALSE);
632 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "use-fiber-dxy");
633 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
634 cpl_parameterlist_append (self, p);
635
636 p = cpl_parameter_new_value ("gravity.metrology.use-met-rtc", CPL_TYPE_BOOL,
637 "Reduce metrology voltage with the real time algorithm\n"
638 "instead of using the pipeline’s algorithm.",
639 "gravity.metrology", FALSE);
640 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "use-met-rtc");
641 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
642 cpl_parameterlist_append (self, p);
643
644
645 p = cpl_parameter_new_value ("gravity.metrology.use-faint-met", CPL_TYPE_BOOL,
646 "In FAINT also the faint parts of the metrology \n"
647 "are used, not only the bright periods.",
648 "gravity.metrology", TRUE);
649 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "use-faint-met");
650 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
651 cpl_parameterlist_append (self, p);
652
653 p = cpl_parameter_new_value ("gravity.metrology.preswitch-delay", CPL_TYPE_INT,
654 "Delay where metrology values are ignored before\n"
655 "laser brightness is switched in faint mode, ms.",
656 "gravity.metrology", 60);
657 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "preswitch-delay");
658 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
659 cpl_parameterlist_append (self, p);
660
661 p = cpl_parameter_new_value ("gravity.metrology.postswitch-delay", CPL_TYPE_INT,
662 "Delay where metrology values are ignored after\n"
663 "laser brightness is switched in faint mode, ms.",
664 "gravity.metrology", 320);
665 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "postswitch-delay");
666 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
667 cpl_parameterlist_append (self, p);
668
669 p = cpl_parameter_new_value ("gravity.metrology.demodulate-metrology", CPL_TYPE_BOOL,
670 "Perform demodulation on the raw metrology data.",
671 "gravity.metrology", CPL_TRUE);
672 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "demodulate-metrology");
673 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
674 cpl_parameterlist_append (self, p);
675
676 p = cpl_parameter_new_value ("gravity.metrology.use-dark-offsets", CPL_TYPE_BOOL,
677 "Use diode zeros measured from the DARK when demodulating metrology.",
678 "gravity.metrology", CPL_TRUE);
679 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "use-dark-offsets");
680 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
681 cpl_parameterlist_append (self, p);
682
683 return p;
684}
685
686cpl_parameter * gravi_parameter_add_extract (cpl_parameterlist *self)
687{
688 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
689
690 cpl_parameter *p;
691 p = cpl_parameter_new_value ("gravity.preproc.ditshift-sc", CPL_TYPE_INT,
692 "Shift the time of SC DITs by an integer value to\n "
693 "account for lost frames in exposure (issue on the\n "
694 "instrument side, report to instrument team). The\n "
695 "time of all DITs in exposure are increased by\n "
696 "ditshift x PERIOD. ditshift can be 0,\n "
697 "positive (system has lost one SC DIT), or negative "
698 "(SC desynchronized).",
699 "gravity.preproc",0);
700 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "ditshift-sc");
701 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
702 cpl_parameterlist_append (self, p);
703
704 p = cpl_parameter_new_value ("gravity.preproc.extra-pixel-ft", CPL_TYPE_BOOL,
705 "Include the 6th pixels ot the FT",
706 "gravity.preproc", TRUE);
707 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "extra-pixel-ft");
708 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
709 cpl_parameterlist_append (self, p);
710
711 return p;
712}
713
714cpl_parameter * gravi_parameter_add_average_vis (cpl_parameterlist *self)
715{
716 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
717 cpl_parameter *p;
718 p = cpl_parameter_new_value ("gravity.postprocess.average-vis", CPL_TYPE_BOOL,
719 "Average the results from the different input files (if any)\n "
720 "in the output product, instead of simply appending them.",
721 "gravity.postprocess", FALSE);
722 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "average-vis");
723 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
724 cpl_parameterlist_append (self, p);
725
726 return p;
727}
728
729cpl_parameter * gravi_parameter_copy_fluxdata (cpl_parameterlist *self)
730{
731 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
732 cpl_parameter *p;
733 p = cpl_parameter_new_value ("gravity.postprocess.copy-fluxdata", CPL_TYPE_BOOL,
734 "Duplicate FLUX into FLUXDATA for OIFITS2\n "
735 "gravity.postprocess", FALSE);
736 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "copy-fluxdata");
737 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
738 cpl_parameterlist_append (self, p);
739
740 return p;
741}
742
743cpl_parameter * gravi_parameter_add_force_uncertainties (cpl_parameterlist *self)
744{
745 cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
746
747 cpl_parameter *p;
748 p = cpl_parameter_new_value ("gravity.postprocess.fluxerr-sc", CPL_TYPE_DOUBLE,
749 "Force the uncertainty in FLUX of SC",
750 "gravity.postprocess", 0.0);
751 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "fluxerr-sc");
752 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
753 cpl_parameterlist_append (self, p);
754
755 p = cpl_parameter_new_value ("gravity.postprocess.visamperr-sc", CPL_TYPE_DOUBLE,
756 "Force the uncertainty in VISAMP of SC",
757 "gravity.postprocess", 0.0);
758 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "visamperr-sc");
759 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
760 cpl_parameterlist_append (self, p);
761
762 p = cpl_parameter_new_value ("gravity.postprocess.visphierr-sc", CPL_TYPE_DOUBLE,
763 "Force the uncertainty in VISPHI of SC",
764 "gravity.postprocess", 0.0);
765 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "visphierr-sc");
766 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
767 cpl_parameterlist_append (self, p);
768
769 p = cpl_parameter_new_value ("gravity.postprocess.vis2err-sc", CPL_TYPE_DOUBLE,
770 "Force the uncertainty in VIS2 of SC",
771 "gravity.postprocess", 0.0);
772 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vis2err-sc");
773 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
774 cpl_parameterlist_append (self, p);
775
776 return p;
777}
778
779cpl_error_code gravi_parameter_add_compute_snr (cpl_parameterlist *self)
780{
781 cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
782 cpl_parameter *p;
783
784 /* chi2r */
785 p = cpl_parameter_new_value ("gravity.signal.chi2r-threshold", CPL_TYPE_DOUBLE,
786 "Threshold in chi2r of the fringe-fit to declare\n "
787 "a bad value. This is usefull to detect outliers\n "
788 "or cosmic in individual frames",
789 "gravity.signal", 50.0);
790 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "chi2r-threshold");
791 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
792 cpl_parameterlist_append (self, p);
793
794 p = cpl_parameter_new_value ("gravity.signal.chi2r-sigma", CPL_TYPE_DOUBLE,
795 "Threshold in chi2r of the fringe-fit (in unit of the \n "
796 "the std of chi2r in the spectral direction) to declare\n "
797 "a bad value. This is usefull to detect outliers\n "
798 "or cosmic in individual frames",
799 "gravity.signal", 100.0);
800 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "chi2r-sigma");
801 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
802 cpl_parameterlist_append (self, p);
803
804 /* Number of FT samples to average to compute SNR and GDELAY */
805 p = cpl_parameter_new_value ("gravity.signal.nsmooth-snr-ft", CPL_TYPE_INT,
806 "Number of samples to average coherently when computing\n "
807 "the real-time SNR and GDELAY of the FT (shall correspond\n "
808 "to the atmospheric coherence time). The integration\n "
809 "window runs from -nsmooth -> +nsmooth.",
810 "gravity.signal", 5);
811 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "nsmooth-snr-ft");
812 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
813 cpl_parameterlist_append (self, p);
814
815 return CPL_ERROR_NONE;
816}
817
818cpl_error_code gravi_parameter_add_compute_signal (cpl_parameterlist *self)
819{
820 cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
821 cpl_parameter *p;
822
823 /* Maxdeg */
824 p = cpl_parameter_new_value ("gravity.signal.phase-ref-sc-maxdeg", CPL_TYPE_INT,
825 "Maximum deg for the fit of PHASE_REF",
826 "gravity.signal", 3);
827 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "phase-ref-sc-maxdeg");
828 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
829 cpl_parameterlist_append (self, p);
830
831 /* Flag to activate metrology zero calculation */
832 p = cpl_parameter_new_value ("gravity.signal.use-met-zero", CPL_TYPE_BOOL,
833 "Flag to add a constant value to OPD_DISP.\n "
834 "This constant value is taken from the header.",
835 "gravity.signal", FALSE);
836 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "use-met-zero");
837 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
838 cpl_parameterlist_append (self, p);
839
840 /* Flag to control the use of metrology in IMAGING_REF calculation */
841 p = cpl_parameter_new_enum ("gravity.signal.imaging-ref-met", CPL_TYPE_STRING,
842 "Metrology source used for IMAGING_REF calculation:\n "
843 "Use fibre coupler metrology (FC);\n "
844 "Use fibre coupler metrology corrected from pupil motion (FC_CORR);\n "
845 "Use telescope metrology (TEL).",
846 "gravity.signal", "FC", 3,
847 "FC", "FC_CORR", "TEL");
848 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "imaging-ref-met");
849 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
850 cpl_parameterlist_append (self, p);
851
852 return CPL_ERROR_NONE;
853}
854
855/*----------------------------------------------------------------------------*/
863/*----------------------------------------------------------------------------*/
864cpl_error_code gravi_parameter_add_rejection (cpl_parameterlist *self, int isCalib)
865{
866 cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
867
868 cpl_parameter *p;
869 p = cpl_parameter_new_value ("gravity.signal.snr-min-ft", CPL_TYPE_DOUBLE,
870 "SNR threshold to accept FT frames (>0). It raises the first bit (<<0)\n "
871 "of column REJECTION_FLAG of FT.",
872 "gravity.signal", isCalib ? 30.0 : 3.0);
873 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "snr-min-ft");
874 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
875 cpl_parameterlist_append (self, p);
876
877 /* OPDC_STATE threshold for fringe DET in FT */
878 p = cpl_parameter_new_value ("gravity.signal.global-state-min-ft", CPL_TYPE_DOUBLE,
879 "Minimum OPDC state to accept FT frames (>=0) It raises the second bit\n "
880 "(<<1) of column REJECTION_FLAG of FT.",
881 "gravity.signal", 2.0);
882 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "global-state-min-ft");
883 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
884 cpl_parameterlist_append (self, p);
885
886 p = cpl_parameter_new_value ("gravity.signal.global-state-max-ft", CPL_TYPE_DOUBLE,
887 "Maximum OPDC state to accept FT frames (>=0) It raises the second bit\n "
888 "(<<1) of column REJECTION_FLAG of FT.",
889 "gravity.signal", 4.0);
890 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "global-state-max-ft");
891 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
892 cpl_parameterlist_append (self, p);
893
894 /* STATE threshold for fringe DET in FT */
895 p = cpl_parameter_new_value ("gravity.signal.state-min-ft", CPL_TYPE_DOUBLE,
896 "Minimum OPDC state per baseline to accept FT frames (>=0) It raises\n "
897 "the second bit (<<1) of column REJECTION_FLAG of FT.",
898 "gravity.signal", 1.0);
899 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "state-min-ft");
900 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
901 cpl_parameterlist_append (self, p);
902
903 /* Minimum detection ratio to accept SC frame */
904 p = cpl_parameter_new_value ("gravity.signal.tracking-min-sc", CPL_TYPE_DOUBLE,
905 "Minimum ratio of accepted FT frames in order to accept a SC frames (0..1),\n "
906 "that is, for each SC DIT, the fraction of the time the\n "
907 "REJECTION_FLAG of the FT is not 0.\n "
908 "It raises the first bit (<<0) of column REJECTION_FLAG of SC",
909 "gravity.signal", 0.8);
910 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "tracking-min-sc");
911 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
912 cpl_parameterlist_append (self, p);
913
914 /* vFactor threshold to accept SC frame */
915 p = cpl_parameter_new_value ("gravity.signal.vfactor-min-sc", CPL_TYPE_DOUBLE,
916 "vFactor threshold to accept SC frame (0..1).\n ",
917 "It raises the second bit (<<1) of column REJECTION_FLAG of SC",
918 "gravity.signal", isCalib ? 0.8 : 0.1);
919 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vfactor-min-sc");
920 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
921 cpl_parameterlist_append (self, p);
922
923 /* Threshold for OPD_PUPIL and OPD_PUPIL_STDDEV */
924 p = cpl_parameter_new_value ("gravity.signal.opd-pupil-max-sc", CPL_TYPE_DOUBLE,
925 "Maximum OPD_PUPIL (abs) to accept SC frames. It raises the third bit\n "
926 "(<<2) of column REJECTION_FLAG of SC.",
927 "gravity.signal", 9999.0);
928 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "opd-pupil-max-sc");
929 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
930 cpl_parameterlist_append (self, p);
931
932 p = cpl_parameter_new_value ("gravity.signal.opd-pupil-stddev-max-sc", CPL_TYPE_DOUBLE,
933 "Maximum OPD_PUPIL_STDDEV to accept SC frames. It\n "
934 "raises the fourth bit (<<3) of REJECTION_FLAG of SC.",
935 "gravity.signal", 2.9e-7);
936 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "opd-pupil-stddev-max-sc");
937 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
938 cpl_parameterlist_append (self, p);
939
940 return CPL_ERROR_NONE;
941}
942
943cpl_error_code gravi_parameter_add_compute_vis (cpl_parameterlist *self, int isCalib)
944{
945 cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
946 cpl_parameter *p;
947
948 /* Max-frame */
949 p = cpl_parameter_new_value ("gravity.vis.max-frame", CPL_TYPE_INT,
950 "Maximum number of frames to integrate \n "
951 "coherently into an OIFITS entry",
952 "gravity.vis", 10000);
953 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "max-frame");
954 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
955 cpl_parameterlist_append (self, p);
956
957 /* Force same time for all baselines */
958 p = cpl_parameter_new_value ("gravity.vis.force-same-time", CPL_TYPE_BOOL,
959 "Force all baseline/quantities to have\n "
960 "strictly the same TIME and MJD columns",
961 "gravity.vis", FALSE);
962 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "force-same-time");
963 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
964 cpl_parameterlist_append (self, p);
965
966 /* Debias SC VIS2 */
967 p = cpl_parameter_new_value ("gravity.vis.debias-sc", CPL_TYPE_BOOL,
968 "Subtract the V2 bias from SC",
969 "gravity.vis", TRUE);
970 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "debias-sc");
971 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
972 cpl_parameterlist_append (self, p);
973
974 /* Debias FT VIS2 */
975 p = cpl_parameter_new_value ("gravity.vis.debias-ft", CPL_TYPE_BOOL,
976 "Subtract the V2 bias from FT",
977 "gravity.vis", TRUE);
978 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "debias-ft");
979 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
980 cpl_parameterlist_append (self, p);
981
982 /* Number of bootstrap */
983 p = cpl_parameter_new_value ("gravity.vis.nboot", CPL_TYPE_INT,
984 "Number of bootstraps to compute error (1..100)",
985 "gravity.vis", isCalib ? 1 : 20);
986 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "nboot");
987 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
988 cpl_parameterlist_append (self, p);
989
990 /* Visibility correction */
991 p = cpl_parameter_new_enum ("gravity.vis.vis-correction-sc", CPL_TYPE_STRING,
992 "Correction of SC visibility from losses due to long integration,\n "
993 "using the measured visibility losses with the FT (VFACTOR\n "
994 "and/or PFACTOR) or by forcing\n "
995 "the SC visibilities to match those of the FT (FORCE). Possible\n "
996 "choices are:",
997 "gravity.vis",
998 isCalib ? "NONE" : "VFACTOR", 5, "VFACTOR", "PFACTOR",
999 "VFACTOR_PFACTOR","FORCE", "NONE");
1000 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vis-correction-sc");
1001 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1002 cpl_parameterlist_append (self, p);
1003
1004 p = cpl_parameter_new_enum ("gravity.vis.vis-correction-ft", CPL_TYPE_STRING,
1005 "Correction of FT visibility from losses due to long integration,\n "
1006 "using a sliding window P_FACTOR, or its square. Choices are:",
1007 "gravity.vis", "NONE", 3, "NONE", "PFACTOR", "PFACTOR_SQUARED");
1008 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vis-correction-ft");
1009 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1010 cpl_parameterlist_append (self, p);
1011
1012 /* Width of sliding window for FT P_FACTOR */
1013 p = cpl_parameter_new_value ("gravity.vis.pfactor-window-length", CPL_TYPE_INT,
1014 "Length of the sliding window used to calculate the FT P_FACTOR.\n "
1015 "For each FT frame, the window will run from -window-length to +window-length inclusive.",
1016 "gravity.vis", 40);
1017 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "pfactor-window-length");
1018 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1019 cpl_parameterlist_append (self, p);
1020
1021 /* Phase referencing */
1022 p = cpl_parameter_new_enum ("gravity.vis.phase-ref-sc", CPL_TYPE_STRING,
1023 "Reference phase used to integrate the SC frames.\n "
1024 "Use a self-estimate of the phase, fitted by poly. (SELF_REF)\n "
1025 "Use the FT phase only, interpolated in lbd (PHASE_REF)\n "
1026 "Use the FT+MET-SEP.UV phase (IMAGING_REF).",
1027 "gravity.vis", "AUTO", 5,
1028 "SELF_REF","PHASE_REF","IMAGING_REF","AUTO","NONE");
1029 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "phase-ref-sc");
1030 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1031 cpl_parameterlist_append (self, p);
1032
1033 /* Phase cleaning in the final OIFITS */
1034 p = cpl_parameter_new_enum ("gravity.vis.output-phase-sc", CPL_TYPE_STRING,
1035 "With DIFFERENTIAL, the mean group-delay and mean\n "
1036 "phases are removed from the output VISPHI in the\n "
1037 "final OIFITS file. With ABSOLUTE, the VISPHI is\n "
1038 "kept unmodified. With SELF_VISPHI, the internal differential\n "
1039 "phase between each spectral channel and a common \n "
1040 "reference channel is computed.\n",
1041 "gravity.vis", "AUTO", 4,
1042 "DIFFERENTIAL","ABSOLUTE","AUTO", "SELF_VISPHI");
1043 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "output-phase-sc");
1044 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1045 cpl_parameterlist_append (self, p);
1046
1047 /* string in the form [124,232] giving channel subset in case SELF_VISPHI */
1048 p = cpl_parameter_new_value ("gravity.vis.output-phase-channels", CPL_TYPE_STRING,
1049 "range (string in the form [min,max]) of channels\n "
1050 "to use a SELF_VISPHI phase reference.\n",
1051 "gravity.vis", "[0,0]");
1052 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "output-phase-channels");
1053 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1054 cpl_parameterlist_append (self, p);
1055
1056 /* Number of bootstrap */
1057 p = cpl_parameter_new_value ("gravity.vis.outlier-fraction-threshold", CPL_TYPE_DOUBLE,
1058 "Flag channels with more than this fraction of the frames\n "
1059 "affected by outliers or cosmics. These are typically detected\n "
1060 "with the thresholds options in chi2 of the fringe-fit.",
1061 "gravity.vis", 0.5);
1062 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "outlier-fraction-threshold");
1063 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1064 cpl_parameterlist_append (self, p);
1065
1066 return CPL_ERROR_NONE;
1067}
1068
1069cpl_error_code gravi_parameter_add_astrometry (cpl_parameterlist *self)
1070{
1071 cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
1072
1073 cpl_parameter *p;
1074
1075 /* just use fiber position for swaps rather than computing astrometry */
1076 p = cpl_parameter_new_value("gravity.astrometry.use-swap-fiber-pos", CPL_TYPE_BOOL,
1077 "use fiber position for swap rather than computing an astrometric solution.", "gravity.astrometry", CPL_FALSE);
1078 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "use-swap-fiber-pos");
1079 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1080 cpl_parameterlist_append (self, p);
1081
1082 /* range in RA for swap astrometry */
1083 p = cpl_parameter_new_value("gravity.astrometry.ra-lim-swap", CPL_TYPE_DOUBLE,
1084 "specify the RA range (in mas) over which to search for the astrometry of the swap. Default specifies entire field of view.", "gravity.astrometry", -1.0);
1085 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "ra-lim-swap");
1086 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1087 cpl_parameterlist_append (self, p);
1088
1089 p = cpl_parameter_new_value("gravity.astrometry.nra-swap", CPL_TYPE_INT,
1090 "number of points over the RA range for the swap.", "gravity.astrometry", 50);
1091 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "nra-swap");
1092 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1093 cpl_parameterlist_append (self, p);
1094
1095 /* range in dec for swap astrometry */
1096 p = cpl_parameter_new_value("gravity.astrometry.dec-lim-swap", CPL_TYPE_DOUBLE,
1097 "specify the dec range (in mas) over which to search for the astrometry of the swap. Default specifies entire field of view.", "gravity.astrometry", -1.0);
1098 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "dec-lim-swap");
1099 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1100 cpl_parameterlist_append (self, p);
1101
1102 p = cpl_parameter_new_value("gravity.astrometry.ndec-swap", CPL_TYPE_INT,
1103 "number of points over the dec range for the swap.", "gravity.astrometry", 50);
1104 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "ndec-swap");
1105 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1106 cpl_parameterlist_append (self, p);
1107
1108 /* average over DITs before reduction for speed */
1109 p = cpl_parameter_new_value("gravity.astrometry.average-over-dits", CPL_TYPE_BOOL,
1110 "Average over DITs before reducing astrometry for speed.", "gravity.astrometry", CPL_FALSE);
1111 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "average-over-dits");
1112 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1113 cpl_parameterlist_append (self, p);
1114
1115 p = cpl_parameter_new_value("gravity.astrometry.zoom-factor", CPL_TYPE_DOUBLE,
1116 "Factor to magnify ra/dec limits by after initial fit to find precise solution.", "gravity.astrometry", 1.0);
1117 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "zoom-factor");
1118 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1119 cpl_parameterlist_append (self, p);
1120
1121 // /* target name from FITS header */
1122 // p = cpl_parameter_new_value("gravity.astrometry.target-name", CPL_TYPE_STRING,
1123 // "specify a particular target to reduce (read from FITS header)", "gravity.astrometry", NULL);
1124
1125 // /* swap target name from FITS header */
1126 // p = cpl_parameter_new_value("gravity.astrometry.swap-target-name", CPL_TYPE_STRING,
1127 // "specify a particular target for the swap calibration in off-axis mode (read from FITS header)", "gravity.astrometry", NULL);
1128
1129 /* fiber position */
1130 // p = cpl_parameter_new_value("gravity.astrometry.fiber-pos-x", CPL_TYPE_DOUBLE,
1131 // "x position (in mas) of the fiber position to restrict the reduction to", "gravity.astrometry", 0.0);
1132 // cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "fiber-pos-x");
1133 // cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1134 // cpl_parameterlist_append (self, p);
1135
1136 // p = cpl_parameter_new_value("gravity.astrometry.fiber-pos-y", CPL_TYPE_DOUBLE,
1137 // "y position (in mas) of the fiber position to restrict the reduction to", "gravity.astrometry", 0.0);
1138 // cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "fiber-pos-y");
1139 // cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1140 // cpl_parameterlist_append (self, p);
1141
1142 /* FT flux threshold */
1143 p = cpl_parameter_new_value("gravity.astrometry.ft-mean-flux", CPL_TYPE_DOUBLE,
1144 "remove all data with FT flux below this factor times the mean", "gravity.astrometry", 0.2);
1145 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "ft-mean-flux");
1146 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1147 cpl_parameterlist_append (self, p);
1148
1149 /* Calibration strategy for computing amplitude references */
1150 const char * calib_strategies[] = {"NONE", "ALL", "SELF", "SWAP", "NEAREST"};
1151 p = cpl_parameter_new_enum_from_array("gravity.astrometry.calib-strategy", CPL_TYPE_STRING,
1152 "how to calculate the reference coherent flux\n"
1153 "\t'NONE': do not use an amplitude reference\n"
1154 "\t'ALL': use all files\n"
1155 "\t'SELF': calibrate each file individually\n"
1156 "\t'SWAP': use the swap files\n"
1157 "\t'NEAREST': use the nearest two (in time) files.",
1158 "gravity.astrometry", 0, 5, calib_strategies);
1159 cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "calib-strategy");
1160 cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1161 cpl_parameterlist_append (self, p);
1162
1163 /* temp for debugging */
1164 // p = cpl_parameter_new_value("gravity.astrometry.wait-for-debugger", CPL_TYPE_BOOL,
1165 // "busy wait for attaching the debugger.", "gravity.astrometry", CPL_FALSE);
1166 // cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "wait-for-debugger");
1167 // cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
1168 // cpl_parameterlist_append (self, p);
1169
1170 return CPL_ERROR_NONE;
1171}
1172
1173cpl_error_code gravi_parameter_add_image (cpl_parameterlist *self)
1174{
1175 cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
1176 cpl_parameter *p;
1177
1178 /* Fill the parameters list */
1179 /* --isotropic */
1180/* p = cpl_parameter_new_value("gravi.gravity_image.isotropic_option",
1181 CPL_TYPE_BOOL, "a flag", "gravi.gravity_image", FALSE);
1182 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "isotropic");
1183 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
1184 cpl_parameterlist_append(recipe->parameters, p);
1185*/
1186
1187 /* --pixelsize */
1188 p = cpl_parameter_new_value("gravi.gravity_image.pixelsize",
1189 CPL_TYPE_DOUBLE, "size of the pixel (milliarcseconds)",
1190 "gravi.gravity_image", 0.2);
1191 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "pixelsize");
1192 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
1193 cpl_parameterlist_append(self, p);
1194
1195 /* --dim */
1196 p = cpl_parameter_new_value("gravi.gravity_image.dim",
1197 CPL_TYPE_INT, "number of pixels per side of the image",
1198 "gravi.gravity_image", 100);
1199 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "dim");
1200 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
1201 cpl_parameterlist_append(self, p);
1202
1203 /* --regul */
1204 p = cpl_parameter_new_value("gravi.gravity_image.regul",
1205 CPL_TYPE_STRING, "name of regularization method",
1206 "gravi.gravity_image", "totvar");
1207 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "regul");
1208 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
1209 cpl_parameterlist_append(self, p);
1210
1211 /* --regul_mu */
1212 p = cpl_parameter_new_value("gravi.gravity_image.regul_mu",
1213 CPL_TYPE_DOUBLE, "global regularization weight",
1214 "gravi.gravity_image", 1E4);
1215 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "regul_mu");
1216 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
1217 cpl_parameterlist_append(self, p);
1218
1219 /* --maxeval */
1220 p = cpl_parameter_new_value("gravi.gravity_image.maxeval",
1221 CPL_TYPE_INT, "maximum number of evaluations of the objective function",
1222 "gravi.gravity_image", 2000);
1223 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "maxeval");
1224 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
1225 cpl_parameterlist_append(self, p);
1226
1227 /* --timeout */
1228 p = cpl_parameter_new_value("gravi.gravity_image.timeout",
1229 CPL_TYPE_DOUBLE, "Maximum execution time of Mira process (s)",
1230 "gravi.gravity_image", 60.);
1231 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "timeout");
1232 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
1233 cpl_parameterlist_append(self, p);
1234
1235
1236 return CPL_ERROR_NONE;
1237}
1238
1239/*----------------------------------------------------------------------------*/
1251/*----------------------------------------------------------------------------*/
1252
1253cpl_frameset * gravi_frameset_extract (cpl_frameset * frameset,
1254 const char ** frame_tags,
1255 int nb_tags)
1256{
1257 cpl_ensure (frameset, CPL_ERROR_NULL_INPUT, NULL);
1258 cpl_ensure (frame_tags, CPL_ERROR_NULL_INPUT, NULL);
1259 cpl_ensure (nb_tags>0, CPL_ERROR_ILLEGAL_INPUT, NULL);
1260
1261 int nb_frame = cpl_frameset_get_size (frameset);
1262 cpl_frameset * output_frameset = cpl_frameset_new();
1263
1264 /* Loop on frames in the frameset */
1265 for (int i = 0; i < nb_frame; i++){
1266
1267 cpl_frame * frame = cpl_frameset_get_position (frameset, i);
1268 const char * frame_tag = cpl_frame_get_tag (frame) ;
1269
1270 /* Loop on requested tags */
1271 for (int j = 0; j < nb_tags; j++) {
1272 if (strcmp(frame_tag, frame_tags[j]) == 0) {
1273 cpl_frameset_insert (output_frameset, cpl_frame_duplicate(frame));
1274 break;
1275 }
1276 }
1277
1278 } /* End loop on frames*/
1279
1280 return output_frameset;
1281}
1282
1283/*----------------------------------------------------------------------------*/
1291/*----------------------------------------------------------------------------*/
1292
1293cpl_frameset * gravi_frameset_extract_p2vm_data (cpl_frameset * frameset) {
1294 const char *tags[] = {GRAVI_P2VM_RAW};
1295 return gravi_frameset_extract (frameset, tags, 1);
1296}
1297cpl_frameset * gravi_frameset_extract_disp_data (cpl_frameset * frameset) {
1298 const char *tags[] = {GRAVI_DISP_RAW};
1299 return gravi_frameset_extract (frameset, tags, 1);
1300}
1301
1302/*----------------------------------------------------------------------------*/
1310/*----------------------------------------------------------------------------*/
1311cpl_frameset * gravi_frameset_extract_dark_data (cpl_frameset * frameset) {
1312 const char *tags[] = {GRAVI_DARK_RAW};
1313 return gravi_frameset_extract (frameset, tags, 1);
1314}
1315cpl_frameset * gravi_frameset_extract_flat_data (cpl_frameset * frameset) {
1316 const char *tags[] = {GRAVI_FLAT_RAW};
1317 return gravi_frameset_extract (frameset, tags, 1);
1318}
1319cpl_frameset * gravi_frameset_extract_diamcat_map (cpl_frameset * frameset) {
1320 const char *tags[] = {GRAVI_DIAMETER_CAT};
1321 return gravi_frameset_extract (frameset, tags, 1);
1322}
1323cpl_frameset * gravi_frameset_extract_fringe_data (cpl_frameset * frameset) {
1325 return gravi_frameset_extract (frameset, tags, 4);
1326}
1327cpl_frameset * gravi_frameset_extract_p2vmred_data (cpl_frameset * frameset) {
1330 return gravi_frameset_extract (frameset, tags, 4);
1331}
1332cpl_frameset * gravi_frameset_extract_piezotf_data (cpl_frameset * frameset) {
1333 const char *tags[] = {GRAVI_PIEZOTF_RAW};
1334 return gravi_frameset_extract (frameset, tags, 1);
1335}
1336cpl_frameset * gravi_frameset_extract_sky_data (cpl_frameset * frameset) {
1337 const char *tags[] = {GRAVI_DUAL_SKY_RAW, GRAVI_SINGLE_SKY_RAW};
1338 return gravi_frameset_extract (frameset, tags, 2);
1339}
1340cpl_frameset * gravi_frameset_extract_wave_data (cpl_frameset * frameset) {
1341 const char *tags[] = {GRAVI_WAVE_RAW};
1342 return gravi_frameset_extract (frameset, tags, 1);
1343}
1344cpl_frameset * gravi_frameset_extract_wavesc_data (cpl_frameset * frameset) {
1345 const char *tags[] = {GRAVI_WAVESC_RAW};
1346 return gravi_frameset_extract (frameset, tags, 1);
1347}
1348cpl_frameset * gravi_frameset_extract_dispvis_data (cpl_frameset * frameset) {
1349 const char *tags[] = {GRAVI_DISP_VIS};
1350 return gravi_frameset_extract (frameset, tags, 1);
1351}
1352cpl_frameset * gravi_frameset_extract_disp_map (cpl_frameset * frameset) {
1353 const char *tags[] = {GRAVI_DISP_MODEL};
1354 return gravi_frameset_extract (frameset, tags, 1);
1355}
1356cpl_frameset * gravi_frameset_extract_met_pos (cpl_frameset * frameset) {
1357 const char *tags[] = {GRAVI_DIODE_POSITION};
1358 return gravi_frameset_extract (frameset, tags, 1);
1359}
1360cpl_frameset * gravi_frameset_extract_wavelamp_map (cpl_frameset * frameset) {
1361 const char *tags[] = {GRAVI_WAVELAMP_MAP};
1362 return gravi_frameset_extract (frameset, tags, 1);
1363}
1364cpl_frameset * gravi_frameset_extract_wavelamp_data (cpl_frameset * frameset) {
1365 const char *tags[] = {GRAVI_WAVELAMP_RAW};
1366 return gravi_frameset_extract (frameset, tags, 1);
1367}
1368cpl_frameset * gravi_frameset_extract_tf_calib (cpl_frameset * frameset) {
1369 const char *tags[] = {GRAVI_TF_SINGLE_CALIB, GRAVI_TF_DUAL_CALIB,
1371 return gravi_frameset_extract (frameset, tags, 5);
1372}
1373cpl_frameset * gravi_frameset_extract_vis_calib (cpl_frameset * frameset) {
1374 const char *tags[] = {GRAVI_VIS_SINGLE_CALIB, GRAVI_VIS_DUAL_CALIB,
1376 return gravi_frameset_extract (frameset, tags, 4);
1377}
1378cpl_frameset * gravi_frameset_extract_vis_science (cpl_frameset * frameset) {
1379 const char *tags[] = {GRAVI_VIS_SINGLE_SCIENCE, GRAVI_VIS_DUAL_SCIENCE};
1380 return gravi_frameset_extract (frameset, tags, 2);
1381}
1382cpl_frameset * gravi_frameset_extract_science_data (cpl_frameset * frameset) {
1383 const char *tags[] = {GRAVI_DUAL_SCIENCE_RAW, GRAVI_SINGLE_SCIENCE_RAW};
1384 return gravi_frameset_extract (frameset, tags, 2);
1385}
1386cpl_frameset * gravi_frameset_extract_astro_target (cpl_frameset * frameset) {
1387 const char *tags[] = {GRAVI_ASTRO_TARGET};
1388 return gravi_frameset_extract (frameset, tags, 1);
1389}
1390cpl_frameset * gravi_frameset_extract_astro_swap (cpl_frameset * frameset) {
1391 const char *tags[] = {GRAVI_ASTRO_SWAP};
1392 return gravi_frameset_extract (frameset, tags, 1);
1393}
1394cpl_frameset * gravi_frameset_extract_astro_phaseref (cpl_frameset * frameset) {
1395 const char *tags[] = {GRAVI_ASTRO_CAL_PHASEREF};
1396 return gravi_frameset_extract (frameset, tags, 1);
1397}
1398cpl_frameset * gravi_frameset_extract_p2vm_map (cpl_frameset * frameset) {
1399 const char *tags[] = {GRAVI_P2VM_MAP};
1400 return gravi_frameset_extract (frameset, tags, 1);
1401}
1402cpl_frameset * gravi_frameset_extract_flat_map (cpl_frameset * frameset){
1403 const char *tags[] = {GRAVI_FLAT_MAP};
1404 return gravi_frameset_extract (frameset, tags, 1);
1405}
1406cpl_frameset * gravi_frameset_extract_dark_map (cpl_frameset * frameset) {
1407 const char *tags[] = {GRAVI_DARK_MAP};
1408 return gravi_frameset_extract (frameset, tags, 1);
1409}
1410cpl_frameset * gravi_frameset_extract_wave_map (cpl_frameset * frameset) {
1411 const char *tags[] = {GRAVI_WAVE_MAP};
1412 return gravi_frameset_extract (frameset, tags, 1);
1413}
1414cpl_frameset * gravi_frameset_extract_bad_map (cpl_frameset * frameset) {
1415 const char *tags[] = {GRAVI_BAD_MAP};
1416 return gravi_frameset_extract (frameset, tags, 1);
1417}
1418cpl_frameset * gravi_frameset_extract_biasmask_map (cpl_frameset * frameset) {
1419 const char *tags[] = {GRAVI_BIASMASK_MAP};
1420 return gravi_frameset_extract (frameset, tags, 1);
1421}
1422cpl_frameset * gravi_frameset_extract_eop_map (cpl_frameset * frameset) {
1423 const char *tags[] = {GRAVI_EOP_MAP};
1424 return gravi_frameset_extract (frameset, tags, 1);
1425}
1426cpl_frameset * gravi_frameset_extract_patch (cpl_frameset * frameset) {
1427 const char *tags[] = {GRAVI_KEY_PATCH};
1428 return gravi_frameset_extract (frameset, tags, 1);
1429}
1430cpl_frameset * gravi_frameset_extract_static_param (cpl_frameset * frameset) {
1431 const char *tags[] = {GRAVI_STATIC_PARAM};
1432 return gravi_frameset_extract (frameset, tags, 1);
1433}
1434cpl_frameset * gravi_frameset_extract_wave_param (cpl_frameset * frameset) {
1435 const char *tags[] = {GRAVI_WAVE_PARAM};
1436 return gravi_frameset_extract (frameset, tags, 1);
1437}
1438cpl_frameset * gravi_frameset_extract_pca_calib (cpl_frameset * frameset) {
1439 const char *tags[] = {GRAVI_PHASE_PCA};
1440 return gravi_frameset_extract (frameset, tags, 1);
1441}
1442
1443/*---------------------------------------------------------------------------*/
1444/*
1445 * Get the parameter from the list. Provide a default in case the parameter
1446 * is NOT in the list.
1447 */
1448/*---------------------------------------------------------------------------*/
1449
1450/*----------------------------------------------------------------------------*/
1461/*----------------------------------------------------------------------------*/
1462
1463double gravi_param_get_double_default (const cpl_parameterlist * parlist, const char * name, double def)
1464{
1465 const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1466
1467 if (tmp) {
1468 return cpl_parameter_get_double (tmp);
1469 } else {
1470 cpl_msg_info (cpl_func, "Could not find the parameter '%s':, use %f", name, def);
1471 return def;
1472 }
1473}
1474
1475int gravi_param_get_int_default (const cpl_parameterlist * parlist, const char * name, int def)
1476{
1477 const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1478
1479 if (tmp) {
1480 return cpl_parameter_get_int (tmp);
1481 } else {
1482 cpl_msg_info (cpl_func, "Could not find the parameter '%s': use %i", name, def);
1483 return def;
1484 }
1485}
1486
1487int gravi_param_get_bool_default (const cpl_parameterlist * parlist, const char * name, int def)
1488{
1489 const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1490
1491 if (tmp) {
1492 return cpl_parameter_get_bool (tmp);
1493 } else {
1494 cpl_msg_info (cpl_func, "Could not find the boolean parameter '%s': use %s", name, (def==0?"FALSE":"TRUE"));
1495 return def;
1496 }
1497}
1498
1499const char * gravi_param_get_string_default (const cpl_parameterlist * parlist, const char * name, const char * def)
1500{
1501 const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1502
1503 if (tmp) {
1504 return cpl_parameter_get_string (tmp);
1505 } else {
1506 cpl_msg_info (cpl_func, "Could not find the string parameter '%s': use %s", name, def);
1507 return def;
1508 }
1509}
1510
1511double gravi_param_get_double (const cpl_parameterlist * parlist, const char * name)
1512{
1513 const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1514 double def = 0.0;
1515
1516 if (tmp) {
1517 return cpl_parameter_get_double (tmp);
1518 } else {
1519 cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "Could not find the parameter '%s':, use %f", name, def);
1520 return def;
1521 }
1522}
1523
1524int gravi_param_get_int (const cpl_parameterlist * parlist, const char * name)
1525{
1526 const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1527 int def = 0;
1528
1529 if (tmp) {
1530 return cpl_parameter_get_int (tmp);
1531 } else {
1532 cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "Could not find the parameter '%s': use %i", name, def);
1533 return def;
1534 }
1535}
1536
1537int gravi_param_get_bool (const cpl_parameterlist * parlist, const char * name)
1538{
1539 const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1540 int def = 0;
1541
1542 if (tmp) {
1543 return cpl_parameter_get_bool (tmp);
1544 } else {
1545 cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "Could not find the boolean parameter '%s': use %s", name, (def==0?"FALSE":"TRUE"));
1546 return def;
1547 }
1548}
1549
1550const char * gravi_param_get_string (const cpl_parameterlist * parlist, const char * name)
1551{
1552 const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1553
1554 if (tmp) {
1555 return cpl_parameter_get_string (tmp);
1556 } else {
1557 cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "Could not find the string parameter '%s': use UNKNOWN", name);
1558 return "UNKNOWN";
1559 }
1560}
1561
1562cpl_error_code gravi_check_frameset (cpl_frameset *frameset, const char * tag, int min, int max)
1563{
1564 int flag = 0;
1565 int nf = cpl_frameset_count_tags (frameset, tag);
1566 char * msg = cpl_sprintf ("Need %i<#<%i '%s' in frameset (%i provided)", min, max, tag, nf);
1567
1568 if (nf < min || nf > max) {
1569 cpl_msg_error (cpl_func, "%s",msg);
1570 cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "%s", msg);
1571 flag ++;
1572 } else {
1573 cpl_msg_info (cpl_func, "%s", msg);
1574 }
1575
1576 cpl_free (msg);
1577 return (flag) ? CPL_ERROR_ILLEGAL_INPUT : CPL_ERROR_NONE;
1578}
1579
#define GRAVI_VISPHI_SINGLE_CALIB
Definition: gravi_dfs.h:115
#define GRAVI_EOP_MAP
Definition: gravi_dfs.h:78
#define GRAVI_P2VMRED_SINGLE_CALIB
Definition: gravi_dfs.h:63
#define GRAVI_TF_SINGLE_CALIB
Definition: gravi_dfs.h:106
#define GRAVI_DARK_RAW
Definition: gravi_dfs.h:46
#define GRAVI_SINGLE_SCIENCE_RAW
Definition: gravi_dfs.h:52
#define GRAVI_TF_DUAL_CALIB
Definition: gravi_dfs.h:111
#define GRAVI_PREPROC
Definition: gravi_dfs.h:60
#define GRAVI_PIEZOTF_MAP
Definition: gravi_dfs.h:86
#define GRAVI_SINGLE_SKY_RAW
Definition: gravi_dfs.h:56
#define GRAVI_ASTRO_TARGET
Definition: gravi_dfs.h:122
#define GRAVI_P2VM_MAP
Definition: gravi_dfs.h:76
#define GRAVI_NAB_CAL
Definition: gravi_dfs.h:82
#define GRAVI_P2VMRED_DUAL_CALIB
Definition: gravi_dfs.h:65
#define GRAVI_DIODE_POSITION
Definition: gravi_dfs.h:81
#define GRAVI_VIS_DUAL_SCIENCE
Definition: gravi_dfs.h:98
#define GRAVI_VIS_SINGLE_SCIENCE
Definition: gravi_dfs.h:96
#define GRAVI_KEY_PATCH
Definition: gravi_dfs.h:68
#define GRAVI_MIRA_OUTPUT_PROCATG
Definition: gravi_dfs.h:130
#define GRAVI_DISP_RAW
Definition: gravi_dfs.h:45
#define GRAVI_BAD_MAP
Definition: gravi_dfs.h:73
#define GRAVI_DUAL_CALIB_RAW
Definition: gravi_dfs.h:53
#define GRAVI_WAVE_RAW
Definition: gravi_dfs.h:47
#define GRAVI_BIASMASK_MAP
Definition: gravi_dfs.h:84
#define GRAVI_P2VMRED_SINGLE_SCIENCE
Definition: gravi_dfs.h:64
#define GRAVI_WAVE_MAP
Definition: gravi_dfs.h:75
#define GRAVI_ZP_CAL
Definition: gravi_dfs.h:128
#define GRAVI_DISP_MODEL
Definition: gravi_dfs.h:79
#define GRAVI_DUAL_SKY_RAW
Definition: gravi_dfs.h:55
#define GRAVI_FLAT_MAP
Definition: gravi_dfs.h:74
#define GRAVI_WAVE_PARAM
Definition: gravi_dfs.h:70
#define GRAVI_WAVELAMP_MAP
Definition: gravi_dfs.h:85
#define GRAVI_PIEZOTF_RAW
Definition: gravi_dfs.h:43
#define GRAVI_DIAMETER_CAT
Definition: gravi_dfs.h:80
#define GRAVI_DARK_MAP
Definition: gravi_dfs.h:77
#define GRAVI_STATIC_PARAM
Definition: gravi_dfs.h:69
#define GRAVI_P2VM_RAW
Definition: gravi_dfs.h:44
#define GRAVI_SINGLE_CALIB_RAW
Definition: gravi_dfs.h:51
#define GRAVI_VIS_DUAL_CALIB
Definition: gravi_dfs.h:99
#define GRAVI_ASTRO_SWAP
Definition: gravi_dfs.h:123
#define GRAVI_DUAL_SCIENCE_RAW
Definition: gravi_dfs.h:54
#define GRAVI_VIS_SINGLE_CALIBRATED
Definition: gravi_dfs.h:101
#define GRAVI_MIRA_INPUT_PROCATG
Definition: gravi_dfs.h:129
#define GRAVI_VIS_SINGLE_CALIB
Definition: gravi_dfs.h:97
#define GRAVI_TF_DUAL_SCIENCE
Definition: gravi_dfs.h:110
#define GRAVI_FLAT_RAW
Definition: gravi_dfs.h:50
#define GRAVI_TF_SINGLE_SCIENCE
Definition: gravi_dfs.h:107
#define GRAVI_PHASE_PCA
Definition: gravi_dfs.h:87
#define GRAVI_ASTRO_CAL_PHASEREF
Definition: gravi_dfs.h:124
#define GRAVI_WAVELAMP_RAW
Definition: gravi_dfs.h:49
#define GRAVI_P2VMRED_DUAL_SCIENCE
Definition: gravi_dfs.h:66
#define GRAVI_VISPHI_DUAL_CALIB
Definition: gravi_dfs.h:116
#define GRAVI_DISP_VIS
Definition: gravi_dfs.h:59
#define GRAVI_VISPHI_TF_DUAL_CALIB
Definition: gravi_dfs.h:118
#define GRAVI_WAVESC_RAW
Definition: gravi_dfs.h:48
#define GRAVI_VIS_DUAL_CALIBRATED
Definition: gravi_dfs.h:102
#define GRAVI_VISPHI_TF_SINGLE_CALIB
Definition: gravi_dfs.h:117
cpl_msg_info(cpl_func, "Compute WAVE_SCAN for %s", GRAVI_TYPE(type_data))
cpl_parameter * gravi_parameter_add_debug_file(cpl_parameterlist *self)
Definition: gravi_dfs.c:479
cpl_frameset * gravi_frameset_extract_wavesc_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1344
cpl_frameset * gravi_frameset_extract_met_pos(cpl_frameset *frameset)
Definition: gravi_dfs.c:1356
cpl_parameter * gravi_parameter_add_astro_file(cpl_parameterlist *self)
Definition: gravi_dfs.c:569
cpl_frameset * gravi_frameset_extract_vis_calib(cpl_frameset *frameset)
Definition: gravi_dfs.c:1373
cpl_parameter * gravi_parameter_add_profile(cpl_parameterlist *self)
Add profile parameters to the input parameter list.
Definition: gravi_dfs.c:346
int gravi_param_get_bool(const cpl_parameterlist *parlist, const char *name)
Definition: gravi_dfs.c:1537
cpl_parameter * gravi_parameter_add_static_name(cpl_parameterlist *self)
Definition: gravi_dfs.c:464
cpl_error_code gravi_parameter_add_astrometry(cpl_parameterlist *self)
Definition: gravi_dfs.c:1069
cpl_parameter * gravi_parameter_add_p2vmred_file(cpl_parameterlist *self)
Definition: gravi_dfs.c:539
cpl_parameter * gravi_parameter_add_metrology(cpl_parameterlist *self)
Definition: gravi_dfs.c:615
cpl_error_code gravi_parameter_add_rejection(cpl_parameterlist *self, int isCalib)
Add rejection parameters to the input parameter list.
Definition: gravi_dfs.c:864
cpl_frameset * gravi_frameset_extract_vis_science(cpl_frameset *frameset)
Definition: gravi_dfs.c:1378
cpl_frameset * gravi_frameset_extract_fringe_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1323
cpl_parameter * gravi_parameter_copy_fluxdata(cpl_parameterlist *self)
Definition: gravi_dfs.c:729
int gravi_param_get_bool_default(const cpl_parameterlist *parlist, const char *name, int def)
Definition: gravi_dfs.c:1487
cpl_error_code gravi_parameter_add_image(cpl_parameterlist *self)
Definition: gravi_dfs.c:1173
cpl_error_code gravi_parameter_add_compute_snr(cpl_parameterlist *self)
Definition: gravi_dfs.c:779
cpl_parameter * gravi_parameter_add_pcacalib(cpl_parameterlist *self)
Add pca calibration parameters to the input parameter list.
Definition: gravi_dfs.c:247
cpl_parameter * gravi_parameter_add_extract(cpl_parameterlist *self)
Definition: gravi_dfs.c:686
cpl_parameter * gravi_parameter_add_biasmethod(cpl_parameterlist *self)
Definition: gravi_dfs.c:584
cpl_frameset * gravi_frameset_extract_patch(cpl_frameset *frameset)
Definition: gravi_dfs.c:1426
cpl_frameset * gravi_frameset_extract_astro_target(cpl_frameset *frameset)
Definition: gravi_dfs.c:1386
cpl_parameter * gravi_parameter_add_vis_file(cpl_parameterlist *self)
Definition: gravi_dfs.c:554
cpl_parameter * gravi_parameter_add_average_vis(cpl_parameterlist *self)
Definition: gravi_dfs.c:714
cpl_frameset * gravi_frameset_extract_wave_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1410
const char * gravi_param_get_string(const cpl_parameterlist *parlist, const char *name)
Definition: gravi_dfs.c:1550
cpl_frameset * gravi_frameset_extract_astro_swap(cpl_frameset *frameset)
Definition: gravi_dfs.c:1390
cpl_frameset * gravi_frameset_extract_disp_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1297
cpl_frameset * gravi_frameset_extract_dispvis_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1348
cpl_parameter * gravi_parameter_add_wave(cpl_parameterlist *self)
Add wavelength calibration parameters to the input parameter list.
Definition: gravi_dfs.c:423
cpl_frameset * gravi_frameset_extract_bad_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1414
cpl_parameter * gravi_parameter_add_pca(cpl_parameterlist *self)
Add pca parameters to the input parameter list.
Definition: gravi_dfs.c:324
cpl_error_code gravi_parameter_disable(cpl_parameter *p)
Disable a parameter.
Definition: gravi_dfs.c:176
cpl_frameset * gravi_frameset_extract_piezotf_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1332
cpl_frameset * gravi_frameset_extract_tf_calib(cpl_frameset *frameset)
Definition: gravi_dfs.c:1368
cpl_error_code gravi_check_frameset(cpl_frameset *frameset, const char *tag, int min, int max)
Definition: gravi_dfs.c:1562
cpl_frameset * gravi_frameset_extract_science_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1382
cpl_frameset * gravi_frameset_extract_flat_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1315
cpl_parameter * gravi_parameter_add_spectrum_file(cpl_parameterlist *self)
Definition: gravi_dfs.c:509
cpl_frameset * gravi_frameset_extract(cpl_frameset *frameset, const char **frame_tags, int nb_tags)
Extract a list of tags from a frameset.
Definition: gravi_dfs.c:1253
int gravi_param_get_int(const cpl_parameterlist *parlist, const char *name)
Definition: gravi_dfs.c:1524
cpl_frameset * gravi_frameset_extract_pca_calib(cpl_frameset *frameset)
Definition: gravi_dfs.c:1438
cpl_frameset * gravi_frameset_extract_biasmask_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1418
cpl_frameset * gravi_frameset_extract_wave_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1340
cpl_parameter * gravi_parameter_add_preproc(cpl_parameterlist *self)
Add preprocessing parameters to the input parameter list.
Definition: gravi_dfs.c:397
cpl_parameter * gravi_parameter_add_force_uncertainties(cpl_parameterlist *self)
Definition: gravi_dfs.c:743
int gravi_param_get_int_default(const cpl_parameterlist *parlist, const char *name, int def)
Definition: gravi_dfs.c:1475
cpl_frameset * gravi_frameset_extract_dark_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1406
cpl_frameset * gravi_frameset_extract_p2vm_data(cpl_frameset *frameset)
Extract P2VM_RAW frame from the input frameset.
Definition: gravi_dfs.c:1293
const char * gravi_param_get_string_default(const cpl_parameterlist *parlist, const char *name, const char *def)
Definition: gravi_dfs.c:1499
cpl_frameset * gravi_frameset_extract_wavelamp_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1360
cpl_error_code gravi_dfs_set_groups(cpl_frameset *set)
Set the group as RAW or CALIB in a frameset.
Definition: gravi_dfs.c:78
cpl_parameter * gravi_parameter_add_preproc_file(cpl_parameterlist *self)
Definition: gravi_dfs.c:524
cpl_frameset * gravi_frameset_extract_p2vmred_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1327
cpl_frameset * gravi_frameset_extract_p2vm_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1398
cpl_frameset * gravi_frameset_extract_sky_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1336
cpl_parameter * gravi_parameter_add_badpix(cpl_parameterlist *self)
Add badpix parameters to the input parameter list.
Definition: gravi_dfs.c:194
cpl_frameset * gravi_frameset_extract_static_param(cpl_frameset *frameset)
Definition: gravi_dfs.c:1430
cpl_frameset * gravi_frameset_extract_wave_param(cpl_frameset *frameset)
Definition: gravi_dfs.c:1434
double gravi_param_get_double(const cpl_parameterlist *parlist, const char *name)
Definition: gravi_dfs.c:1511
cpl_error_code gravi_parameter_add_compute_vis(cpl_parameterlist *self, int isCalib)
Definition: gravi_dfs.c:943
cpl_frameset * gravi_frameset_extract_wavelamp_data(cpl_frameset *frameset)
Definition: gravi_dfs.c:1364
cpl_parameter * gravi_parameter_add_biassub_file(cpl_parameterlist *self)
Definition: gravi_dfs.c:494
cpl_frameset * gravi_frameset_extract_astro_phaseref(cpl_frameset *frameset)
Definition: gravi_dfs.c:1394
cpl_frameset * gravi_frameset_extract_flat_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1402
cpl_frameset * gravi_frameset_extract_eop_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1422
cpl_frameset * gravi_frameset_extract_diamcat_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1319
cpl_frameset * gravi_frameset_extract_disp_map(cpl_frameset *frameset)
Definition: gravi_dfs.c:1352
void gravity_print_banner(void)
Definition: gravi_dfs.c:61
cpl_frameset * gravi_frameset_extract_dark_data(cpl_frameset *frameset)
Extract DARK_RAW frame from the input frameset.
Definition: gravi_dfs.c:1311
cpl_error_code gravi_parameter_add_compute_signal(cpl_parameterlist *self)
Definition: gravi_dfs.c:818
double gravi_param_get_double_default(const cpl_parameterlist *parlist, const char *name, double def)
Get the parameter from the parameter list.
Definition: gravi_dfs.c:1463