GRAVI Pipeline Reference Manual  0.6.3
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 median of a raw dark set of integration.",
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 
131  /* Do not create the recipe if an error code is already set */
132  if (cpl_error_get_code() != CPL_ERROR_NONE) {
133  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
134  cpl_func, __LINE__, cpl_error_get_where());
135  return (int)cpl_error_get_code();
136  }
137 
138  if (plugin == NULL) {
139  cpl_msg_error(cpl_func, "Null plugin");
140  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
141  }
142 
143  /* Verify plugin type */
144  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
145  cpl_msg_error(cpl_func, "Plugin is not a recipe");
146  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
147  }
148 
149  /* Get the recipe */
150  recipe = (cpl_recipe *)plugin;
151 
152  /* Create the parameters list in the cpl_recipe object */
153  recipe->parameters = cpl_parameterlist_new();
154  if (recipe->parameters == NULL) {
155  cpl_msg_error(cpl_func, "Parameter list allocation failed");
156  cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
157  }
158 
159  /* Fill the parameters list */
160 
161  return 0;
162 }
163 
164 /*----------------------------------------------------------------------------*/
170 /*----------------------------------------------------------------------------*/
171 static int gravi_all_disp_exec(cpl_plugin * plugin)
172 {
173 
174  cpl_recipe * recipe;
175  int recipe_status;
176  cpl_errorstate initial_errorstate = cpl_errorstate_get();
177 
178  /* Return immediately if an error code is already set */
179  if (cpl_error_get_code() != CPL_ERROR_NONE) {
180  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
181  cpl_func, __LINE__, cpl_error_get_where());
182  return (int)cpl_error_get_code();
183  }
184 
185  if (plugin == NULL) {
186  cpl_msg_error(cpl_func, "Null plugin");
187  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
188  }
189 
190  /* Verify plugin type */
191  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
192  cpl_msg_error(cpl_func, "Plugin is not a recipe");
193  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
194  }
195 
196  /* Get the recipe */
197  recipe = (cpl_recipe *)plugin;
198 
199  /* Verify parameter and frame lists */
200  if (recipe->parameters == NULL) {
201  cpl_msg_error(cpl_func, "Recipe invoked with NULL parameter list");
202  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
203  }
204  if (recipe->frames == NULL) {
205  cpl_msg_error(cpl_func, "Recipe invoked with NULL frame set");
206  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
207  }
208 
209  /* Invoke the recipe */
210  recipe_status = gravi_all_disp(recipe->frames, recipe->parameters);
211 
212  /* Ensure DFS-compliance of the products */
213  if (cpl_dfs_update_product_header(recipe->frames)) {
214  if (!recipe_status) recipe_status = (int)cpl_error_get_code();
215  }
216 
217  if (!cpl_errorstate_is_equal(initial_errorstate)) {
218  /* Dump the error history since recipe execution start.
219  At this point the recipe cannot recover from the error */
220  cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
221  }
222 
223  return recipe_status;
224 }
225 
226 /*----------------------------------------------------------------------------*/
232 /*----------------------------------------------------------------------------*/
233 static int gravi_all_disp_destroy(cpl_plugin * plugin)
234 {
235  cpl_recipe * recipe;
236  cpl_parameter * p;
237  if (plugin == NULL) {
238  cpl_msg_error(cpl_func, "Null plugin");
239  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
240  }
241 
242  /* Verify plugin type */
243  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
244  cpl_msg_error(cpl_func, "Plugin is not a recipe");
245  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
246  }
247 
248  /* Get the recipe */
249  recipe = (cpl_recipe *)plugin;
250 
251  /* Get the recipe */
252  recipe = (cpl_recipe *)plugin;
253 
254  /* Create the parameters list in the cpl_recipe object */
255  recipe->parameters = cpl_parameterlist_new();
256  if (recipe->parameters == NULL) {
257  cpl_msg_error(cpl_func, "Parameter list allocation failed");
258  cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
259  }
260 
261  /* Fill the parameters list */
262 
263  /* --Save the preproc files */
264  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.p2vmreduce_file",
265  CPL_TYPE_BOOL, "Save the reduced p2vm file", "gravi.gravi_all_p2vm", TRUE);
266  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "p2vmfile");
267  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
268  cpl_parameterlist_append(recipe->parameters, p);
269 
270  /* --Extract the real opd from the metrology */
271  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.opd_met",
272  CPL_TYPE_BOOL, "extract the real opd from the metrology",
273  "gravi.gravi_all_p2vm", TRUE);
274  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "extmetrology");
275  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
276  cpl_parameterlist_append(recipe->parameters, p);
277 
278  /* --the minimum wavelength */
279  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.min_wave",
280  CPL_TYPE_DOUBLE, "the minimum wavelength", "gravi.gravi_all_p2vm", 2.0);
281  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdamin");
282  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
283  cpl_parameterlist_append(recipe->parameters, p);
284 
285  /* --the maximum wavelength */
286  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.max_wave",
287  CPL_TYPE_DOUBLE, "the maximum wavelength", "gravi.gravi_all_p2vm", 2.6);
288  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdamax");
289  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
290  cpl_parameterlist_append(recipe->parameters, p);
291 
292  /* --the sigma readout SC */
293  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.readoutSC",
294  CPL_TYPE_DOUBLE, "the readout error sigma SC", "gravi.gravi_all_p2vm", 1.0);
295  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_readout_SC");
296  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
297  cpl_parameterlist_append(recipe->parameters, p);
298 
299  /* --the sigma readout FT */
300  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.readoutFT",
301  CPL_TYPE_DOUBLE, "the readout error sigma FT", "gravi.gravi_all_p2vm", 1.0);
302  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_readout_FT");
303  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
304  cpl_parameterlist_append(recipe->parameters, p);
305 
306  /* --the number of the spectral element to compute for FT data */
307  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.nspectrum_FT",
308  CPL_TYPE_INT, "the number of the spectral", "gravi.gravi_all_p2vm", 5);
309  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "nlambda_ft");
310  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
311  cpl_parameterlist_append(recipe->parameters, p);
312 
313  /* --the number of the spectral element to compute for SC data */
314  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.nspectrum_SC",
315  CPL_TYPE_INT, "the number of the spectral", "gravi.gravi_all_p2vm", 5);
316  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "nlambda_sc");
317  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
318  cpl_parameterlist_append(recipe->parameters, p);
319 
320  /* --the width of the profile element */
321  p = cpl_parameter_new_value("gravi.gravi_all_flat."
322  "profile_width", CPL_TYPE_INT, "profile width option",
323  "gravi.gravi_all_flat", 5);
324  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "profile_width");
325  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
326  cpl_parameterlist_append(recipe->parameters, p);
327 
328  /* --the background correction */
329  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.correction",
330  CPL_TYPE_STRING, "the background correction", "gravi.gravi_all_p2vm", "DARK");
331  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "background");
332  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
333  cpl_parameterlist_append(recipe->parameters, p);
334 
335  p = cpl_parameter_new_value("gravi."
336  "flat_param.Bad_dark_threshold", CPL_TYPE_INT, "the rms factor for "
337  "dark bad pixel threshold", "gravi.gravi_all_flat", 5);
338  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "Bad_dark_threshold");
339  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
340  cpl_parameterlist_append(recipe->parameters, p);
341 
342  return 0;
343 }
344 
345 
346 /*----------------------------------------------------------------------------*/
354 /*----------------------------------------------------------------------------*/
355 static int gravi_all_disp(cpl_frameset * frameset,
356  const cpl_parameterlist * parlist)
357 {
358  cpl_frameset * disp_frameset, * wavecalib_frameset, * darkcalib_frameset,
359  * gaincalib_frameset, * dark_frameset, * wave_frameset,
360  * badpix_frameset, * gain_frameset, * p2vmreduce_frameset, * p2vm_frameset;
361  cpl_propertylist * applist, * primary_hdr, * primary_hdr_dark, * disp_plist,
362  * primary_hdr_wave, * bad_primary_hdr, * profile_primary_hdr;
363  cpl_frame * frame;
364  const cpl_parameter * p;
365  char * out_dark, * out_wave, * preproc_name, * out_gain;
366  const char * filename;/*, * insname;*/
367  gravi_data * disp_map, * data, * dark_map, * wave_map,
368  * profile_map, * badpix_map, * p2vm_reduce;
369  gravi_data ** calib_datas;
370  gravi_data * preproc_data, * p2vm_map;
371  gravi_data ** raw_data;
372  dark_map = NULL, wave_map = NULL;
373  int nb_frame, i, nb_frame_gain;
374  int rest, num_disp, nwave_sc;
375  double gain_ft, gain_sc, mjd_obs;
376  int * shutter;
377  cpl_table * p2vm_met = NULL, * metrology_table, * opl_table = NULL, * disp_table;
378 
379  cpl_propertylist * met_plist;
380  cpl_frameset * preproc_frame;
381  cpl_matrix * phase_matrix;
382  cpl_vector ** opd_vector;
383 // double dit, darkmean, minwave, maxwave, darkrms;
384 
385  /* Identify the RAW and CALIB frames in the input frameset */
386 
387  cpl_ensure_code(gravi_dfs_set_groups(frameset) == CPL_ERROR_NONE,
388  cpl_error_get_code()) ;
389 
390 
391  /* - Extract a set of frame p2vm and set of frame dark wave */
392  p2vmreduce_frameset = gravi_frameset_extract_p2vmreduce_data(frameset);
393  p2vm_frameset = gravi_frameset_extract_p2vm_file(frameset);
394  if (cpl_frameset_is_empty(p2vmreduce_frameset)){
395  disp_frameset = gravi_frameset_extract_disp_data(frameset);
396  wavecalib_frameset = gravi_frameset_extract_wave_file(frameset);
397  darkcalib_frameset = gravi_frameset_extract_dark_file(frameset);
398  gaincalib_frameset = gravi_frameset_extract_flat_file(frameset);
399  wave_frameset = gravi_frameset_extract_wave(frameset);
400  dark_frameset = gravi_frameset_extract_dark(frameset);
401  gain_frameset = gravi_frameset_extract_flat(frameset);
402  badpix_frameset = gravi_frameset_extract_badpix(frameset);
403  if (cpl_frameset_is_empty(disp_frameset) ||
404  cpl_frameset_is_empty(p2vm_frameset)) {
405  /* To use this recipe the frameset must contain at least
406  * one p2vm frame. */
407  cpl_frameset_delete(dark_frameset);
408  cpl_frameset_delete(wave_frameset);
409  cpl_frameset_delete(gain_frameset);
410  cpl_frameset_delete(disp_frameset);
411  cpl_frameset_delete(wavecalib_frameset);
412  cpl_frameset_delete(wavecalib_frameset);
413  cpl_frameset_delete(gaincalib_frameset);
414  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
415  "No dispersion or p2vm frame on the frameset") ;
416  }
417 
418  /* Identify and extract the dark and wave fits files */
419  /* Check and get the dark frame */
420 
421  if (!cpl_frameset_is_empty(dark_frameset)) {
422  frame = cpl_frameset_get_position(dark_frameset, 0);
423 
424  filename = cpl_frame_get_filename(frame);
425  cpl_msg_info (NULL, "This file %s is a dark file", filename);
426  data = gravi_data_load(filename);
427  primary_hdr = gravi_data_get_propertylist(data,
428  GRAVI_PRIMARY_HDR_NAME_EXT);
429  shutter = gravi_shutters_check(primary_hdr);
430  if (!((shutter[0] == 0) && (shutter[1] == 0) && (shutter[2] == 0)
431  && (shutter[3] == 0))){
432  cpl_frameset_delete(dark_frameset);
433  cpl_frameset_delete(wave_frameset);
434  cpl_frameset_delete(gain_frameset);
435  cpl_frameset_delete(darkcalib_frameset);
436  cpl_frameset_delete(wavecalib_frameset);
437  cpl_frameset_delete(gaincalib_frameset);
438  cpl_frameset_delete(disp_frameset);
439  gravi_data_delete(data);
440  return (int)cpl_error_set_message(cpl_func,
441  CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem");
442  }
443  /* The dark file must contains all the shutter close */
444 
445  dark_map = gravi_compute_dark(data);
446  if (cpl_error_get_code()) {
447  cpl_frameset_delete(dark_frameset);
448  cpl_frameset_delete(wave_frameset);
449  cpl_frameset_delete(gain_frameset);
450  cpl_frameset_delete(darkcalib_frameset);
451  cpl_frameset_delete(wavecalib_frameset);
452  cpl_frameset_delete(gaincalib_frameset);
453  gravi_data_delete(dark_map);
454  cpl_frameset_delete(disp_frameset);
455  cpl_propertylist_delete(applist);
456  gravi_data_delete(data);
457  return (int)cpl_error_set_message(cpl_func,
458  CPL_ERROR_ILLEGAL_OUTPUT,
459  "Error while computing the dark_map");
460  }
461 
462  /* Save the dark map */
463  cpl_frameset_insert(darkcalib_frameset, cpl_frame_duplicate(frame));
464  primary_hdr_dark = gravi_data_get_propertylist(dark_map,
465  GRAVI_PRIMARY_HDR_NAME_EXT);
466  applist = gravi_propertylist_get_qc (primary_hdr_dark);
467 // dit = gravi_pfits_get_dit(primary_hdr_dark);
468  //insname = gravi_pfits_get_insname(primary_hdr_dark);
469 
470  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
471  DARK);
472 
473 // cpl_propertylist_append_double(applist, GRAVI_DET_DIT, dit);
474  //cpl_propertylist_append_string(applist, "INSNAME", insname);
475 
476  out_dark = "gravi_final_dark.fits";
477 
478  if (gravi_data_save(dark_map, frameset, out_dark, parlist,
479  darkcalib_frameset, frame, "gravi_all_disp", applist)
480  != CPL_ERROR_NONE){
481  cpl_frameset_delete(dark_frameset);
482  cpl_frameset_delete(wave_frameset);
483  cpl_frameset_delete(gain_frameset);
484  cpl_frameset_delete(darkcalib_frameset);
485  cpl_frameset_delete(wavecalib_frameset);
486  cpl_frameset_delete(gaincalib_frameset);
487  gravi_data_delete(dark_map);
488  cpl_frameset_delete(disp_frameset);
489  cpl_propertylist_delete(applist);
490  gravi_data_delete(data);
491 
492  return (int) cpl_error_set_message(cpl_func,
493  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the dark_map"
494  " on the output file");
495  }
496  cpl_propertylist_delete(applist);
497 
498  gravi_data_delete(data);
499  cpl_free(shutter);
500 
501  }
502  else if (!cpl_frameset_is_empty(darkcalib_frameset)){
503  frame = cpl_frameset_get_position(darkcalib_frameset, 0);
504  cpl_frameset_insert (dark_frameset, cpl_frame_duplicate (frame));
505  filename = cpl_frame_get_filename(frame);
506 
507  cpl_msg_info (NULL, "This file %s is a dark file already "
508  "computed", filename);
509  dark_map = gravi_data_load(filename);
510 
511  }
512 
513  /* Check that the dark_map in the input frameset */
514  else {
515  cpl_frameset_delete(dark_frameset);
516  cpl_frameset_delete(wave_frameset);
517  cpl_frameset_delete(gain_frameset);
518  cpl_frameset_delete(disp_frameset);
519  cpl_frameset_delete(darkcalib_frameset);
520  cpl_frameset_delete(wavecalib_frameset);
521  cpl_frameset_delete(gaincalib_frameset);
522  gravi_data_delete(dark_map);
523  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
524  "No dark frames in the frameset");
525  }
526 
527 
528 
529  /* Compute the bad pixel map */
530  if (!cpl_frameset_is_empty(badpix_frameset)){
531  frame = cpl_frameset_get_position(badpix_frameset, 0);
532  filename = cpl_frame_get_filename(frame);
533  cpl_msg_info (NULL, "This file %s is a bad pixel map", filename);
534 
535  badpix_map = gravi_data_load(filename);
536  }
537  else {
538 
539  badpix_map = gravi_compute_badpix(dark_map, parlist);
540 
541  if (cpl_error_get_code()) {
542  gravi_data_delete(badpix_map);
543  cpl_frameset_delete(dark_frameset);
544  cpl_frameset_delete(wave_frameset);
545  cpl_frameset_delete(gain_frameset);
546  cpl_frameset_delete(disp_frameset);
547  cpl_frameset_delete(darkcalib_frameset);
548  cpl_frameset_delete(wavecalib_frameset);
549  cpl_frameset_delete(gaincalib_frameset);
550  gravi_data_delete(dark_map);
551  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
552  "Error while computing the bad pixel map");
553 
554  }
555  /* Save the pad pixel map */
556  bad_primary_hdr = gravi_data_get_propertylist (badpix_map,
557  GRAVI_PRIMARY_HDR_NAME_EXT);
558  applist = gravi_propertylist_get_qc (bad_primary_hdr);
559 
560  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, BAD);
561 
562  frame = cpl_frameset_get_position (dark_frameset, 0);
563 
564  if (gravi_data_save (badpix_map, frameset, "gravi_bad_map.fits", parlist,
565  dark_frameset, frame, "gravi_all_disp", applist)
566  != CPL_ERROR_NONE){
567 
568  gravi_data_delete(badpix_map);
569  cpl_frameset_delete(dark_frameset);
570  cpl_frameset_delete(wave_frameset);
571  cpl_frameset_delete(gain_frameset);
572  cpl_frameset_delete(disp_frameset);
573  cpl_frameset_delete(darkcalib_frameset);
574  cpl_frameset_delete(wavecalib_frameset);
575  cpl_frameset_delete(gaincalib_frameset);
576  cpl_frameset_delete(badpix_frameset);
577  gravi_data_delete(dark_map);
578  return (int) cpl_error_set_message(cpl_func,
579  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the bad pixel map");
580  }
581  cpl_propertylist_delete (applist);
582  }
583 
584  cpl_frameset_delete(dark_frameset);
585  cpl_frameset_delete(badpix_frameset);
586 
587  /* Check that the gain map in the input frameset */
588  if (cpl_error_get_code()){
589  cpl_frameset_delete(disp_frameset);
590  cpl_frameset_delete(wavecalib_frameset);
591  cpl_frameset_delete(wave_frameset);
592  cpl_frameset_delete(gain_frameset);
593  gravi_data_delete(badpix_map);
594  gravi_data_delete(dark_map);
595  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
596  "Compute of the gain failed");
597  }
598 
599  if ((!cpl_frameset_is_empty(gain_frameset)) &&
600  (cpl_frameset_is_empty(gaincalib_frameset)) ) {
601  /* Identify the flat file */
602  nb_frame_gain = cpl_frameset_get_size (gain_frameset);//nb_frame;
603  raw_data = cpl_malloc(nb_frame_gain * sizeof(gravi_data *));
604 
605 
606 
607  for (i = 0; i < nb_frame_gain; i++){
608  frame = cpl_frameset_get_position(gain_frameset, i);
609  filename = cpl_frame_get_filename(frame);
610  raw_data[i] = gravi_data_load(filename);
611  primary_hdr = gravi_data_get_propertylist(raw_data[i],
612  GRAVI_PRIMARY_HDR_NAME_EXT);
613  shutter = gravi_shutters_check(primary_hdr);
614  cpl_free(shutter);
615 
616  }
617 
618  /* Compute the gain and extract the gain map*/
619  gain_sc = gravi_compute_gain(raw_data, nb_frame_gain, dark_map,
620  GRAVI_IMAGING_DATA_SC_EXT);
621  gain_ft = gravi_compute_gain(raw_data, nb_frame_gain, dark_map,
622  GRAVI_IMAGING_DATA_FT_EXT);
623  /* Compute the profile */
624  profile_map = gravi_compute_profile(raw_data, dark_map, badpix_map,
625  nb_frame_gain, parlist);
626 
627  if (cpl_error_get_code()){
628  cpl_frameset_delete(disp_frameset);
629  cpl_frameset_delete(wavecalib_frameset);
630  cpl_frameset_delete(wave_frameset);
631  cpl_frameset_delete(gain_frameset);
632  gravi_data_delete(profile_map);
633  gravi_data_delete(dark_map);
634  for (i = 0; i < nb_frame_gain; i++){
635  gravi_data_delete(raw_data[i]);
636  }
637  cpl_free(raw_data);
638  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
639  "Compute of the profile map failed");
640  }
641  profile_primary_hdr = gravi_data_get_propertylist(profile_map,
642  GRAVI_PRIMARY_HDR_NAME_EXT);
643  /* Save the profile map */
644  applist = gravi_propertylist_get_qc (profile_primary_hdr);
645  cpl_propertylist_append_double (applist, QC_MEANGAIN_FT, gain_ft);
646  cpl_propertylist_append_double (applist, QC_MEANGAIN_SC, gain_sc);
647 
648  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, FLAT);
649 
650  out_gain = "gravi_final_profile.fits";
651  frame = cpl_frameset_get_position(gain_frameset, 0);
652  if (gravi_data_save(profile_map, frameset, out_gain, parlist,
653  gain_frameset, frame, "gravi_all_disp", applist)
654  != CPL_ERROR_NONE){
655 
656  cpl_frameset_delete(wavecalib_frameset);
657  cpl_frameset_delete(gaincalib_frameset);
658  cpl_frameset_delete(wave_frameset);
659  cpl_frameset_delete(gain_frameset);
660  for (i = 0; i < nb_frame_gain; i++){
661  gravi_data_delete(raw_data[i]);
662  }
663  cpl_free(raw_data);
664  gravi_data_delete(dark_map);
665  gravi_data_delete(profile_map);
666  cpl_frameset_delete(disp_frameset);
667  cpl_propertylist_delete(applist);
668 
669  return (int) cpl_error_set_message(cpl_func,
670  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the profile_map"
671  " on the output file");
672  }
673  cpl_propertylist_delete(applist);
674 
675  for (i = 0; i < nb_frame_gain; i++){
676  gravi_data_delete(raw_data[i]);
677  }
678  cpl_free(raw_data);
679  }
680 
681  else {
682 
683  frame = cpl_frameset_get_position(gaincalib_frameset, 0);
684 
685  filename = cpl_frame_get_filename(frame);
686  cpl_msg_info (NULL, "This file %s is a flat file already "
687  "computed", filename);
688  profile_map = gravi_data_load(filename);
689 
690  }
691 
692  cpl_frameset_delete(gaincalib_frameset);
693  cpl_frameset_delete(gain_frameset);
694 
695 
696  /* Check and get the wave frame */
697 
698 
699  p = cpl_parameterlist_find_const(parlist, "gravi.gravi_all_p2vm."
700  "opd_met");
701  if ((!cpl_frameset_is_empty(wave_frameset)) &&
702  (cpl_frameset_is_empty(wavecalib_frameset))) {
703  frame = cpl_frameset_get_position(wave_frameset, 0);
704 
705  filename = cpl_frame_get_filename(frame);
706  cpl_msg_info (NULL, "This file %s is a wave file", filename);
707  data = gravi_data_load(filename);
708  primary_hdr = gravi_data_get_propertylist(data,
709  GRAVI_PRIMARY_HDR_NAME_EXT);
710  shutter = gravi_shutters_check(primary_hdr);
711  if (!((shutter[0] == 1) && (shutter[1] == 1) && (shutter[2] == 1)
712  && (shutter[3] == 1))){
713  cpl_frameset_delete(wavecalib_frameset);
714  cpl_frameset_delete(wave_frameset);
715  gravi_data_delete(dark_map);
716  cpl_frameset_delete(disp_frameset);
717  gravi_data_delete(data);
718  gravi_data_delete(profile_map);
719  return (int)cpl_error_set_message(cpl_func,
720  CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem");
721  }
722 
723 
724  /* Compute the p2vm of the metrology */
725  if (cpl_parameter_get_bool (p)){
726 
727  metrology_table = gravi_data_get_table(data,
728  GRAVI_METROLOGY_EXT);
729  met_plist = cpl_propertylist_duplicate(
730  gravi_data_get_propertylist(data,
731  GRAVI_METROLOGY_EXT));
732  if ((cpl_table_get_nrow(metrology_table)%4) != 0)
733  rest = 4 + (cpl_table_get_nrow(metrology_table)%4) ;
734  else
735  rest = 4;
736  mjd_obs = gravi_pfits_get_mjd (primary_hdr);
737 
738  opl_table = cpl_table_new (cpl_table_get_nrow(metrology_table) - rest);
739  p2vm_met = gravi_metrology_calibration (metrology_table,
740  opl_table, mjd_obs);
741  }
742  /* The wave file must contains all the shutters open */
743  wave_map = gravi_compute_wave(data, profile_map, dark_map, badpix_map,
744  opl_table, parlist);
745 
746  cpl_table_delete (opl_table);
747 
748  if (cpl_error_get_code()) {
749  cpl_frameset_delete(wavecalib_frameset);
750  cpl_frameset_delete(wave_frameset);
751  gravi_data_delete(dark_map);
752  gravi_data_delete(wave_map);
753  cpl_frameset_delete(disp_frameset);
754  gravi_data_delete(data);
755  gravi_data_delete(profile_map);
756  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
757  "Error while computing the wave_map");
758  }
759  /* Save the wave map */
760 
761  primary_hdr_wave = gravi_data_get_propertylist(wave_map,
762  GRAVI_PRIMARY_HDR_NAME_EXT);
763  applist = gravi_propertylist_get_qc (primary_hdr_wave);
764 // dit = gravi_pfits_get_dit(primary_hdr_wave);
765  //insname = gravi_pfits_get_insname(primary_hdr_wave);
766 
767  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
768  WAVE);
769 
770 // cpl_propertylist_append_double(applist, GRAVI_DET_DIT, dit);
771  //cpl_propertylist_append_string(applist, "INSNAME", insname);
772 
773  out_wave = "gravi_final_wave.fits";
774  if (gravi_data_save(wave_map, frameset, out_wave, parlist,
775  wave_frameset, frame, "gravi_all_disp", applist)
776  != CPL_ERROR_NONE){
777 
778  cpl_frameset_delete(wavecalib_frameset);
779  cpl_frameset_delete(wave_frameset);
780  gravi_data_delete(dark_map);
781  gravi_data_delete(wave_map);
782  cpl_frameset_delete(disp_frameset);
783  cpl_propertylist_delete(applist);
784  gravi_data_delete(data);
785  gravi_data_delete(profile_map);
786  return (int) cpl_error_set_message(cpl_func,
787  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the wave_map"
788  " on the output file");
789  }
790 
791  cpl_propertylist_delete(applist);
792 
793  gravi_data_delete(data);
794  cpl_free(shutter);
795 
796  }
797  else {
798 
799  frame = cpl_frameset_get_position(wavecalib_frameset, 0);
800 
801  filename = cpl_frame_get_filename(frame);
802 
803  cpl_msg_info (NULL, "This file %s is a wave file already "
804  "computed", filename);
805  wave_map = gravi_data_load(filename);
806 
807  }
808 
809 
810  /* Check that wave_map exist in the input frameset */
811  if (wave_map == NULL){
812  cpl_frameset_delete(disp_frameset);
813  cpl_frameset_delete(wavecalib_frameset);
814  cpl_frameset_delete(wave_frameset);
815  gravi_data_delete(wave_map);
816  gravi_data_delete(profile_map);
817  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
818  "No wave frames in the frameset");
819  }
820 
821  cpl_frameset_delete(wavecalib_frameset);
822  cpl_frameset_delete(wave_frameset);
823 
824  calib_datas = cpl_malloc(4 * sizeof(gravi_data *));
825  calib_datas[0] = dark_map;
826  calib_datas[1] = wave_map;
827  calib_datas[2] = profile_map;
828  calib_datas[3] = badpix_map;
829 
830  /* Load the p2vm data */
831  frame = cpl_frameset_get_position(p2vm_frameset, 0);
832  filename = cpl_frame_get_filename(frame);
833  cpl_msg_info (NULL, "This file %s is a p2vm file already "
834  "computed", filename);
835 
836  p2vm_map = gravi_data_load (filename);
837 
838  if (cpl_error_get_code()) {
839  cpl_frameset_delete(darkcalib_frameset);
840  cpl_frameset_delete(p2vm_frameset);
841  cpl_frameset_delete(dark_frameset);
842  cpl_frameset_delete(wave_frameset);
843  cpl_frameset_delete(gain_frameset);
844  gravi_data_delete(profile_map);
845  gravi_data_delete(dark_map);
846  gravi_data_delete(wave_map);
847  gravi_data_delete(p2vm_map);
848  gravi_data_delete(p2vm_map);
849  gravi_data_delete(badpix_map);
850 
851  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
852  "Error while loading the p2vm_map");
853  }
854 
855  /* Get the number of the p2vm frame contained in the frameset */
856  nb_frame = cpl_frameset_get_size(disp_frameset);
857 
858  p = cpl_parameterlist_find_const(parlist, "gravi.gravi_all_p2vm."
859  "preproc_param.p2vmreduce_file");
860 
861 
862 
863  /* Construction of the opd vector and phase matrix */
864  num_disp = 0;
865  nwave_sc = gravi_pfits_get_nwave (gravi_data_get_propertylist (wave_map, GRAVI_IO_WAVELENGTH_SC_EXT));
866  opd_vector = cpl_malloc (nwave_sc * sizeof(cpl_vector *));
867  phase_matrix = cpl_malloc (sizeof(cpl_matrix *));
868 
869 
870  for (i = 0; i < nb_frame; i++){
871  frame = cpl_frameset_get_position(disp_frameset, i);
872  filename = cpl_frame_get_filename(frame);
873  cpl_msg_info (NULL, "Calibration of this file %s", filename);
874  data = gravi_data_load(filename);
875  primary_hdr = gravi_data_get_propertylist(data,
876  GRAVI_PRIMARY_HDR_NAME_EXT);
877  shutter = gravi_shutters_check(primary_hdr);
878 
879  if ((shutter[0] == 1) && (shutter[1] == 1) && (shutter[2] == 1)
880  && (shutter[3] == 1)){
881 
882  /* Compute the p2vm of the metrology */
883  metrology_table = gravi_data_get_table(data,
884  GRAVI_METROLOGY_EXT);
885 
886  if (p2vm_met == NULL){
887  met_plist = cpl_propertylist_duplicate
888  (gravi_data_get_propertylist (data, GRAVI_METROLOGY_EXT));
889  if ((cpl_table_get_nrow(metrology_table)%4) != 0)
890  rest = 4 + (cpl_table_get_nrow(metrology_table)%4) ;
891  else
892  rest = 4;
893  mjd_obs = gravi_pfits_get_mjd (primary_hdr);
894  opl_table = cpl_table_new (cpl_table_get_nrow(metrology_table) - rest);
895  p2vm_met = gravi_metrology_calibration (metrology_table,
896  opl_table, mjd_obs);
897  if (cpl_error_get_code()) {
898  cpl_frameset_delete(disp_frameset);
899  cpl_free(calib_datas);
900  gravi_data_delete(dark_map);
901  gravi_data_delete(wave_map);
902  gravi_data_delete(profile_map);
903  gravi_data_delete(badpix_map);
904  gravi_data_delete(data);
905  gravi_data_delete (p2vm_map);
906  cpl_table_delete (opl_table);
907  cpl_table_delete (p2vm_met);
908  cpl_propertylist_delete (met_plist);
909  cpl_free (shutter);
910  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
911  "Error while computing p2vm metrology");
912  }
913  cpl_table_delete (opl_table);
914 
915  }
916 
917 
918  clock_t start, end;
919  start = clock();
920  preproc_data = gravi_preproc(data, calib_datas, 4, parlist);
921  end = clock();
922  printf ("Temps gravi_preproc %s : %f\n", filename, (end - start) / (double)CLOCKS_PER_SEC);
923  gravi_data_delete(data);
924 
925  if (cpl_error_get_code()) {
926  cpl_frameset_delete(disp_frameset);
927 
928  gravi_data_delete(badpix_map);
929  cpl_table_delete (opl_table);
930  cpl_table_delete (p2vm_met);
931  cpl_propertylist_delete (met_plist);
932  cpl_free (shutter);
933  gravi_data_delete(preproc_data);
934  cpl_free(calib_datas);
935  gravi_data_delete(dark_map);
936  gravi_data_delete(wave_map);
937  gravi_data_delete (p2vm_map);
938  gravi_data_delete(profile_map);
939  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
940  "Error while computing the preproc data_map");
941  }
942 
943  p2vm_reduce = gravi_p2vm_reduce (preproc_data, p2vm_map, "gravi_single");
944 
945  cpl_propertylist_set_string (met_plist, "EXTNAME",
946  GRAVI_P2VM_MET_EXT);
947 
948  gravi_data_add (p2vm_reduce, met_plist, p2vm_met);
949 
950  gravi_data_delete(preproc_data);
951  /* Option save the proproc file */
952  if (cpl_parameter_get_bool(p)){
953  preproc_frame = cpl_frameset_new ();
954  cpl_frameset_insert (preproc_frame, cpl_frame_duplicate (frame));
955  preproc_name = cpl_sprintf("p2vm_reduce_%s", filename);
956 
957  applist = gravi_propertylist_get_qc (gravi_data_get_propertylist
958  (p2vm_reduce, GRAVI_PRIMARY_HDR_NAME_EXT));
959 
960 
961  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, PREPROC);
962 
963 
964  gravi_data_save(p2vm_reduce, frameset, preproc_name, parlist,
965  preproc_frame, frame, "gravi_all_disp", applist);
966 
967  // gravi_data_save_data(preproc_data[i], preproc_name, CPL_IO_CREATE);
968  cpl_free(preproc_name);
969  cpl_propertylist_delete (applist);
970  cpl_frameset_delete (preproc_frame);
971 
972  }
973 
974 
975  if (gravi_disp_opd_phase_wrap (p2vm_reduce, p2vm_met, opd_vector, phase_matrix, num_disp) != CPL_ERROR_NONE){
976 
977  gravi_data_delete(badpix_map);
978  cpl_table_delete (opl_table);
979  cpl_table_delete (p2vm_met);
980  cpl_propertylist_delete (met_plist);
981  cpl_free (shutter);
982  gravi_data_delete(preproc_data);
983  cpl_free(calib_datas);
984  gravi_data_delete(dark_map);
985  gravi_data_delete(wave_map);
986  gravi_data_delete (p2vm_map);
987  gravi_data_delete(profile_map);
988  gravi_data_delete(p2vm_reduce);
989  return (int) cpl_error_set_message(cpl_func,
990  CPL_ERROR_ILLEGAL_OUTPUT, "Error while computing the dispersion");
991  }
992  if (num_disp){
993  disp_map = gravi_data_new (0);
994  gravi_data_set_propertylist(disp_map,
995  GRAVI_PRIMARY_HDR_NAME_EXT, primary_hdr);
996  }
997  num_disp ++;
998 
999  gravi_data_delete (p2vm_reduce);
1000 
1001  }
1002 // printf("cpl_frameset_delete (preproc_frame);\n");
1003  cpl_free (shutter);
1004 // printf("data\n");
1005 
1006 // printf("fin\n");
1007  }
1008 // cpl_frameset_delete (preproc_frame);
1009  cpl_free(calib_datas);
1010  gravi_data_delete(dark_map);
1011  gravi_data_delete(wave_map);
1012  gravi_data_delete(profile_map);
1013  gravi_data_delete(badpix_map);
1014  }
1015  else {
1016 
1017 
1018  /* Construction of the opd vector and phase matrix */
1019 
1020  nb_frame = cpl_frameset_get_size (p2vmreduce_frameset);
1021 
1022  for (i = 0; i < nb_frame; i++){
1023  frame = cpl_frameset_get_position(p2vmreduce_frameset, i);
1024  filename = cpl_frame_get_filename(frame);
1025  cpl_msg_info (NULL, "Load the p2vm_reduce %s", filename);
1026 
1027 
1028  p2vm_reduce = gravi_data_load(filename);
1029  primary_hdr = gravi_data_get_propertylist(data,
1030  GRAVI_PRIMARY_HDR_NAME_EXT);
1031 
1032  /* Get the p2vm of the metrology */
1033  if (i == 0){
1034  int nwave_sc = gravi_pfits_get_nwave (gravi_data_get_propertylist (p2vm_reduce, GRAVI_IO_WAVELENGTH_SC_EXT));
1035  opd_vector = cpl_malloc (nwave_sc * sizeof(cpl_vector *));
1036  phase_matrix = cpl_malloc (sizeof(cpl_matrix *));
1037  p2vm_met = cpl_table_duplicate (
1038  gravi_data_get_table (p2vm_reduce, GRAVI_P2VM_MET_EXT));
1039  met_plist = cpl_propertylist_duplicate (
1040  gravi_data_get_propertylist (p2vm_reduce, GRAVI_P2VM_MET_EXT));
1041  disp_map = gravi_data_new (0);
1042  gravi_data_set_propertylist(disp_map,
1043  GRAVI_PRIMARY_HDR_NAME_EXT, primary_hdr);
1044  }
1045 
1046  if (gravi_disp_opd_phase_wrap (p2vm_reduce, p2vm_met,
1047  opd_vector, phase_matrix, num_disp) != CPL_ERROR_NONE){
1048  cpl_table_delete (p2vm_met);
1049  cpl_propertylist_delete (met_plist);
1050  for (i = 0; i < nwave_sc; i ++){
1051  cpl_vector_delete (opd_vector[i]);
1052 
1053  }
1054  cpl_matrix_delete (phase_matrix);
1055  cpl_free (opd_vector);
1056  cpl_free (phase_matrix);
1057  gravi_data_delete(p2vm_reduce);
1058  return (int) cpl_error_set_message(cpl_func,
1059  CPL_ERROR_ILLEGAL_OUTPUT, "Error while computing the dispersion");
1060  }
1061 
1062  num_disp ++;
1063 
1064  gravi_data_delete (p2vm_reduce);
1065 
1066 
1067  // printf("cpl_frameset_delete (preproc_frame);\n");
1068  // printf("data\n");
1069 
1070  // printf("fin\n");
1071  }
1072  }
1073 
1074  /* Compute the dispersion table of a set of disp frames */
1075 
1076  disp_table = gravi_compute_disp(opd_vector, phase_matrix, nwave_sc);
1077 
1078  for (i = 0; i < nwave_sc; i ++){
1079  cpl_vector_delete (opd_vector[i]);
1080 
1081  }
1082  cpl_matrix_delete (phase_matrix);
1083  cpl_free (opd_vector);
1084  cpl_free (phase_matrix);
1085  gravi_data_add (disp_map, met_plist, p2vm_met);
1086 
1087  cpl_table_delete (p2vm_met);
1088  cpl_propertylist_set_string (met_plist, "EXTNAME",
1089  "DISPERSION");
1090  gravi_data_add (disp_map, met_plist, disp_table);
1091  cpl_propertylist_delete (met_plist);
1092 
1093  if (cpl_error_get_code()) {
1094  cpl_frameset_delete(disp_frameset);
1095 
1096  gravi_data_delete(disp_map);
1097  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
1098  "Error while computing the disp_map");
1099  }
1100 
1101  /* Create product frame, add DataFlow keywords, save the file, log the
1102  * saved file in the input frameset*/
1103 
1104  disp_plist = gravi_data_get_propertylist(disp_map, GRAVI_PRIMARY_HDR_NAME_EXT);
1105  applist = gravi_propertylist_get_qc (disp_plist);
1106 
1107  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, DISP_MODEL);
1108 
1109  if (gravi_data_save( disp_map, frameset, "gravi_all_disp.fits", parlist,
1110  disp_frameset, NULL, "gravi_all_disp", applist)
1111  != CPL_ERROR_NONE){
1112 
1113  gravi_data_delete(disp_map);
1114  cpl_frameset_delete(disp_frameset);
1115  cpl_propertylist_delete(applist);
1116  return (int) cpl_error_set_message(cpl_func,
1117  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the disp map"
1118  " on the output file");
1119  }
1120 
1121  /* Deallocation of all variables */
1122 
1123  gravi_data_delete(disp_map);
1124  cpl_frameset_delete(disp_frameset);
1125  cpl_propertylist_delete(applist);
1126 
1127  return (int)cpl_error_get_code();
1128 }
1129 
1130