GRAVI Pipeline Reference Manual  1.2.3
gravi_dfs.c
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 
61 void gravity_print_banner (void)
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 
78 cpl_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_VIS_SINGLE_SCIENCE)) ||
110  (!strcmp(tag, GRAVI_VIS_DUAL_CALIB)) ||
111  (!strcmp(tag, GRAVI_VIS_DUAL_SCIENCE)) ||
112  (!strcmp(tag, GRAVI_P2VMRED_SINGLE_CALIB)) ||
113  (!strcmp(tag, GRAVI_P2VMRED_SINGLE_SCIENCE)) ||
114  (!strcmp(tag, GRAVI_P2VMRED_DUAL_CALIB)) ||
115  (!strcmp(tag, GRAVI_P2VMRED_DUAL_SCIENCE)) ||
116  (!strcmp(tag, GRAVI_MIRA_INPUT_PROCATG))||
117  (!strcmp(tag, GRAVI_VIS_SINGLE_CALIBRATED)) ||
118  (!strcmp(tag, GRAVI_VIS_DUAL_CALIBRATED)) ||
119  (!strcmp(tag, GRAVI_DISP_RAW)) ){
120  /* RAW frames */
121  cpl_frame_set_group(frame, CPL_FRAME_GROUP_RAW);
122  }else if ((!strcmp(tag, GRAVI_DARK_MAP)) ||
123  (!strcmp(tag, GRAVI_FLAT_MAP)) ||
124  (!strcmp(tag, GRAVI_WAVE_MAP)) ||
125  (!strcmp(tag, GRAVI_P2VM_MAP)) ||
126  (!strcmp(tag, GRAVI_BAD_MAP)) ||
127  (!strcmp(tag, GRAVI_BIASMASK_MAP)) ||
128  (!strcmp(tag, GRAVI_PIEZOTF_MAP)) ||
129  (!strcmp(tag, GRAVI_PREPROC)) ||
130  (!strcmp(tag, GRAVI_TF_SINGLE_SCIENCE)) ||
131  (!strcmp(tag, GRAVI_TF_SINGLE_CALIB)) ||
132  (!strcmp(tag, GRAVI_WAVELAMP_MAP)) ||
133  (!strcmp(tag, GRAVI_TF_DUAL_SCIENCE)) ||
134  (!strcmp(tag, GRAVI_TF_DUAL_CALIB)) ||
135  (!strcmp(tag, GRAVI_ZP_CAL)) ||
136  (!strcmp(tag, GRAVI_DISP_VIS)) ||
137  (!strcmp(tag, GRAVI_DIAMETER_CAT)) ||
138  (!strcmp(tag, GRAVI_DISP_MODEL)) ||
139  (!strcmp(tag, GRAVI_DIODE_POSITION))||
140  (!strcmp(tag, GRAVI_KEY_PATCH))){
141  /* CALIB frames */
142  cpl_frame_set_group(frame, CPL_FRAME_GROUP_CALIB);
143  }else if (
144  (!strcmp(tag, GRAVI_MIRA_OUTPUT_PROCATG)) ||
145  (!strcmp(tag, GRAVI_NAB_CAL)) ){
146  /* PRODUCT frames */
147  cpl_frame_set_group(frame, CPL_FRAME_GROUP_PRODUCT);
148  }
149 
150  }
151 
152  if (!cpl_errorstate_is_equal(prestate)) {
153  return cpl_error_set_message(cpl_func, cpl_error_get_code(),
154  "Could not identify RAW and CALIB "
155  "frames");
156  }
157 
158  return CPL_ERROR_NONE;
159 }
160 /*----------------------------------------------------------------------------*/
167 /*----------------------------------------------------------------------------*/
168 
169 cpl_error_code gravi_parameter_disable (cpl_parameter * p)
170 {
171  cpl_ensure_code (p, CPL_ERROR_NULL_INPUT);
172  cpl_parameter_disable (p, CPL_PARAMETER_MODE_CLI);
173  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
174  cpl_parameter_disable (p, CPL_PARAMETER_MODE_CFG);
175  return CPL_ERROR_NONE;
176 }
177 
178 /*----------------------------------------------------------------------------*/
185 /*----------------------------------------------------------------------------*/
186 
187 cpl_parameter * gravi_parameter_add_badpix (cpl_parameterlist *self)
188 {
189  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
190 
191  cpl_parameter *p;
192  p = cpl_parameter_new_value ("gravity.calib.bad-dark-threshold", CPL_TYPE_INT,
193  "the rms factor for "
194  "dark bad pixel threshold",
195  "gravity.calib", 10);
196  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "bad-dark-threshold");
197  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
198  cpl_parameterlist_append (self, p);
199 
200  return p;
201 }
202 
203 /*----------------------------------------------------------------------------*/
210 /*----------------------------------------------------------------------------*/
211 
212 cpl_parameter * gravi_parameter_add_profile (cpl_parameterlist *self)
213 {
214  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
215 
216  cpl_parameter *p;
217 
218  /* Method for profile */
219  p = cpl_parameter_new_enum ("gravity.calib.profile-mode", CPL_TYPE_STRING,
220  "Method to compute the extraction profile. "
221  "PROFILE corresponds to the pixel intensities measured in the "
222  "FLAT files (Gaussian like with FWHM of approx 1.5 pixel). "
223  "This is the AUTO option for the Low and Med spectral resolution. "
224  "GAUSS corresponds to a Gaussian fit of the (non-zero) pixel intensities measured "
225  "in the FLAT files. BOX corresponds to a box-card of 6 pixels centered "
226  "on the spectra measured in the FLAT files. This is the AUTO option for High "
227  "spectral resolution",
228  "gravity.calib", "AUTO",
229  4, "AUTO", "PROFILE", "GAUSS", "BOX");
230  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "profile-mode");
231  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
232  cpl_parameterlist_append (self, p);
233 
234  /* How to deal with bad-pixels */
235  p = cpl_parameter_new_value ("gravity.calib.force-badpix-to-zero", CPL_TYPE_BOOL,
236  "Force the badpixel to zero in profile",
237  "gravity.calib", TRUE);
238  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "force-badpix-to-zero");
239  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
240  cpl_parameterlist_append (self, p);
241 
242  /* The width of the profile element */
243  p = cpl_parameter_new_value ("gravity.calib.profile-width", CPL_TYPE_INT,
244  "Width of the detector window extracted around the default "
245  "position of each spectrum, and on which the profile "
246  "will be applied to perform the extraction.",
247  "gravity.calib", 6);
248  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "profile-width");
249  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
250  cpl_parameterlist_append (self, p);
251 
252 
253  return p;
254 }
255 
256 /*----------------------------------------------------------------------------*/
263 /*----------------------------------------------------------------------------*/
264 cpl_parameter * gravi_parameter_add_preproc (cpl_parameterlist *self)
265 {
266  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
267 
268  cpl_parameter *p = NULL;
269 
270  /* Method for interpolation */
271 // p = cpl_parameter_new_value ("gravity.preproc.interp-3pixels", CPL_TYPE_BOOL,
272 // "Interpolate with 3 pixels",
273 // "gravity.calib", FALSE);
274 // cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "interp-3pixels");
275 // cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
276 // cpl_parameterlist_append (self, p);
277 
278  return p;
279 }
280 
281 
282 /*----------------------------------------------------------------------------*/
289 /*----------------------------------------------------------------------------*/
290 cpl_parameter * gravi_parameter_add_wave (cpl_parameterlist *self)
291 {
292  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
293 
294  cpl_parameter *p;
295 
296  /* Method for profile */
297  p = cpl_parameter_new_value ("gravity.calib.force-wave-ft-equal", CPL_TYPE_BOOL,
298  "Force the spatial order of the wavelength 2D fit for FT to "
299  "zero (so all region share the same calibration). "
300  "This is used to build the P2VM calibration of the TAC "
301  "real-time code running on the instrument ifself.",
302  "gravity.calib", FALSE);
303  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "force-wave-ft-equal");
304  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
305  cpl_parameterlist_append (self, p);
306 
307  /* Spectral order of 2D wave fit */
308 // p = cpl_parameter_new_value ("gravity.calib.wave-spectral-order", CPL_TYPE_INT,
309 // "Set the spatial order of the wavelength 2D fit for SC.",
310 // "gravity.calib", 3);
311 // cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "wave-spectral-order");
312 // cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
313 // cpl_parameterlist_append (self, p);
314 
315  /* Wave determination */
316 // p = cpl_parameter_new_enum ("gravity.calib.wave-mode", CPL_TYPE_STRING,
317 // "Define the way the wavelength are computed.\n "
318 // "PIXEL to compute the wavelength per pixels\n "
319 // "BASELINE to compute the wavelength per baseline (ABCD)\n "
320 // "AUTO to compute the wavelength per pixels in LOW, and per baseline otherwise",
321 // "gravity.calib", "AUTO", 3,
322 // "PIXEL","BASELINE","AUTO");
323 // cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "wave-mode");
324 // cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
325 // cpl_parameterlist_append (self, p);
326 
327  return p;
328 }
329 
330 
331 cpl_parameter * gravi_parameter_add_static_name (cpl_parameterlist *self)
332 {
333  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
334 
335  cpl_parameter *p;
336  p = cpl_parameter_new_value ("gravity.dfs.static-name", CPL_TYPE_BOOL,
337  "Use static names for the products (for ESO)",
338  "gravity.dfs", FALSE);
339  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "static-name");
340  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
341  cpl_parameterlist_append (self, p);
342 
343  return p;
344 }
345 
346 cpl_parameter * gravi_parameter_add_debug_file (cpl_parameterlist *self)
347 {
348  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
349 
350  cpl_parameter *p;
351  p = cpl_parameter_new_value ("gravity.dfs.debug-file", CPL_TYPE_BOOL,
352  "Save additional debug file(s)",
353  "gravity.dfs", FALSE);
354  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "debug-file");
355  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
356  cpl_parameterlist_append (self, p);
357 
358  return p;
359 }
360 
361 cpl_parameter * gravi_parameter_add_biassub_file (cpl_parameterlist *self)
362 {
363  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
364 
365  cpl_parameter *p;
366  p = cpl_parameter_new_value ("gravity.dfs.bias-subtracted-file", CPL_TYPE_BOOL,
367  "Save the BIAS_SUBTRACTED intermediate product",
368  "gravity.dfs", FALSE);
369  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "bias-subtracted-file");
370  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
371  cpl_parameterlist_append (self, p);
372 
373  return p;
374 }
375 
376 cpl_parameter * gravi_parameter_add_spectrum_file (cpl_parameterlist *self)
377 {
378  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
379 
380  cpl_parameter *p;
381  p = cpl_parameter_new_value ("gravity.dfs.spectrum-file", CPL_TYPE_BOOL,
382  "Save the SPECTRUM intermediate product",
383  "gravity.dfs", FALSE);
384  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "spectrum-file");
385  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
386  cpl_parameterlist_append (self, p);
387 
388  return p;
389 }
390 
391 cpl_parameter * gravi_parameter_add_preproc_file (cpl_parameterlist *self)
392 {
393  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
394 
395  cpl_parameter *p;
396  p = cpl_parameter_new_value ("gravity.dfs.preproc-file", CPL_TYPE_BOOL,
397  "Save the PREPROC intermediate product",
398  "gravity.dfs", FALSE);
399  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "preproc-file");
400  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
401  cpl_parameterlist_append (self, p);
402 
403  return p;
404 }
405 
406 cpl_parameter * gravi_parameter_add_p2vmred_file (cpl_parameterlist *self)
407 {
408  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
409 
410  cpl_parameter *p;
411  p = cpl_parameter_new_value ("gravity.dfs.p2vmred-file", CPL_TYPE_BOOL,
412  "Save the P2VMRED intermediate product",
413  "gravity.dfs", FALSE);
414  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "p2vmreduced-file");
415  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
416  cpl_parameterlist_append (self, p);
417 
418  return p;
419 }
420 
421 cpl_parameter * gravi_parameter_add_vis_file (cpl_parameterlist *self)
422 {
423  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
424 
425  cpl_parameter *p;
426  p = cpl_parameter_new_value ("gravity.dfs.vis-file", CPL_TYPE_BOOL,
427  "Save the VIS intermediate product",
428  "gravity.dfs", FALSE);
429  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vis-file");
430  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
431  cpl_parameterlist_append (self, p);
432 
433  return p;
434 }
435 
436 cpl_parameter * gravi_parameter_add_astro_file (cpl_parameterlist *self)
437 {
438  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
439 
440  cpl_parameter *p;
441  p = cpl_parameter_new_value ("gravity.dfs.astro-file", CPL_TYPE_BOOL,
442  "Save the ASTROREDUCED intermediate product",
443  "gravity.dfs", FALSE);
444  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "astro-file");
445  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
446  cpl_parameterlist_append (self, p);
447 
448  return p;
449 }
450 
451 cpl_parameter * gravi_parameter_add_biasmethod (cpl_parameterlist *self)
452 {
453  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
454 
455  cpl_parameter *p;
456  p = cpl_parameter_new_enum ("gravity.preproc.bias-method", CPL_TYPE_STRING,
457  "Method to average the biaspixels when cleaning-up\n "
458  "the SC detector (only applied to MED and LOW). Ideally\n "
459  "the same value shall be used when reducing the DARK\n "
460  "with gravity_dark and the OBJECT with gravity_vis.",
461  "gravity.preproc", "MEDIAN",
462  2, "MEDIAN", "MEDIAN_PER_COLUMN");
463  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "bias-method");
464  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
465  cpl_parameterlist_append (self, p);
466 
467  return p;
468 }
469 
470 cpl_parameter * gravi_parameter_add_metrology (cpl_parameterlist *self)
471 {
472  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
473 
474  cpl_parameter *p;
475  p = cpl_parameter_new_value ("gravity.metrology.acq-correction-delay",
476  CPL_TYPE_DOUBLE,
477  "Delay between the end of ACQ frame and correction\n "
478  "offset seen by the metrology diodes, in seconds.",
479  "gravity.metrology", 0.1);
480  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "acq-correction-delay");
481  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
482  cpl_parameterlist_append (self, p);
483 
484  return p;
485 }
486 
487 cpl_parameter * gravi_parameter_add_extract (cpl_parameterlist *self)
488 {
489  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
490 
491  cpl_parameter *p;
492  p = cpl_parameter_new_value ("gravity.preproc.ditshift-sc", CPL_TYPE_INT,
493  "Shift the time of SC DITs by an integer value to\n "
494  "account for lost frames in exposure (issue on the\n "
495  "instrument side, report to instrument team). The\n "
496  "time of all DITs in exposure are increased by\n "
497  "ditshift x PERIOD. ditshift can be 0,\n "
498  "positive (system has lost one SC DIT), or negative "
499  "(SC desynchronized).",
500  "gravity.preproc",0);
501  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "ditshift-sc");
502  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
503  cpl_parameterlist_append (self, p);
504 
505  return p;
506 }
507 
508 cpl_parameter * gravi_parameter_add_average_vis (cpl_parameterlist *self)
509 {
510  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
511  cpl_parameter *p;
512  p = cpl_parameter_new_value ("gravity.postprocess.average-vis", CPL_TYPE_BOOL,
513  "Average the results from the different input files (if any)\n "
514  "in the output product, instead of simply appending them.",
515  "gravity.postprocess", FALSE);
516  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "average-vis");
517  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
518  cpl_parameterlist_append (self, p);
519 
520  return p;
521 }
522 
523 cpl_parameter * gravi_parameter_add_force_uncertainties (cpl_parameterlist *self)
524 {
525  cpl_ensure (self, CPL_ERROR_NULL_INPUT, NULL);
526 
527  cpl_parameter *p;
528  p = cpl_parameter_new_value ("gravity.postprocess.fluxerr-sc", CPL_TYPE_DOUBLE,
529  "Force the uncertainty in FLUX of SC",
530  "gravity.postprocess", 0.0);
531  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "fluxerr-sc");
532  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
533  cpl_parameterlist_append (self, p);
534 
535  p = cpl_parameter_new_value ("gravity.postprocess.visamperr-sc", CPL_TYPE_DOUBLE,
536  "Force the uncertainty in VISAMP of SC",
537  "gravity.postprocess", 0.0);
538  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "visamperr-sc");
539  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
540  cpl_parameterlist_append (self, p);
541 
542  p = cpl_parameter_new_value ("gravity.postprocess.visphierr-sc", CPL_TYPE_DOUBLE,
543  "Force the uncertainty in VISPHI of SC",
544  "gravity.postprocess", 0.0);
545  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "visphierr-sc");
546  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
547  cpl_parameterlist_append (self, p);
548 
549  p = cpl_parameter_new_value ("gravity.postprocess.vis2err-sc", CPL_TYPE_DOUBLE,
550  "Force the uncertainty in VIS2 of SC",
551  "gravity.postprocess", 0.0);
552  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vis2err-sc");
553  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
554  cpl_parameterlist_append (self, p);
555 
556  return p;
557 }
558 
559 cpl_error_code gravi_parameter_add_compute_snr (cpl_parameterlist *self, int isCalib)
560 {
561  cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
562  cpl_parameter *p;
563 
564  /* Number of FT samples to average to compute SNR and GDELAY */
565  p = cpl_parameter_new_value ("gravity.signal.nsmooth-snr-ft", CPL_TYPE_INT,
566  "Number of samples to average coherently when computing\n "
567  "the real-time SNR and GDELAY of the FT (shall correspond\n "
568  "to the atmospheric coherence time). The integration\n "
569  "window runs from -nsmooth -> +nsmooth.",
570  "gravity.signal", 5);
571  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "nsmooth-snr-ft");
572  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
573  cpl_parameterlist_append (self, p);
574 
575  return CPL_ERROR_NONE;
576 }
577 
578 cpl_error_code gravi_parameter_add_compute_signal (cpl_parameterlist *self, int isCalib)
579 {
580  cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
581  return CPL_ERROR_NONE;
582 }
583 
584 /*----------------------------------------------------------------------------*/
592 /*----------------------------------------------------------------------------*/
593 cpl_error_code gravi_parameter_add_rejection (cpl_parameterlist *self, int isCalib)
594 {
595  cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
596 
597  cpl_parameter *p;
598  p = cpl_parameter_new_value ("gravity.signal.snr-min-ft", CPL_TYPE_DOUBLE,
599  "SNR threshold to accept FT frames (>0). It raises the first bit (<<0)\n "
600  "of column REJECTION_FLAG of FT.",
601  "gravity.signal", isCalib ? 30.0 : 3.0);
602  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "snr-min-ft");
603  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
604  cpl_parameterlist_append (self, p);
605 
606  /* OPDC_STATE threshold for fringe DET in FT */
607  p = cpl_parameter_new_value ("gravity.signal.global-state-min-ft", CPL_TYPE_DOUBLE,
608  "Minimum OPDC state to accept FT frames (>=0) It raises the second bit\n "
609  "(<<1) of column REJECTION_FLAG of FT.",
610  "gravity.signal", 2.0);
611  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "global-state-min-ft");
612  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
613  cpl_parameterlist_append (self, p);
614 
615  p = cpl_parameter_new_value ("gravity.signal.global-state-max-ft", CPL_TYPE_DOUBLE,
616  "Maximum OPDC state to accept FT frames (>=0) It raises the second bit\n "
617  "(<<1) of column REJECTION_FLAG of FT.",
618  "gravity.signal", 4.0);
619  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "global-state-max-ft");
620  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
621  cpl_parameterlist_append (self, p);
622 
623  /* STATE threshold for fringe DET in FT */
624  p = cpl_parameter_new_value ("gravity.signal.state-min-ft", CPL_TYPE_DOUBLE,
625  "Minimum OPDC state per baseline to accept FT frames (>=0) It raises\n "
626  "the second bit (<<1) of column REJECTION_FLAG of FT.",
627  "gravity.signal", 1.0);
628  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "state-min-ft");
629  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
630  cpl_parameterlist_append (self, p);
631 
632  /* Minimum detection ratio to accept SC frame */
633  p = cpl_parameter_new_value ("gravity.signal.tracking-min-sc", CPL_TYPE_DOUBLE,
634  "Minimum ratio of accepted FT frames in order to accept a SC frames (0..1),\n "
635  "that is, for each SC DIT, the fraction of the time the\n "
636  "REJECTION_FLAG of the FT is not 0.\n "
637  "It raises the first bit (<<0) of column REJECTION_FLAG of SC",
638  "gravity.signal", 0.8);
639  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "tracking-min-sc");
640  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
641  cpl_parameterlist_append (self, p);
642 
643  /* vFactor threshold to accept SC frame */
644  p = cpl_parameter_new_value ("gravity.signal.vfactor-min-sc", CPL_TYPE_DOUBLE,
645  "vFactor threshold to accept SC frame (0..1).\n ",
646  "It raises the second bit (<<1) of column REJECTION_FLAG of SC",
647  "gravity.signal", isCalib ? 0.8 : 0.1);
648  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vfactor-min-sc");
649  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
650  cpl_parameterlist_append (self, p);
651 
652  /* Flag to activate metrology zero calculation */
653  p = cpl_parameter_new_value ("gravity.signal.use-met-zero", CPL_TYPE_BOOL,
654  "Flag to activate metrology zero calculation in OPD_DISP.\n "
655  "If disabled all metrology zeroes are set to zero.",
656  "gravity.signal", TRUE);
657  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "use-met-zero");
658  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
659  cpl_parameterlist_append (self, p);
660 
661  /* Flag to control the use of metrology in IMAGING_REF calculation */
662  p = cpl_parameter_new_enum ("gravity.signal.imaging-ref-met", CPL_TYPE_STRING,
663  "Metrology source used for IMAGING_REF calculation:\n "
664  "Use fibre coupler metrology (FC);\n "
665  "Use fibre coupler metrology corrected from pupil motion (FC_CORR);\n "
666  "Use telescope metrology (TEL).",
667  "gravity.signal", "FC", 3,
668  "FC", "FC_CORR", "TEL");
669  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "imaging-ref-met");
670  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
671  cpl_parameterlist_append (self, p);
672 
673  return CPL_ERROR_NONE;
674 }
675 
676 cpl_error_code gravi_parameter_add_compute_vis (cpl_parameterlist *self, int isCalib)
677 {
678  cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
679  cpl_parameter *p;
680 
681  /* Max-frame */
682  p = cpl_parameter_new_value ("gravity.vis.max-frame", CPL_TYPE_INT,
683  "Maximum number of frames to integrate \n "
684  "coherently into an OIFITS entry",
685  "gravity.vis", 10000);
686  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "max-frame");
687  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
688  cpl_parameterlist_append (self, p);
689 
690  /* Force same time for all baselines */
691  p = cpl_parameter_new_value ("gravity.vis.force-same-time", CPL_TYPE_BOOL,
692  "Force all baseline/quantities to have\n "
693  "strictly the same TIME and MJD columns",
694  "gravity.vis", FALSE);
695  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "force-same-time");
696  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
697  cpl_parameterlist_append (self, p);
698 
699  /* Debias SC VIS2 */
700  p = cpl_parameter_new_value ("gravity.vis.debias-sc", CPL_TYPE_BOOL,
701  "Subtract the V2 bias from SC",
702  "gravity.vis", TRUE);
703  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "debias-sc");
704  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
705  cpl_parameterlist_append (self, p);
706 
707  /* Debias FT VIS2 */
708  p = cpl_parameter_new_value ("gravity.vis.debias-ft", CPL_TYPE_BOOL,
709  "Subtract the V2 bias from FT",
710  "gravity.vis", TRUE);
711  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "debias-ft");
712  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
713  cpl_parameterlist_append (self, p);
714 
715  /* Number of bootstrap */
716  p = cpl_parameter_new_value ("gravity.vis.nboot", CPL_TYPE_INT,
717  "Number of bootstraps to compute error (1..100)",
718  "gravity.vis", isCalib ? 1 : 20);
719  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "nboot");
720  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
721  cpl_parameterlist_append (self, p);
722 
723  /* Visibility correction */
724  p = cpl_parameter_new_enum ("gravity.vis.vis-correction-sc", CPL_TYPE_STRING,
725  "Correction of SC visibility from losses due to long integration,\n "
726  "using the measured visibility losses with the FT (VFACTOR\n "
727  "and/or PFACTOR) or by forcing\n "
728  "the SC visibilities to match those of the FT (FORCE). Possible\n "
729  "choices are:",
730  "gravity.vis",
731  isCalib ? "NONE" : "VFACTOR", 5, "VFACTOR", "PFACTOR",
732  "VFACTOR_PFACTOR","FORCE", "NONE");
733  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "vis-correction-sc");
734  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
735  cpl_parameterlist_append (self, p);
736 
737  /* Phase referencing */
738  p = cpl_parameter_new_enum ("gravity.vis.phase-ref-sc", CPL_TYPE_STRING,
739  "Reference phase used to integrate the SC frames.\n "
740  "Use a self-estimate of the phase, fitted by poly. (SELF_REF)\n "
741  "Use the FT phase only, interpolated in lbd (PHASE_REF)\n "
742  "Use the FT+MET-SEP.UV phase (IMAGING_REF).",
743  "gravity.vis", "AUTO", 5,
744  "SELF_REF","PHASE_REF","IMAGING_REF","AUTO","NONE");
745  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "phase-ref-sc");
746  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
747  cpl_parameterlist_append (self, p);
748 
749  /* Phase cleaning in the final OIFITS */
750  p = cpl_parameter_new_enum ("gravity.vis.output-phase-sc", CPL_TYPE_STRING,
751  "With DIFFERENTIAL, the mean group-delay and mean\n "
752  "phases are removed from the output VISPHI in the\n "
753  "final OIFITS file. With ABSOLUTE, the VISPHI is\n "
754  "kept unmodified. With SELF_VISPHI, the internal differential\n"
755  "phase between each spectral channel and a common \n"
756  "reference channel is computed.\n",
757  "gravity.vis", "AUTO", 4,
758  "DIFFERENTIAL","ABSOLUTE","AUTO", "SELF_VISPHI");
759  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "output-phase-sc");
760  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
761  cpl_parameterlist_append (self, p);
762 
763  /* string in the form [124,232] giving channel subset in case SELF_VISPHI */
764  p = cpl_parameter_new_value ("gravity.vis.output-phase-channels", CPL_TYPE_STRING,
765  "range (string in the form [min,max]) of channels\n"
766  "to use a SELF_VISPHI phase reference.\n",
767  "gravity.vis", "[0,0]");
768  cpl_parameter_set_alias (p, CPL_PARAMETER_MODE_CLI, "output-phase-channels");
769  cpl_parameter_disable (p, CPL_PARAMETER_MODE_ENV);
770  cpl_parameterlist_append (self, p);
771 
772  return CPL_ERROR_NONE;
773 }
774 
775 cpl_error_code gravi_parameter_add_image (cpl_parameterlist *self)
776 {
777  cpl_ensure_code (self, CPL_ERROR_NULL_INPUT);
778  cpl_parameter *p;
779 
780  /* Fill the parameters list */
781  /* --isotropic */
782 /* p = cpl_parameter_new_value("gravi.gravity_image.isotropic_option",
783  CPL_TYPE_BOOL, "a flag", "gravi.gravity_image", FALSE);
784  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "isotropic");
785  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
786  cpl_parameterlist_append(recipe->parameters, p);
787 */
788 
789  /* --pixelsize */
790  p = cpl_parameter_new_value("gravi.gravity_image.pixelsize",
791  CPL_TYPE_DOUBLE, "size of the pixel (milliarcseconds)",
792  "gravi.gravity_image", 0.2);
793  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "pixelsize");
794  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
795  cpl_parameterlist_append(self, p);
796 
797  /* --dim */
798  p = cpl_parameter_new_value("gravi.gravity_image.dim",
799  CPL_TYPE_INT, "number of pixels per side of the image",
800  "gravi.gravity_image", 100);
801  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "dim");
802  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
803  cpl_parameterlist_append(self, p);
804 
805  /* --regul */
806  p = cpl_parameter_new_value("gravi.gravity_image.regul",
807  CPL_TYPE_STRING, "name of regularization method",
808  "gravi.gravity_image", "totvar");
809  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "regul");
810  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
811  cpl_parameterlist_append(self, p);
812 
813  /* --regul_mu */
814  p = cpl_parameter_new_value("gravi.gravity_image.regul_mu",
815  CPL_TYPE_DOUBLE, "global regularization weight",
816  "gravi.gravity_image", 1E4);
817  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "regul_mu");
818  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
819  cpl_parameterlist_append(self, p);
820 
821  /* --maxeval */
822  p = cpl_parameter_new_value("gravi.gravity_image.maxeval",
823  CPL_TYPE_INT, "maximum number of evaluations of the objective function",
824  "gravi.gravity_image", 2000);
825  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "maxeval");
826  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
827  cpl_parameterlist_append(self, p);
828 
829  /* --timeout */
830  p = cpl_parameter_new_value("gravi.gravity_image.timeout",
831  CPL_TYPE_DOUBLE, "Maximum execution time of Mira process (s)",
832  "gravi.gravity_image", 60.);
833  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "timeout");
834  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
835  cpl_parameterlist_append(self, p);
836 
837 
838  return CPL_ERROR_NONE;
839 }
840 
841 /*----------------------------------------------------------------------------*/
853 /*----------------------------------------------------------------------------*/
854 
855 cpl_frameset * gravi_frameset_extract (cpl_frameset * frameset,
856  const char ** frame_tags,
857  int nb_tags)
858 {
859  cpl_ensure (frameset, CPL_ERROR_NULL_INPUT, NULL);
860  cpl_ensure (frame_tags, CPL_ERROR_NULL_INPUT, NULL);
861  cpl_ensure (nb_tags>0, CPL_ERROR_ILLEGAL_INPUT, NULL);
862 
863  int nb_frame = cpl_frameset_get_size (frameset);
864  cpl_frameset * output_frameset = cpl_frameset_new();
865 
866  /* Loop on frames in the frameset */
867  for (int i = 0; i < nb_frame; i++){
868 
869  cpl_frame * frame = cpl_frameset_get_position (frameset, i);
870  const char * frame_tag = cpl_frame_get_tag (frame) ;
871 
872  /* Loop on requested tags */
873  for (int j = 0; j < nb_tags; j++) {
874  if (strcmp(frame_tag, frame_tags[j]) == 0) {
875  cpl_frameset_insert (output_frameset, cpl_frame_duplicate(frame));
876  break;
877  }
878  }
879 
880  } /* End loop on frames*/
881 
882  return output_frameset;
883 }
884 
885 /*----------------------------------------------------------------------------*/
893 /*----------------------------------------------------------------------------*/
894 
895 cpl_frameset * gravi_frameset_extract_p2vm_data (cpl_frameset * frameset) {
896  const char *tags[] = {GRAVI_P2VM_RAW};
897  return gravi_frameset_extract (frameset, tags, 1);
898 }
899 cpl_frameset * gravi_frameset_extract_disp_data (cpl_frameset * frameset) {
900  const char *tags[] = {GRAVI_DISP_RAW};
901  return gravi_frameset_extract (frameset, tags, 1);
902 }
903 
904 /*----------------------------------------------------------------------------*/
912 /*----------------------------------------------------------------------------*/
913 cpl_frameset * gravi_frameset_extract_dark_data (cpl_frameset * frameset) {
914  const char *tags[] = {GRAVI_DARK_RAW};
915  return gravi_frameset_extract (frameset, tags, 1);
916 }
917 cpl_frameset * gravi_frameset_extract_flat_data (cpl_frameset * frameset) {
918  const char *tags[] = {GRAVI_FLAT_RAW};
919  return gravi_frameset_extract (frameset, tags, 1);
920 }
921 cpl_frameset * gravi_frameset_extract_diamcat_map (cpl_frameset * frameset) {
922  const char *tags[] = {GRAVI_DIAMETER_CAT};
923  return gravi_frameset_extract (frameset, tags, 1);
924 }
925 cpl_frameset * gravi_frameset_extract_fringe_data (cpl_frameset * frameset) {
926  const char *tags[] = {GRAVI_SINGLE_CALIB_RAW, GRAVI_SINGLE_SCIENCE_RAW, GRAVI_DUAL_CALIB_RAW, GRAVI_DUAL_SCIENCE_RAW};
927  return gravi_frameset_extract (frameset, tags, 4);
928 }
929 cpl_frameset * gravi_frameset_extract_p2vmred_data (cpl_frameset * frameset) {
930  const char *tags[] = {GRAVI_P2VMRED_SINGLE_CALIB, GRAVI_P2VMRED_SINGLE_SCIENCE,
931  GRAVI_P2VMRED_DUAL_CALIB, GRAVI_P2VMRED_DUAL_SCIENCE};
932  return gravi_frameset_extract (frameset, tags, 4);
933 }
934 cpl_frameset * gravi_frameset_extract_piezotf_data (cpl_frameset * frameset) {
935  const char *tags[] = {GRAVI_PIEZOTF_RAW};
936  return gravi_frameset_extract (frameset, tags, 1);
937 }
938 cpl_frameset * gravi_frameset_extract_sky_data (cpl_frameset * frameset) {
939  const char *tags[] = {GRAVI_DUAL_SKY_RAW, GRAVI_SINGLE_SKY_RAW};
940  return gravi_frameset_extract (frameset, tags, 2);
941 }
942 cpl_frameset * gravi_frameset_extract_wave_data (cpl_frameset * frameset) {
943  const char *tags[] = {GRAVI_WAVE_RAW};
944  return gravi_frameset_extract (frameset, tags, 1);
945 }
946 cpl_frameset * gravi_frameset_extract_wavesc_data (cpl_frameset * frameset) {
947  const char *tags[] = {GRAVI_WAVESC_RAW};
948  return gravi_frameset_extract (frameset, tags, 1);
949 }
950 cpl_frameset * gravi_frameset_extract_dispvis_data (cpl_frameset * frameset) {
951  const char *tags[] = {GRAVI_DISP_VIS};
952  return gravi_frameset_extract (frameset, tags, 1);
953 }
954 cpl_frameset * gravi_frameset_extract_disp_map (cpl_frameset * frameset) {
955  const char *tags[] = {GRAVI_DISP_MODEL};
956  return gravi_frameset_extract (frameset, tags, 1);
957 }
958 cpl_frameset * gravi_frameset_extract_met_pos (cpl_frameset * frameset) {
959  const char *tags[] = {GRAVI_DIODE_POSITION};
960  return gravi_frameset_extract (frameset, tags, 1);
961 }
962 cpl_frameset * gravi_frameset_extract_wavelamp_map (cpl_frameset * frameset) {
963  const char *tags[] = {GRAVI_WAVELAMP_MAP};
964  return gravi_frameset_extract (frameset, tags, 1);
965 }
966 cpl_frameset * gravi_frameset_extract_wavelamp_data (cpl_frameset * frameset) {
967  const char *tags[] = {GRAVI_WAVELAMP_RAW};
968  return gravi_frameset_extract (frameset, tags, 1);
969 }
970 cpl_frameset * gravi_frameset_extract_tf_calib (cpl_frameset * frameset) {
971  const char *tags[] = {GRAVI_TF_SINGLE_CALIB, GRAVI_TF_DUAL_CALIB, GRAVI_ZP_CAL};
972  return gravi_frameset_extract (frameset, tags, 3);
973 }
974 cpl_frameset * gravi_frameset_extract_vis_calib (cpl_frameset * frameset) {
975  const char *tags[] = {GRAVI_VIS_SINGLE_CALIB, GRAVI_VIS_DUAL_CALIB};
976  return gravi_frameset_extract (frameset, tags, 2);
977 }
978 cpl_frameset * gravi_frameset_extract_vis_science (cpl_frameset * frameset) {
979  const char *tags[] = {GRAVI_VIS_SINGLE_SCIENCE, GRAVI_VIS_DUAL_SCIENCE};
980  return gravi_frameset_extract (frameset, tags, 2);
981 }
982 cpl_frameset * gravi_frameset_extract_p2vm_map (cpl_frameset * frameset) {
983  const char *tags[] = {GRAVI_P2VM_MAP};
984  return gravi_frameset_extract (frameset, tags, 1);
985 }
986 cpl_frameset * gravi_frameset_extract_flat_map (cpl_frameset * frameset){
987  const char *tags[] = {GRAVI_FLAT_MAP};
988  return gravi_frameset_extract (frameset, tags, 1);
989 }
990 cpl_frameset * gravi_frameset_extract_dark_map (cpl_frameset * frameset) {
991  const char *tags[] = {GRAVI_DARK_MAP};
992  return gravi_frameset_extract (frameset, tags, 1);
993 }
994 cpl_frameset * gravi_frameset_extract_wave_map (cpl_frameset * frameset) {
995  const char *tags[] = {GRAVI_WAVE_MAP};
996  return gravi_frameset_extract (frameset, tags, 1);
997 }
998 cpl_frameset * gravi_frameset_extract_bad_map (cpl_frameset * frameset) {
999  const char *tags[] = {GRAVI_BAD_MAP};
1000  return gravi_frameset_extract (frameset, tags, 1);
1001 }
1002 cpl_frameset * gravi_frameset_extract_biasmask_map (cpl_frameset * frameset) {
1003  const char *tags[] = {GRAVI_BIASMASK_MAP};
1004  return gravi_frameset_extract (frameset, tags, 1);
1005 }
1006 cpl_frameset * gravi_frameset_extract_eop_map (cpl_frameset * frameset) {
1007  const char *tags[] = {GRAVI_EOP_MAP};
1008  return gravi_frameset_extract (frameset, tags, 1);
1009 }
1010 cpl_frameset * gravi_frameset_extract_patch (cpl_frameset * frameset) {
1011  const char *tags[] = {GRAVI_KEY_PATCH};
1012  return gravi_frameset_extract (frameset, tags, 1);
1013 }
1014 
1015 cpl_frameset * gravi_frameset_extract_static_param (cpl_frameset * frameset) {
1016  const char *tags[] = {GRAVI_STATIC_PARAM};
1017  return gravi_frameset_extract (frameset, tags, 1);
1018 }
1019 
1020 cpl_frameset * gravi_frameset_extract_wave_param (cpl_frameset * frameset) {
1021  const char *tags[] = {GRAVI_WAVE_PARAM};
1022  return gravi_frameset_extract (frameset, tags, 1);
1023 }
1024 
1025 /*---------------------------------------------------------------------------*/
1026 /*
1027  * Get the parameter from the list. Provide a default in case the parameter
1028  * is NOT in the list.
1029  */
1030 /*---------------------------------------------------------------------------*/
1031 
1032 /*----------------------------------------------------------------------------*/
1043 /*----------------------------------------------------------------------------*/
1044 
1045 double gravi_param_get_double_default (const cpl_parameterlist * parlist, const char * name, double def)
1046 {
1047  const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1048 
1049  if (tmp) {
1050  return cpl_parameter_get_double (tmp);
1051  } else {
1052  cpl_msg_info (cpl_func, "Could not find the parameter '%s':, use %f", name, def);
1053  return def;
1054  }
1055 }
1056 
1057 int gravi_param_get_int_default (const cpl_parameterlist * parlist, const char * name, int def)
1058 {
1059  const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1060 
1061  if (tmp) {
1062  return cpl_parameter_get_int (tmp);
1063  } else {
1064  cpl_msg_info (cpl_func, "Could not find the parameter '%s': use %i", name, def);
1065  return def;
1066  }
1067 }
1068 
1069 int gravi_param_get_bool_default (const cpl_parameterlist * parlist, const char * name, int def)
1070 {
1071  const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1072 
1073  if (tmp) {
1074  return cpl_parameter_get_bool (tmp);
1075  } else {
1076  cpl_msg_info (cpl_func, "Could not find the boolean parameter '%s': use %s", name, (def==0?"FALSE":"TRUE"));
1077  return def;
1078  }
1079 }
1080 
1081 const char * gravi_param_get_string_default (const cpl_parameterlist * parlist, const char * name, const char * def)
1082 {
1083  const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1084 
1085  if (tmp) {
1086  return cpl_parameter_get_string (tmp);
1087  } else {
1088  cpl_msg_info (cpl_func, "Could not find the string parameter '%s': use %s", name, def);
1089  return def;
1090  }
1091 }
1092 
1093 double gravi_param_get_double (const cpl_parameterlist * parlist, const char * name)
1094 {
1095  const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1096  double def = 0.0;
1097 
1098  if (tmp) {
1099  return cpl_parameter_get_double (tmp);
1100  } else {
1101  cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "Could not find the parameter '%s':, use %f", name, def);
1102  return def;
1103  }
1104 }
1105 
1106 int gravi_param_get_int (const cpl_parameterlist * parlist, const char * name)
1107 {
1108  const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1109  int def = 0;
1110 
1111  if (tmp) {
1112  return cpl_parameter_get_int (tmp);
1113  } else {
1114  cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "Could not find the parameter '%s': use %i", name, def);
1115  return def;
1116  }
1117 }
1118 
1119 int gravi_param_get_bool (const cpl_parameterlist * parlist, const char * name)
1120 {
1121  const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1122  int def = 0;
1123 
1124  if (tmp) {
1125  return cpl_parameter_get_bool (tmp);
1126  } else {
1127  cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "Could not find the boolean parameter '%s': use %s", name, (def==0?"FALSE":"TRUE"));
1128  return def;
1129  }
1130 }
1131 
1132 const char * gravi_param_get_string (const cpl_parameterlist * parlist, const char * name)
1133 {
1134  const cpl_parameter * tmp = cpl_parameterlist_find_const(parlist, name);
1135 
1136  if (tmp) {
1137  return cpl_parameter_get_string (tmp);
1138  } else {
1139  cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "Could not find the string parameter '%s': use UNKNOWN", name);
1140  return "UNKNOWN";
1141  }
1142 }
1143 
1144 cpl_error_code gravi_check_frameset (cpl_frameset *frameset, const char * tag, int min, int max)
1145 {
1146  int flag = 0;
1147  int nf = cpl_frameset_count_tags (frameset, tag);
1148  char * msg = cpl_sprintf ("Need %i<#<%i '%s' in frameset (%i provided)", min, max, tag, nf);
1149 
1150  if (nf < min || nf > max) {
1151  cpl_msg_error (cpl_func, "%s",msg);
1152  cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT, "%s", msg);
1153  flag ++;
1154  } else {
1155  cpl_msg_info (cpl_func, "%s", msg);
1156  }
1157 
1158  cpl_free (msg);
1159  return (flag) ? CPL_ERROR_ILLEGAL_INPUT : CPL_ERROR_NONE;
1160 }
1161 
cpl_parameter * gravi_parameter_add_badpix(cpl_parameterlist *self)
Add badpix parameters to the input parameter list.
Definition: gravi_dfs.c:187
cpl_frameset * gravi_frameset_extract_dark_data(cpl_frameset *frameset)
Extract DARK_RAW frame from the input frameset.
Definition: gravi_dfs.c:913
cpl_parameter * gravi_parameter_add_preproc(cpl_parameterlist *self)
Add preprocessing parameters to the input parameter list.
Definition: gravi_dfs.c:264
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_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:855
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:1045
cpl_error_code gravi_parameter_disable(cpl_parameter *p)
Disable a parameter.
Definition: gravi_dfs.c:169
cpl_parameter * gravi_parameter_add_profile(cpl_parameterlist *self)
Add profile parameters to the input parameter list.
Definition: gravi_dfs.c:212
cpl_error_code gravi_parameter_add_rejection(cpl_parameterlist *self, int isCalib)
Add rejection parameters to the input parameter list.
Definition: gravi_dfs.c:593
cpl_frameset * gravi_frameset_extract_p2vm_data(cpl_frameset *frameset)
Extract P2VM_RAW frame from the input frameset.
Definition: gravi_dfs.c:895
cpl_parameter * gravi_parameter_add_wave(cpl_parameterlist *self)
Add wavelength calibration parameters to the input parameter list.
Definition: gravi_dfs.c:290