GRAVI Pipeline Reference Manual  0.7.11
gravi_all_disp.c
1 /* $Id: gravi_all_disp.c,v 1.29 2015/01/10 09:16:12 nazouaoui 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 
21 /*
22  * $Author: nazouaoui $
23  * $Date: 2015/01/10 09:16:12 $
24  * $Revision: 1.29 $
25  * $Name: $
26  */
27 
28 #ifdef HAVE_CONFIG_H
29 #include <config.h>
30 #endif
31 
32 /*-----------------------------------------------------------------------------
33  Includes
34  -----------------------------------------------------------------------------*/
35 
36 #include <cpl.h>
37 #include <stdio.h>
38 #include <string.h>
39 #include <time.h>
40 
41 #include "gravi_utils.h"
42 #include "gravi_pfits.h"
43 #include "gravi_dfs.h"
44 #include "gravi_calib.h"
45 #include "gravi_vis.h"
46 #include "gravi_data.h"
47 
48 /*-----------------------------------------------------------------------------
49  Private function prototypes
50  -----------------------------------------------------------------------------*/
51 
52 static int gravi_all_disp_create(cpl_plugin *);
53 static int gravi_all_disp_exec(cpl_plugin *);
54 static int gravi_all_disp_destroy(cpl_plugin *);
55 static int gravi_all_disp(cpl_frameset *, const cpl_parameterlist *);
56 
57 /*-----------------------------------------------------------------------------
58  Static variables
59  -----------------------------------------------------------------------------*/
60 
61 static char gravi_all_disp_description[] =
62 "This recipe is associated to the template GRAVI_all_disp. Its aim is to reduce the raw"
63 "calibration file for dispersion calibration. It is used in both modes Dual and Single."
64 "\n"
65 "Description DO category\n"
66 "Required input :\n"
67 "Raw dark file (one or more) " GRAVI_DISP "\n"
68 "Ouput :\n"
69 "Dispersion (one per input file) " DISP_MODEL "\n";
70 
71 /*-----------------------------------------------------------------------------
72  Function code
73  -----------------------------------------------------------------------------*/
74 
75 /*----------------------------------------------------------------------------*/
85 /*----------------------------------------------------------------------------*/
86 int cpl_plugin_get_info(cpl_pluginlist * list)
87 {
88  cpl_recipe * recipe = cpl_calloc(1, sizeof *recipe );
89  cpl_plugin * plugin = &recipe->interface;
90 
91  if (cpl_plugin_init(plugin,
92  CPL_PLUGIN_API,
93  GRAVI_BINARY_VERSION,
94  CPL_PLUGIN_TYPE_RECIPE,
95  "gravi_all_disp",
96  "This recipe is used to compute the dispersion model.",
97  gravi_all_disp_description,
98  "Firstname Lastname",
99  PACKAGE_BUGREPORT,
100  gravi_get_license(),
101  gravi_all_disp_create,
102  gravi_all_disp_exec,
103  gravi_all_disp_destroy)) {
104  cpl_msg_error(cpl_func, "Plugin initialization failed");
105  (void)cpl_error_set_where(cpl_func);
106  return 1;
107  }
108 
109  if (cpl_pluginlist_append(list, plugin)) {
110  cpl_msg_error(cpl_func, "Error adding plugin to list");
111  (void)cpl_error_set_where(cpl_func);
112  return 1;
113  }
114 
115  return 0;
116 }
117 
118 /*----------------------------------------------------------------------------*/
126 /*----------------------------------------------------------------------------*/
127 static int gravi_all_disp_create(cpl_plugin * plugin)
128 {
129  cpl_recipe * recipe;
130  cpl_parameter * p;
131 
132  /* Do not create the recipe if an error code is already set */
133  if (cpl_error_get_code() != CPL_ERROR_NONE) {
134  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
135  cpl_func, __LINE__, cpl_error_get_where());
136  return (int)cpl_error_get_code();
137  }
138 
139  if (plugin == NULL) {
140  cpl_msg_error(cpl_func, "Null plugin");
141  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
142  }
143 
144  /* Verify plugin type */
145  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
146  cpl_msg_error(cpl_func, "Plugin is not a recipe");
147  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
148  }
149 
150  /* Get the recipe */
151  recipe = (cpl_recipe *)plugin;
152 
153  /* Create the parameters list in the cpl_recipe object */
154  recipe->parameters = cpl_parameterlist_new();
155  if (recipe->parameters == NULL) {
156  cpl_msg_error(cpl_func, "Parameter list allocation failed");
157  cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
158  }
159 
160  /* Fill the parameters list */
161 
162  /* --Save the preproc files */
163  p = cpl_parameter_new_value("gravi.preproc_param.preproc_file",
164  CPL_TYPE_BOOL, "Save the preproc file", "gravi.gravi_all_p2vm", FALSE);
165  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "preproc-file");
166  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
167  cpl_parameterlist_append(recipe->parameters, p);
168 
169  /* --Save the preproc files */
170  p = cpl_parameter_new_value("gravi.preproc_param.p2vmreduced_file",
171  CPL_TYPE_BOOL, "Save the file with all visibilities", "gravi.gravi_dual", FALSE);
172  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "p2vmreduced-file");
173  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
174  cpl_parameterlist_append(recipe->parameters, p);
175 
176  /* --Save the preproc files */
177  p = cpl_parameter_new_value("gravi.vis_reduce.vis_correction",
178  CPL_TYPE_BOOL, "Parameter of correction", "gravi.gravi_dual", FALSE);
179  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "vis-correction");
180  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
181  cpl_parameterlist_append(recipe->parameters, p);
182 
183  return 0;
184 }
185 
186 /*----------------------------------------------------------------------------*/
192 /*----------------------------------------------------------------------------*/
193 static int gravi_all_disp_exec(cpl_plugin * plugin)
194 {
195 
196  cpl_recipe * recipe;
197  int recipe_status;
198  cpl_errorstate initial_errorstate = cpl_errorstate_get();
199 
200  /* Return immediately if an error code is already set */
201  if (cpl_error_get_code() != CPL_ERROR_NONE) {
202  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
203  cpl_func, __LINE__, cpl_error_get_where());
204  return (int)cpl_error_get_code();
205  }
206 
207  if (plugin == NULL) {
208  cpl_msg_error(cpl_func, "Null plugin");
209  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
210  }
211 
212  /* Verify plugin type */
213  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
214  cpl_msg_error(cpl_func, "Plugin is not a recipe");
215  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
216  }
217 
218  /* Get the recipe */
219  recipe = (cpl_recipe *)plugin;
220 
221  /* Verify parameter and frame lists */
222  if (recipe->parameters == NULL) {
223  cpl_msg_error(cpl_func, "Recipe invoked with NULL parameter list");
224  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
225  }
226  if (recipe->frames == NULL) {
227  cpl_msg_error(cpl_func, "Recipe invoked with NULL frame set");
228  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
229  }
230 
231  /* Invoke the recipe */
232  recipe_status = gravi_all_disp(recipe->frames, recipe->parameters);
233 
234  /* Ensure DFS-compliance of the products */
235 
236  if (cpl_dfs_update_product_header(recipe->frames)) {
237  if (!recipe_status){
238  recipe_status = (int)cpl_error_get_code();
239  }
240  }
241 
242  if (!cpl_errorstate_is_equal(initial_errorstate)) {
243  /* Dump the error history since recipe execution start.
244  At this point the recipe cannot recover from the error */
245  cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
246  }
247 
248  return recipe_status;
249 }
250 
251 /*----------------------------------------------------------------------------*/
257 /*----------------------------------------------------------------------------*/
258 static int gravi_all_disp_destroy(cpl_plugin * plugin)
259 {
260  cpl_recipe * recipe;
261 
262  if (plugin == NULL) {
263  cpl_msg_error(cpl_func, "Null plugin");
264  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
265  }
266 
267  /* Verify plugin type */
268  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
269  cpl_msg_error(cpl_func, "Plugin is not a recipe");
270  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
271  }
272 
273  /* Get the recipe */
274  recipe = (cpl_recipe *)plugin;
275 
276  cpl_parameterlist_delete(recipe->parameters);
277 
278  return 0;
279 }
280 
281 
282 /*----------------------------------------------------------------------------*/
290 /*----------------------------------------------------------------------------*/
291 static int gravi_all_disp(cpl_frameset * frameset,
292  const cpl_parameterlist * parlist)
293 {
294  cpl_frameset * disp_frameset, * wavecalib_frameset, * darkcalib_frameset,
295  * gaincalib_frameset, * dark_frameset, * wave_frameset,
296  * badpix_frameset, * gain_frameset, * p2vmreduce_frameset,
297  * p2vm_frameset, * skyframeset;
298  cpl_propertylist * applist, * primary_hdr, * primary_hdr_dark, * disp_plist,
299  * primary_hdr_wave, * bad_primary_hdr,
300  * profile_primary_hdr, * wave_plist;
301  cpl_parameterlist * preproc_parlist;
302  cpl_frame * frame;
303  const cpl_parameter * p, *p_;
304  cpl_parameter * par;
305  char * out_dark, * out_wave, * preproc_name, * out_gain,
306  * vis_name;
307  const char * filename, * temp, * filename_, *frame_tag;/*, * insname;*/
308  gravi_data * disp_map, * data, * dark_map, * wave_map,
309  * profile_map, * badpix_map, * p2vm_reduce, * sky_map;
310  gravi_data ** calib_datas, * oi_vis;
311  gravi_data * preproc_data, * p2vm_map;
312  gravi_data ** raw_data;
313  dark_map = NULL, wave_map = NULL;
314  int nb_frame, i, nb_frame_gain;
315  int rest, nb_vis, nwave_sc, num_disp, nwave_ft;
316  double gain_ft, gain_sc, mjd_obs, wavemin, wavemax;
317  int * shutter;
318  cpl_table * vis_met = NULL, * metrology_table, * fddl;
319 
320  cpl_propertylist * met_plist;
321  cpl_frameset * preproc_frame;
322 // double dit, darkmean, minwave, maxwave, darkrms;
323 
324  /* Identify the RAW and CALIB frames in the input frameset */
325 
326  cpl_ensure_code(gravi_dfs_set_groups(frameset) == CPL_ERROR_NONE,
327  cpl_error_get_code()) ;
328 
329  /* - Extract a set of frame p2vm and set of frame dark wave */
330  p2vmreduce_frameset = gravi_frameset_extract_p2vmreduce_data(frameset);
331 
332  if (cpl_frameset_is_empty(p2vmreduce_frameset)){
333 
334  /* - Extract a set of frame p2vm and set of frame dark wave */
335  // cpl_frameset * frameset = cpl_frameset_duplicate(_frameset);
336  disp_frameset = gravi_frameset_extract_disp_data(frameset);
337  p2vm_frameset = gravi_frameset_extract_p2vm_file(frameset);
338  darkcalib_frameset = gravi_frameset_extract_dark_file(frameset);
339  wave_frameset = gravi_frameset_extract_wave_file(frameset);
340  dark_frameset = gravi_frameset_extract_dark(frameset);
341  gain_frameset = gravi_frameset_extract_flat_file(frameset);
342  badpix_frameset = gravi_frameset_extract_badpix(frameset);
343  skyframeset = gravi_frameset_extract_sky_data (frameset);
344  if (cpl_frameset_is_empty(disp_frameset)) {
345  /* To use this recipe the frameset must contain at least
346  * one p2vm frame. */
347  cpl_frameset_delete(darkcalib_frameset);
348  cpl_frameset_delete(wave_frameset);
349  cpl_frameset_delete(dark_frameset);
350  cpl_frameset_delete(gain_frameset);
351  cpl_frameset_delete(p2vm_frameset);
352  cpl_frameset_delete(disp_frameset);
353 
354  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
355  "No single frame on the frameset") ;
356  }
357 
358  if ((cpl_frameset_is_empty(p2vm_frameset)) ||
359  (cpl_frameset_is_empty(wave_frameset)) ||
360  (cpl_frameset_is_empty(gain_frameset))) {
361  /* To use this recipe the frameset must contain the p2vm, wave and
362  * gain calibration file. */
363  cpl_frameset_delete(darkcalib_frameset);
364  cpl_frameset_delete(disp_frameset);
365  cpl_frameset_delete(wave_frameset);
366  cpl_frameset_delete(dark_frameset);
367  cpl_frameset_delete(gain_frameset);
368  cpl_frameset_delete(p2vm_frameset);
369  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
370  "No p2vm or gain or wave file on the frameset") ;
371  }
372 
373  /* Get the number of the p2vm frame contained in the frameset */
374  nb_frame = cpl_frameset_get_size(disp_frameset);
375 
376  /* Identify and extract the dark and wave fits files */
377 
378  /* Check and get the dark frame */
379 
380  if (!cpl_frameset_is_empty(dark_frameset)) {
381  frame = cpl_frameset_get_position(dark_frameset, 0);
382 
383  filename_ = cpl_frame_get_filename(frame);
384  data = gravi_data_load(filename_);
385  temp = strrchr(filename_, '/');
386  filename = temp ? temp + 1 : filename_;
387  primary_hdr = gravi_data_get_propertylist(data,
388  GRAVI_PRIMARY_HDR_NAME_EXT);
389  shutter = gravi_shutters_check(primary_hdr);
390  if (!((shutter[0] == 0) && (shutter[1] == 0) && (shutter[2] == 0)
391  && (shutter[3] == 0))){
392  cpl_frameset_delete(darkcalib_frameset);
393  cpl_frameset_delete(dark_frameset);
394  cpl_frameset_delete(wave_frameset);
395  cpl_frameset_delete(gain_frameset);
396  cpl_frameset_delete(p2vm_frameset);
397  cpl_frameset_delete(disp_frameset);
398  gravi_data_delete(data);
399  return (int)cpl_error_set_message(cpl_func,
400  CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem");
401  }
402  /* The dark file must contains all the shutter close */
403 
404  cpl_msg_info (cpl_func, "This file %s is a dark file",
405  filename);
406  dark_map = gravi_compute_dark(data);
407  if (cpl_error_get_code()) {
408  cpl_frameset_delete(darkcalib_frameset);
409  cpl_frameset_delete(dark_frameset);
410  cpl_frameset_delete(wave_frameset);
411  cpl_frameset_delete(gain_frameset);
412  gravi_data_delete(dark_map);
413  cpl_frameset_delete(p2vm_frameset);
414  cpl_frameset_delete(disp_frameset);
415  cpl_propertylist_delete(applist);
416  gravi_data_delete(data);
417  return (int)cpl_error_set_message(cpl_func,
418  CPL_ERROR_ILLEGAL_OUTPUT,
419  "Error while computing the dark_map");
420  }
421 
422  /* Save the dark map */
423 
424  primary_hdr_dark = gravi_data_get_propertylist(dark_map,
425  GRAVI_PRIMARY_HDR_NAME_EXT);
426  applist = gravi_propertylist_get_qc (primary_hdr_dark);
427  // dit = gravi_pfits_get_dit(primary_hdr_dark);
428  //insname = gravi_pfits_get_insname(primary_hdr_dark);
429  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
430  DARK);
431 
432  // cpl_propertylist_append_double(applist, GRAVI_DET_DIT, dit);
433  // out_dark = cpl_sprintf("master_dark.%s", filename + 1);
434  out_dark = gravi_data_product_name (filename, "dark");
435 
436  if (gravi_data_save(dark_map, frameset, out_dark, parlist,
437  dark_frameset, frame, "gravi_all_disp", applist)
438  != CPL_ERROR_NONE){
439  cpl_frameset_delete(darkcalib_frameset);
440  cpl_frameset_delete(dark_frameset);
441  cpl_frameset_delete(wave_frameset);
442  cpl_frameset_delete(gain_frameset);
443  gravi_data_delete(dark_map);
444  cpl_frameset_delete(p2vm_frameset);
445  cpl_frameset_delete(disp_frameset);
446  cpl_propertylist_delete(applist);
447  gravi_data_delete(data);
448  cpl_free(shutter);
449 
450  return (int) cpl_error_set_message(cpl_func,
451  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the dark_map"
452  " on the output file");
453  }
454  cpl_propertylist_delete(applist);
455 
456 
457  gravi_data_delete(data);
458  cpl_free(shutter);
459 
460 
461  }
462  else if (!cpl_frameset_is_empty(darkcalib_frameset)) {
463  frame = cpl_frameset_get_position(darkcalib_frameset, 0);
464 
465  frame_tag = cpl_frame_get_tag(frame) ;
466  filename_ = cpl_frame_get_filename(frame);
467 
468  dark_map = gravi_data_load(filename_);
469  temp = strrchr(filename_, '/');
470  filename = temp ? temp + 1 : filename_;
471  cpl_msg_info (cpl_func, "This file %s is a dark file already "
472  "computed", filename);
473  cpl_frameset_insert (dark_frameset, cpl_frame_duplicate (frame));
474  }
475 
476  /* Check that the dark_map in the input frameset */
477  else {
478  cpl_frameset_delete(darkcalib_frameset);
479  cpl_frameset_delete(p2vm_frameset);
480  cpl_frameset_delete(dark_frameset);
481  cpl_frameset_delete(wave_frameset);
482  cpl_frameset_delete(gain_frameset);
483  gravi_data_delete(dark_map);
484  cpl_frameset_delete(disp_frameset);
485 
486  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
487  "No dark frames in the frameset");
488  }
489 
490  if (!cpl_frameset_is_empty(skyframeset)) {
491 
492  frame = cpl_frameset_get_position(skyframeset, 0);
493 
494  filename_ = cpl_frame_get_filename(frame);
495  data = gravi_data_load(filename_);
496  temp = strrchr(filename_, '/');
497  filename = temp ? temp + 1 : filename_;
498  primary_hdr = gravi_data_get_propertylist(data,
499  GRAVI_PRIMARY_HDR_NAME_EXT);
500 
501  cpl_msg_info (cpl_func, "This file %s is a sky file",
502  filename);
503  sky_map = gravi_compute_dark(data);
504 
505  gravi_data_delete(data);
506  if (cpl_error_get_code()) {
507  cpl_frameset_delete(darkcalib_frameset);
508  cpl_frameset_delete(dark_frameset);
509  cpl_frameset_delete(wave_frameset);
510  cpl_frameset_delete(gain_frameset);
511  gravi_data_delete(sky_map);
512  cpl_frameset_delete(p2vm_frameset);
513  cpl_frameset_delete(disp_frameset);
514  cpl_propertylist_delete(applist);
515 
516  return (int)cpl_error_set_message(cpl_func,
517  CPL_ERROR_ILLEGAL_OUTPUT,
518  "Error while computing the dark_map");
519  }
520  cpl_frameset_insert (dark_frameset, cpl_frame_duplicate (frame));
521  /* Save the dark map */
522 
523  primary_hdr_dark = gravi_data_get_propertylist(sky_map,
524  GRAVI_PRIMARY_HDR_NAME_EXT);
525  applist = gravi_propertylist_get_qc (primary_hdr_dark);
526  // dit = gravi_pfits_get_dit(primary_hdr_dark);
527  //insname = gravi_pfits_get_insname(primary_hdr_dark);
528  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
529  SKY);
530 
531  // cpl_propertylist_append_double(applist, GRAVI_DET_DIT, dit);
532  // out_dark = cpl_sprintf("sky_meadian.%s", filename + 1);
533  out_dark = gravi_data_product_name (filename, "sky");
534 
535  if (gravi_data_save(sky_map, frameset, out_dark, parlist,
536  skyframeset, frame, "gravi_all_disp", applist)
537  != CPL_ERROR_NONE){
538  cpl_frameset_delete(darkcalib_frameset);
539  cpl_frameset_delete(dark_frameset);
540  cpl_frameset_delete(wave_frameset);
541  cpl_frameset_delete(gain_frameset);
542  gravi_data_delete(sky_map);
543  cpl_frameset_delete(p2vm_frameset);
544  cpl_frameset_delete(disp_frameset);
545  cpl_propertylist_delete(applist);
546 
547  cpl_free(shutter);
548 
549  return (int) cpl_error_set_message(cpl_func,
550  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the dark_map"
551  " on the output file");
552  }
553  cpl_propertylist_delete(applist);
554 
555  cpl_imagelist * sky_cube = gravi_data_get_cube (sky_map,
556  GRAVI_IMAGING_DATA_SC_EXT);
557 
558  gravi_data_set_cube (dark_map, GRAVI_IMAGING_DATA_SC_EXT,
559  cpl_imagelist_duplicate (sky_cube));
560  gravi_data_delete (sky_map);
561  cpl_free (out_dark);
562  }
563 
564  cpl_frameset_delete(skyframeset);
565  /* Compute the bad pixel map */
566  if (!cpl_frameset_is_empty(badpix_frameset)){
567  frame = cpl_frameset_get_position(badpix_frameset, 0);
568  filename_ = cpl_frame_get_filename(frame);
569 
570  badpix_map = gravi_data_load(filename_);
571  temp = strrchr(filename_, '/');
572  filename = temp ? temp + 1 : filename_;
573  cpl_msg_info (cpl_func, "This file %s is a bad pixel map", filename);
574  }
575  else {
576 
577  badpix_map = gravi_compute_badpix(dark_map, parlist);
578 
579  if (cpl_error_get_code()) {
580  gravi_data_delete(badpix_map);
581  cpl_frameset_delete(dark_frameset);
582  cpl_frameset_delete(wave_frameset);
583  cpl_frameset_delete(gain_frameset);
584  cpl_frameset_delete(p2vm_frameset);
585  cpl_frameset_delete(darkcalib_frameset);
586  gravi_data_delete(dark_map);
587  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
588  "Error while computing the bad pixel map");
589 
590  }
591  /* Save the pad pixel map */
592  bad_primary_hdr = gravi_data_get_propertylist (badpix_map,
593  GRAVI_PRIMARY_HDR_NAME_EXT);
594  applist = gravi_propertylist_get_qc (bad_primary_hdr);
595 
596  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, BAD);
597 
598  frame = cpl_frameset_get_position (dark_frameset, 0);
599 
600  if (gravi_data_save (badpix_map, frameset, "gravi_bad_map.fits", parlist,
601  dark_frameset, frame, "gravi_all_disp", applist)
602  != CPL_ERROR_NONE){
603 
604  gravi_data_delete(badpix_map);
605  cpl_frameset_delete(dark_frameset);
606  cpl_frameset_delete(wave_frameset);
607  cpl_frameset_delete(gain_frameset);
608  cpl_frameset_delete(p2vm_frameset);
609  cpl_frameset_delete(darkcalib_frameset);
610  cpl_frameset_delete(badpix_frameset);
611  gravi_data_delete(dark_map);
612  return (int) cpl_error_set_message(cpl_func,
613  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the bad pixel map");
614  }
615  cpl_propertylist_delete (applist);
616  }
617 
618  /* Identify the flat file */
619 
620  frame = cpl_frameset_get_position(gain_frameset, 0);
621  filename_ = cpl_frame_get_filename(frame);
622 
623 
624  profile_map = gravi_data_load(filename_);
625  temp = strrchr(filename_, '/');
626  filename = temp ? temp + 1 : filename_;
627  cpl_msg_info (cpl_func, "This file %s is a flat file already "
628  "computed", filename);
629 
630  /* Check and get the wave frame */
631  frame = cpl_frameset_get_position(wave_frameset, 0);
632  filename_ = cpl_frame_get_filename(frame);
633 
634  wave_map = gravi_data_load(filename_);
635  temp = strrchr(filename_, '/');
636  filename = temp ? temp + 1 : filename_;
637 
638  cpl_msg_info (cpl_func, "This file %s is a wave file already "
639  "computed", filename);
640 
641  /* Check that wave_map exist in the input frameset */
642  if ((wave_map == NULL) || (profile_map == NULL)){
643  cpl_frameset_delete(darkcalib_frameset);
644  cpl_frameset_delete(p2vm_frameset);
645  cpl_frameset_delete(dark_frameset);
646  cpl_frameset_delete(wave_frameset);
647  cpl_frameset_delete(gain_frameset);
648  gravi_data_delete(wave_map);
649  gravi_data_delete(profile_map);
650  gravi_data_delete(badpix_map);
651  cpl_frameset_delete(disp_frameset);
652 
653  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
654  "No wave frames in the frameset");
655  }
656 
657  /* Load the p2vm data */
658  frame = cpl_frameset_get_position(p2vm_frameset, 0);
659  filename_ = cpl_frame_get_filename(frame);
660 
661 
662  p2vm_map = gravi_data_load (filename_);
663  temp = strrchr(filename_, '/');
664  filename = temp ? temp + 1 : filename_;
665 
666  cpl_msg_info (cpl_func, "This file %s is a p2vm file already "
667  "computed", filename);
668 
669  if (cpl_error_get_code()) {
670  cpl_frameset_delete(darkcalib_frameset);
671  cpl_frameset_delete(p2vm_frameset);
672  cpl_frameset_delete(dark_frameset);
673  cpl_frameset_delete(wave_frameset);
674  cpl_frameset_delete(gain_frameset);
675  gravi_data_delete(profile_map);
676  gravi_data_delete(dark_map);
677  gravi_data_delete(wave_map);
678  gravi_data_delete(p2vm_map);
679  cpl_frameset_delete(disp_frameset);
680 
681  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
682  "Error while loading the p2vm_map");
683  }
684 
685  /* Check if the data with the p2vm have the same spectral n */
686  int n_region = cpl_table_get_nrow (gravi_data_get_table (p2vm_map,
687  GRAVI_IMAGING_DETECTOR_SC_EXT));
688  int n_pol = 1;
689  if (n_region > 24)
690  n_pol = 2;
691 
692 
693  wave_plist = gravi_data_get_oi_propertylist (p2vm_map, GRAVI_OI_WAVE_SWITCH(GRAVI_TYPE_SC),
694  GRAVI_SPECTRO_SWITCH(GRAVI_TYPE_SC, 0, n_pol));
695 
696  nwave_sc = gravi_pfits_get_nwave (wave_plist);
697  wave_plist = gravi_data_get_oi_propertylist (p2vm_map, GRAVI_OI_WAVE_SWITCH(GRAVI_TYPE_FT),
698  GRAVI_SPECTRO_SWITCH(GRAVI_TYPE_FT, 0, n_pol));
699 
700  nwave_ft = gravi_pfits_get_nwave (wave_plist);
701  primary_hdr = gravi_data_get_propertylist (wave_map,
702  GRAVI_PRIMARY_HDR_NAME_EXT);//pour ft et sc
703 
704  if (cpl_error_get_code()) {
705  cpl_frameset_delete(darkcalib_frameset);
706  cpl_frameset_delete(p2vm_frameset);
707  cpl_frameset_delete(dark_frameset);
708  cpl_frameset_delete(wave_frameset);
709  cpl_frameset_delete(gain_frameset);
710  gravi_data_delete(profile_map);
711  gravi_data_delete(dark_map);
712  gravi_data_delete(wave_map);
713  gravi_data_delete(p2vm_map);
714  cpl_frameset_delete(disp_frameset);
715 
716  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
717  "Missed one the preproc parameters");
718  }
719 
720  wavemin = cpl_propertylist_get_double (primary_hdr, QC_MINWAVE_SC);
721  wavemax = cpl_propertylist_get_double (primary_hdr, QC_MAXWAVE_SC);
722 //
723 // printf("wavemin = %e wavemaxe = %e nwave_ft = %d nwave_sc = %d\n"
724 // , wavemin, wavemax, nwave_ft, nwave_sc);
725  /* Construction of the parameterlist to compute the preprocing */
726  cpl_size nb_par = cpl_parameterlist_get_size (parlist);
727 
728  preproc_parlist = cpl_parameterlist_new ();
729  p = cpl_parameterlist_get_first_const (parlist);
730  for (i = 0; i < nb_par; i ++){
731  cpl_type type = cpl_parameter_get_type (p);
732  switch (type) {
733  case CPL_TYPE_DOUBLE :
734  par = cpl_parameter_new_value(cpl_parameter_get_name (p), type,
735  cpl_parameter_get_help(p),
736  cpl_parameter_get_context(p),
737  cpl_parameter_get_double (p));
738  break;
739  case CPL_TYPE_BOOL :
740  par = cpl_parameter_new_value(cpl_parameter_get_name (p), type,
741  cpl_parameter_get_help(p),
742  cpl_parameter_get_context(p),
743  cpl_parameter_get_bool (p));
744  break;
745  case CPL_TYPE_INT :
746  par = cpl_parameter_new_value(cpl_parameter_get_name (p), type,
747  cpl_parameter_get_help(p),
748  cpl_parameter_get_context(p),
749  cpl_parameter_get_int (p));
750  break;
751  case CPL_TYPE_STRING :
752  par = cpl_parameter_new_value(cpl_parameter_get_name (p), type,
753  cpl_parameter_get_help(p),
754  cpl_parameter_get_context(p),
755  cpl_parameter_get_string (p));
756  break;
757  default :
758  cpl_msg_warning(cpl_func, "Type of the parameter is different %s",
759  cpl_type_get_name (type));
760  break;
761  }
762 
763 
764  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI,
765  cpl_parameter_get_alias (p, CPL_PARAMETER_MODE_CLI));
766  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
767  cpl_parameterlist_append(preproc_parlist, par);
768  p = cpl_parameterlist_get_next_const (parlist);
769  }
770  /* --the minimum wavelength */
771 
772  par = cpl_parameter_new_value("gravi.preproc_param.min_wave",
773  CPL_TYPE_DOUBLE, "the minimum wavelength",
774  "gravi.gravi_all_p2vm", wavemin + 0.0001);
775  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, "lambdamin");
776  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
777  cpl_parameterlist_append(preproc_parlist, par);
778 
779  /* --the maximum wavelength */
780  par = cpl_parameter_new_value("gravi.preproc_param.max_wave",
781  CPL_TYPE_DOUBLE, "the maximum wavelength",
782  "gravi.gravi_all_p2vm", wavemax - 0.0001);
783  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, "lambdamax");
784  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
785  cpl_parameterlist_append(preproc_parlist, par);
786 
787  /* --the number of the spectral element to compute */
788  par = cpl_parameter_new_value("gravi.preproc_param.nspectrum_FT",
789  CPL_TYPE_INT, "the number of the spectral",
790  "gravi.gravi_all_dark", nwave_ft);
791  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, "nlambda_ft");
792  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
793  cpl_parameterlist_append(preproc_parlist, par);
794 
795  /* --the number of the spectral element to compute */
796  par = cpl_parameter_new_value("gravi.preproc_param.nspectrum_SC",
797  CPL_TYPE_INT, "the number of the spectral",
798  "gravi.gravi_all_dark", nwave_sc);
799  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, "nlambda_sc");
800  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
801  cpl_parameterlist_append(preproc_parlist, par);
802 
803 
804  // printf("nb_frameset = %d nb_frameset_dark = %d nb_frameset_wave = %d nb_frameset_p2vm = %d nb_gain_frame = %d\n",
805  // nb_frame, cpl_frameset_get_size(dark_frameset), cpl_frameset_get_size(wave_frameset),
806  // cpl_frameset_get_size(p2vm_frameset), cpl_frameset_get_size(gain_frameset));
807 
808 
809  /* Construction of the calibration data */
810  calib_datas = cpl_malloc(4 * sizeof(gravi_data *));
811  calib_datas[0] = dark_map;
812  calib_datas[1] = wave_map;
813  calib_datas[2] = profile_map;
814  calib_datas[3] = badpix_map;
815 
816  p = cpl_parameterlist_find_const(parlist, "gravi.preproc_param.preproc_file");
817 
818  p_ = cpl_parameterlist_find_const(parlist, "gravi.preproc_param.p2vmreduced_file");
819 
820  /* Construction of the preproc data and extract the spectra using
821  * the results of the spectral calibration */
822 
823  nb_vis = 0;
824  oi_vis = gravi_data_new(0);
825  primary_hdr = gravi_data_get_propertylist (p2vm_map,
826  GRAVI_PRIMARY_HDR_NAME_EXT);
827  const char * resol_p2vm = gravi_pfits_get_resolution (primary_hdr),
828  * resol_file;
829 
830  // int threadError = 0;
831  // omp_set_num_threads(4);
832  // printf("maxtreads %d\n",omp_get_max_threads());
833  //#pragma omp parallel for schedule(dynamic) default(none) \
834  // lastprivate(frame,frame_tag,filename_,temp,filename,data,primary_hdr,\
835  // shutter,preproc_name,preproc_frame,applist, p2vmreduced_frame,\
836  // p2vm_reduce,p2vm_name) \
837  // shared(nb_frame, frame_tag,disp_frameset,cpl_func,calib_datas,\
838  // preproc_parlist,preproc_frameset,p,SKYREDUCED,CPL_DFS_PRO_CATG,\
839  // p2vm_map,p_,P2VMREDUCED,oi_vis,nb_vis)
840  //
841  int thread;
842  for (thread = 0; thread < nb_frame; thread++){
843  // cpl_msg_info(NULL, "Thread : %d : ==> Start of thread",
844  // omp_get_thread_num());
845  // cpl_msg_info(NULL, "OpenMP number of thread : %d",
846  // omp_get_num_threads());
847  frame = cpl_frameset_get_position (disp_frameset, thread);
848  frame_tag = cpl_frame_get_tag (frame);
849  filename_ = cpl_frame_get_filename (frame);
850 
851  temp = strrchr(filename_, '/');
852  filename = temp ? temp + 1 : filename_;
853 
854  data = gravi_data_load(filename_);
855  primary_hdr = gravi_data_get_propertylist (data,
856  GRAVI_PRIMARY_HDR_NAME_EXT);
857  /* Check the shutter for extracting the files can be used to compute
858  * the visibilities */
859  shutter = gravi_shutters_check(primary_hdr);
860  resol_file = gravi_pfits_get_resolution (primary_hdr);
861  // if (cpl_error_get_code()) {
862  // cpl_frameset_delete(darkcalib_frameset);
863  // cpl_frameset_delete(p2vm_frameset);
864  // cpl_frameset_delete(dark_frameset);
865  // cpl_frameset_delete(wave_frameset);
866  // cpl_frameset_delete(gain_frameset);
867  //
868  //
869  // gravi_data_delete(preproc_data);
870  //
871  // cpl_free(preproc_data);
872  // cpl_free(calib_datas);
873  // gravi_data_delete(profile_map);
874  // gravi_data_delete(dark_map);
875  // gravi_data_delete(wave_map);
876  // gravi_data_delete(badpix_map);
877  // gravi_data_delete(p2vm_map);
878  // cpl_frameset_delete(disp_frameset);
879  //
880  // return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
881  // "Missing key word");
882  // }
883 
884 // printf("resol_file = %s shutter %d %d %d %d\n", resol_file,
885 // shutter[0],
886 // shutter[1],
887 // shutter[2],
888 // shutter[3] );
889  if (strcmp(resol_file, resol_p2vm)){
890  // cpl_frameset_delete(darkcalib_frameset);
891  // cpl_frameset_delete(p2vm_frameset);
892  // cpl_frameset_delete(dark_frameset);
893  // cpl_frameset_delete(wave_frameset);
894  // cpl_frameset_delete(gain_frameset);
895  //
896  //
897  // gravi_data_delete(preproc_data);
898  //
899  // cpl_free(preproc_data);
900  // cpl_free(calib_datas);
901  // gravi_data_delete(profile_map);
902  // gravi_data_delete(dark_map);
903  // gravi_data_delete(wave_map);
904  // gravi_data_delete(badpix_map);
905  // gravi_data_delete(p2vm_map);
906  // cpl_frameset_delete(disp_frameset);
907  //
908  // return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
909  // "The files don t have the same"
910  // "resultion as the input p2vm");
911  }
912 
913 
914  cpl_msg_info (cpl_func, "Calibration of this file %s", filename);
915  preproc_data = gravi_preproc(data, calib_datas, 4,p2vm_map, preproc_parlist);
916 
917  gravi_data_delete(data);
918  cpl_free(shutter);
919  cpl_frameset_insert (p2vmreduce_frameset, cpl_frame_duplicate (frame));
920 
921 
922  if (cpl_error_get_code()) {
923  cpl_frameset_delete(darkcalib_frameset);
924  cpl_frameset_delete(p2vm_frameset);
925  cpl_frameset_delete(dark_frameset);
926  cpl_frameset_delete(wave_frameset);
927  cpl_frameset_delete(gain_frameset);
928 
929 
930  gravi_data_delete(preproc_data);
931 
932  cpl_free(preproc_data);
933  cpl_free(calib_datas);
934  gravi_data_delete(profile_map);
935  gravi_data_delete(dark_map);
936  gravi_data_delete(wave_map);
937  gravi_data_delete(badpix_map);
938  gravi_data_delete(p2vm_map);
939  cpl_frameset_delete(disp_frameset);
940 
941  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
942  "Error while computing the preproc data_map");
943  }
944 
945  /* Option save the proproc file */
946  if (cpl_parameter_get_bool(p)){
947  // preproc_name = cpl_sprintf("gravi_preproc.%s", filename);
948  preproc_name = gravi_data_product_name (filename, "preproc");
949  cpl_frameset * preproc_frame = cpl_frameset_new ();
950  cpl_frameset_insert (preproc_frame, cpl_frame_duplicate (frame));
951 
952  applist = gravi_propertylist_get_qc (gravi_data_get_propertylist
953  (preproc_data, GRAVI_PRIMARY_HDR_NAME_EXT));
954 
955 
956  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, PREPROC);
957 
958  if (gravi_data_save(preproc_data, frameset, preproc_name, parlist,
959  preproc_frame, frame, "gravi_all_disp", applist)
960  != CPL_ERROR_NONE){
961  cpl_frameset_delete(darkcalib_frameset);
962  cpl_frameset_delete(dark_frameset);
963  cpl_frameset_delete(wave_frameset);
964  cpl_frameset_delete(gain_frameset);
965  cpl_free(calib_datas);
966  gravi_data_delete(profile_map);
967  gravi_data_delete(dark_map);
968  gravi_data_delete(wave_map);
969  gravi_data_delete(p2vm_map);
970  cpl_frameset_delete(p2vm_frameset);
971  cpl_frameset_delete(disp_frameset);
972  cpl_propertylist_delete(applist);
973 
974  gravi_data_delete(preproc_data);
975 
976  cpl_free(preproc_name);
977 
978  return (int) cpl_error_set_message(cpl_func,
979  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the preproc data"
980  " on the output file");
981  }
982 
983  cpl_free(preproc_name);
984  cpl_propertylist_delete (applist);
985  cpl_frameset_delete (preproc_frame);
986  }
987 
988  /* Compute the flux and visibilities for each telescope and
989  * per acquisition */
990  cpl_msg_info (cpl_func, "reduce the p2vm of the file %s",
991  filename);
992  p2vm_reduce = gravi_p2vm_reduce (preproc_data, p2vm_map, "gravi_dual", parlist);//gravi_data_duplicate (preproc_data);
993  gravi_data_delete(preproc_data);
994  if (cpl_error_get_code()){
995  gravi_data_delete(p2vm_reduce);
996 
997  gravi_data_delete(p2vm_map);
998  cpl_frameset_delete(p2vm_frameset);
999  cpl_frameset_delete(disp_frameset);
1000 
1001 
1002  return (int) cpl_error_set_message(cpl_func,
1003  CPL_ERROR_ILLEGAL_OUTPUT, "error while reducing the p2vm");
1004  }
1005 
1006  if (cpl_parameter_get_bool(p_)){
1007  // char * p2vm_name = cpl_sprintf("dual_reduced.%s", filename);
1008  char * p2vm_name = gravi_data_product_name (filename, "p2vmreduced");
1009 
1010  cpl_frameset * p2vmreduced_frame = cpl_frameset_new ();
1011  cpl_frameset_insert (p2vmreduced_frame, cpl_frame_duplicate (frame));
1012 
1013  applist = gravi_propertylist_get_qc (gravi_data_get_propertylist
1014  (p2vm_reduce, GRAVI_PRIMARY_HDR_NAME_EXT));
1015 
1016 
1017  if ((strcmp(frame_tag, SINGLE_CAL_SKY_RAW) == 0)||
1018  (strcmp(frame_tag, SINGLE_SCI_SKY_RAW) == 0)||
1019  (strcmp(frame_tag, DUAL_CAL_SKY_RAW) == 0)||
1020  (strcmp(frame_tag, DUAL_SCI_SKY_RAW) == 0))
1021 
1022  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, SKYREDUCED);
1023 
1024  else
1025  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, P2VMREDUCED);
1026 
1027  if (gravi_data_save(p2vm_reduce, frameset, p2vm_name, parlist,
1028  p2vmreduced_frame, frame, "gravi_all_disp", applist)
1029  != CPL_ERROR_NONE){
1030  // cpl_frameset_delete(darkcalib_frameset);
1031  // cpl_frameset_delete(dark_frameset);
1032  // cpl_frameset_delete(wave_frameset);
1033  // cpl_frameset_delete(gain_frameset);
1034  // cpl_frameset_delete(p2vmreduced_frame);
1035  // cpl_free(calib_datas);
1036  // gravi_data_delete(profile_map);
1037  // gravi_data_delete(dark_map);
1038  // gravi_data_delete(wave_map);
1039  // gravi_data_delete(p2vm_map);
1040  // cpl_frameset_delete(p2vm_frameset);
1041  // cpl_frameset_delete(disp_frameset);
1042  // cpl_propertylist_delete(applist);
1043  //
1044  // gravi_data_delete(preproc_data);
1045  //
1046  // cpl_free(p2vm_name);
1047  //
1048  // return (int) cpl_error_set_message(cpl_func,
1049  // CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the preproc data"
1050  // " on the output file");
1051  }
1052 
1053  cpl_free(p2vm_name);
1054  cpl_propertylist_delete (applist);
1055  cpl_frameset_delete (p2vmreduced_frame);
1056  }
1057 
1058  // if ((strcmp(frame_tag, SINGLE_SKY_RAW) == 0)){
1059  // gravi_data_delete(p2vm_reduce);
1060  // continue;
1061  // }
1062 
1063  /* Compute the complex visibilty, squared visibity and the cloture phases */
1064  /* To compute the visibility from a set of observable */
1065 
1066  /* by inverting the V2PM to compute the P2VM. The matrix inversion is
1067  * done using the singular value decomposition method */
1068  cpl_msg_info (cpl_func, "reduce the visibilities");
1069  gravi_vis_reduce (oi_vis, p2vm_reduce, nb_vis, parlist, "gravi_dual");
1070 
1071 
1072  if (cpl_error_get_code()){
1073  gravi_data_delete(p2vm_reduce);
1074  gravi_data_delete(oi_vis);
1075  cpl_frameset_delete(p2vm_frameset);
1076  cpl_frameset_delete(disp_frameset);
1077  cpl_free(calib_datas);
1078  gravi_data_delete(profile_map);
1079  gravi_data_delete(dark_map);
1080  gravi_data_delete(wave_map);
1081  gravi_data_delete(badpix_map);
1082  gravi_data_delete(p2vm_map);
1083  cpl_parameterlist_delete (preproc_parlist);
1084  cpl_frameset_delete(darkcalib_frameset);
1085  cpl_frameset_delete(wave_frameset);
1086  cpl_frameset_delete(dark_frameset);
1087  cpl_frameset_delete(gain_frameset);
1088  cpl_frameset_delete(badpix_frameset);
1089 
1090 
1091  return (int) cpl_error_set_message(cpl_func,
1092  CPL_ERROR_ILLEGAL_OUTPUT, "error while the compute "
1093  "of the visibilies");
1094  }
1095 
1096  nb_vis++;
1097 
1098  gravi_data_delete(p2vm_reduce);
1099  // cpl_msg_info(NULL, "Thread : %d : ==> End of thread",
1100  // omp_get_thread_num());
1101  }
1102 
1103  cpl_free(calib_datas);
1104  gravi_data_delete(profile_map);
1105  gravi_data_delete(dark_map);
1106  gravi_data_delete(wave_map);
1107  gravi_data_delete(badpix_map);
1108  gravi_data_delete(p2vm_map);
1109  cpl_parameterlist_delete (preproc_parlist);
1110  cpl_frameset_delete(darkcalib_frameset);
1111  cpl_frameset_delete(wave_frameset);
1112  cpl_frameset_delete(dark_frameset);
1113  cpl_frameset_delete(gain_frameset);
1114  cpl_frameset_delete(badpix_frameset);
1115  }
1116  else {
1117 
1118  oi_vis = gravi_data_new(0);
1119  /* Construction of the opd vector and phase matrix */
1120  disp_frameset = cpl_frameset_duplicate (p2vmreduce_frameset);
1121  nb_frame = cpl_frameset_get_size (p2vmreduce_frameset);
1122 
1123  for (i = 0; i < nb_frame; i++){
1124  frame = cpl_frameset_get_position(p2vmreduce_frameset, i);
1125  filename_ = cpl_frame_get_filename(frame);
1126  temp = strrchr(filename_, '/');
1127  filename = temp ? temp + 1 : filename_;
1128  cpl_msg_info (NULL, "Load the p2vm_reduce %s", filename);
1129 
1130 
1131  p2vm_reduce = gravi_data_load(filename_);
1132 
1133  if (i == 0) {
1134  vis_met = cpl_table_duplicate (gravi_data_get_table (p2vm_reduce,
1135  GRAVI_OI_VIS_MET_EXT));
1136  fddl = cpl_table_duplicate (gravi_data_get_table (p2vm_reduce,
1137  GRAVI_FDDL_EXT));
1138  }
1139 
1140  /* Get the p2vm of the metrology */
1141 
1142  cpl_msg_info (cpl_func, "reduce the visibilities");
1143  gravi_vis_reduce (oi_vis, p2vm_reduce, num_disp, parlist, "gravi_dual");
1144 
1145  if (cpl_error_get_code()){
1146  cpl_propertylist_delete (met_plist);
1147  gravi_data_delete(p2vm_reduce);
1148  return (int) cpl_error_set_message(cpl_func,
1149  CPL_ERROR_ILLEGAL_OUTPUT, "Error while computing "
1150  "the visibilities");
1151  }
1152 
1153  num_disp ++;
1154 
1155  gravi_data_delete (p2vm_reduce);
1156 
1157 
1158  // printf("cpl_frameset_delete (preproc_frame);\n");
1159  // printf("data\n");
1160 
1161  // printf("fin\n");
1162  }
1163 
1164 
1165  }
1166 
1167  /* Save the out put data file */
1168 
1169  primary_hdr = gravi_data_get_propertylist(oi_vis,
1170  GRAVI_PRIMARY_HDR_NAME_EXT);
1171  applist = gravi_propertylist_get_qc (primary_hdr);
1172 
1173  cpl_propertylist_append_int(applist, GRAVI_NIGHT_OBS,
1174  cpl_propertylist_get_int (primary_hdr, GRAVI_NIGHT_OBS));
1175  cpl_propertylist_append_string(applist, "DATE-OBS",
1176  cpl_propertylist_get_string (primary_hdr, "DATE-OBS"));
1177 // temp = strchr(filename, '.');
1178  //vis_name = cpl_sprintf("vis_dual_science.%s", filename);
1179  vis_name = gravi_data_product_name (filename, "visDualSci");
1180  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, VIS_DUAL_SCIENCE);
1181 
1182  if (gravi_data_save(oi_vis, frameset, vis_name, parlist,
1183  p2vmreduce_frameset, frame, "gravi_all_disp", applist)
1184  != CPL_ERROR_NONE){
1185 // gravi_data_delete(p2vm_map);
1186  gravi_data_delete(oi_vis);
1187  cpl_frameset_delete(p2vmreduce_frameset);
1188  cpl_frameset_delete(disp_frameset);
1189  cpl_propertylist_delete(applist);
1190 
1191  return (int) cpl_error_set_message(cpl_func,
1192  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the oi_vis"
1193  " on the output file");
1194  }
1195 
1196  cpl_propertylist_delete(applist);
1197  cpl_free (vis_name);
1198 
1199 
1200  cpl_frameset_delete(p2vmreduce_frameset);
1201 
1202  /* Compute the dispersion table of a set of disp frames */
1203 
1204  disp_map = gravi_compute_disp(oi_vis, vis_met , fddl);
1205 
1206  if (cpl_error_get_code()) {
1207  cpl_frameset_delete(disp_frameset);
1208 
1209  gravi_data_delete(disp_map);
1210  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
1211  "Error while computing the disp_map");
1212  }
1213 
1214  /* Create product frame, add DataFlow keywords, save the file, log the
1215  * saved file in the input frameset */
1216 
1217  // char * disp_name = cpl_sprintf("disp.%s", filename);
1218  char * disp_name = gravi_data_product_name (filename, "disp");
1219 
1220  disp_plist = gravi_data_get_propertylist(disp_map, GRAVI_PRIMARY_HDR_NAME_EXT);
1221  applist = gravi_propertylist_get_qc (disp_plist);
1222  frame = cpl_frameset_get_position(disp_frameset, 0);
1223  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, DISP_MODEL);
1224 
1225  if (gravi_data_save( disp_map, frameset, disp_name, parlist,
1226  disp_frameset, frame, "gravi_all_disp", applist)
1227  != CPL_ERROR_NONE){
1228 
1229  gravi_data_delete(disp_map);
1230  cpl_frameset_delete(disp_frameset);
1231  cpl_propertylist_delete(applist);
1232  return (int) cpl_error_set_message(cpl_func,
1233  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the disp map"
1234  " on the output file");
1235  }
1236  /* Deallocation of all variables */
1237  gravi_data_delete(oi_vis);
1238  cpl_free (disp_name);
1239  gravi_data_delete(disp_map);
1240  cpl_table_delete (vis_met);
1241  cpl_table_delete (fddl);
1242  cpl_frameset_delete(disp_frameset);
1243  cpl_propertylist_delete(applist);
1244 
1245  return (int)cpl_error_get_code();
1246 }
1247 
1248