GRAVI Pipeline Reference Manual  0.6.3
gravi_dual.c
1 /* $Id: gravi_dual.c,v 1.29 2011/12/3 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: 2011/12/3 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 
40 #include "gravi_utils.h"
41 #include "gravi_pfits.h"
42 #include "gravi_dfs.h"
43 #include "gravi_calib.h"
44 #include "gravi_vis.h"
45 #include "gravi_data.h"
46 
47 
48 
49 /*-----------------------------------------------------------------------------
50  Private function prototypes
51  -----------------------------------------------------------------------------*/
52 
53 static int gravi_dual_create(cpl_plugin *);
54 static int gravi_dual_exec(cpl_plugin *);
55 static int gravi_dual_destroy(cpl_plugin *);
56 static int gravi_dual(cpl_frameset *, const cpl_parameterlist *);
57 
58 /*-----------------------------------------------------------------------------
59  Static variables
60  -----------------------------------------------------------------------------*/
61 
62 static char gravi_dual_description[] =
63 "This recipe is associated to the template GRAVI_dual_calib.\n"
64 "Its aim is to reduce the raw interferometric data acquired on calibrator\n"
65 "target and to compute the intrumental visibility. It is used in dual mode.\n"
66 "The given output FITS file contain a oi fits file, \n"
67 "the values of the visibility complex, squared visibility and the cloture phase.\n"
68 "their associated tags, e.g."
69 "GRAVI-gravi_dual-raw-file.fits " GRAVI_DUAL_CALIB " and "
70 GRAVI_DUAL_SCIENCE "\n"
71 "and any optional files, e.g.\n"
72 "GRAVI-gravi_dual-file.fits " VIS_CALIB " and " VIS_SCIENCE "\n"
73 "Additionally, it should describe functionality of the expected output."
74 "\n";
75 
76 /*-----------------------------------------------------------------------------
77  Function code
78  -----------------------------------------------------------------------------*/
79 
80 /*----------------------------------------------------------------------------*/
90 /*----------------------------------------------------------------------------*/
91 int cpl_plugin_get_info(cpl_pluginlist * list)
92 {
93  cpl_recipe * recipe = cpl_calloc(1, sizeof *recipe );
94  cpl_plugin * plugin = &recipe->interface;
95 
96  if (cpl_plugin_init(plugin,
97  CPL_PLUGIN_API,
98  GRAVI_BINARY_VERSION,
99  CPL_PLUGIN_TYPE_RECIPE,
100  "gravi_dual",
101  "This recipe is used to compute the squared visibility",
102  gravi_dual_description,
103  "Firstname Lastname",
104  PACKAGE_BUGREPORT,
105  gravi_get_license(),
106  gravi_dual_create,
107  gravi_dual_exec,
108  gravi_dual_destroy)) {
109  cpl_msg_error(cpl_func, "Plugin initialization failed");
110  (void)cpl_error_set_where(cpl_func);
111  return 1;
112  }
113 
114  if (cpl_pluginlist_append(list, plugin)) {
115  cpl_msg_error(cpl_func, "Error adding plugin to list");
116  (void)cpl_error_set_where(cpl_func);
117  return 1;
118  }
119 
120  return 0;
121 }
122 
123 /*----------------------------------------------------------------------------*/
131 /*----------------------------------------------------------------------------*/
132 static int gravi_dual_create(cpl_plugin * plugin)
133 {
134  cpl_recipe * recipe;
135  cpl_parameter * p;
136 
137  /* Do not create the recipe if an error code is already set */
138  if (cpl_error_get_code() != CPL_ERROR_NONE) {
139  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
140  cpl_func, __LINE__, cpl_error_get_where());
141  return (int)cpl_error_get_code();
142  }
143 
144  if (plugin == NULL) {
145  cpl_msg_error(cpl_func, "Null plugin");
146  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
147  }
148 
149  /* Verify plugin type */
150  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
151  cpl_msg_error(cpl_func, "Plugin is not a recipe");
152  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
153  }
154 
155  /* Get the recipe */
156  recipe = (cpl_recipe *)plugin;
157 
158  /* Create the parameters list in the cpl_recipe object */
159  recipe->parameters = cpl_parameterlist_new();
160  if (recipe->parameters == NULL) {
161  cpl_msg_error(cpl_func, "Parameter list allocation failed");
162  cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
163  }
164 
165  /* Fill the parameters list */
166 
167  /* --the sigma readout */
168  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.readout",
169  CPL_TYPE_DOUBLE, "the readout error sigma", "gravi.gravi_all_p2vm", 1);
170  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_readout");
171  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
172  cpl_parameterlist_append(recipe->parameters, p);
173 
174  /* --Save the preproc files */
175  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.preproc_file",
176  CPL_TYPE_BOOL, "Save the preproc file", "gravi.gravi_all_p2vm", FALSE);
177  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "preprocfile");
178  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
179  cpl_parameterlist_append(recipe->parameters, p);
180 
181  /* --Save the preproc files */
182  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.vis_reduce.vis_correction",
183  CPL_TYPE_BOOL, "Parameter of corection", "gravi.gravi_dual", FALSE);
184  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "vis_correction");
185  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
186  cpl_parameterlist_append(recipe->parameters, p);
187 
188  /* --the sigma readout SC */
189  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.readoutSC",
190  CPL_TYPE_DOUBLE, "the readout error sigma SC", "gravi.gravi_all_p2vm", 1.0);
191  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_readout_SC");
192  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
193  cpl_parameterlist_append(recipe->parameters, p);
194 
195  /* --the sigma readout FT */
196  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.readoutFT",
197  CPL_TYPE_DOUBLE, "the readout error sigma FT", "gravi.gravi_all_p2vm", 1.0);
198  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_readout_FT");
199  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
200  cpl_parameterlist_append(recipe->parameters, p);
201 
202  return 0;
203 }
204 
205 /*----------------------------------------------------------------------------*/
211 /*----------------------------------------------------------------------------*/
212 static int gravi_dual_exec(cpl_plugin * plugin)
213 {
214 
215  cpl_recipe * recipe;
216  int recipe_status;
217  cpl_errorstate initial_errorstate = cpl_errorstate_get();
218 
219  /* Return immediately if an error code is already set */
220  if (cpl_error_get_code() != CPL_ERROR_NONE) {
221  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
222  cpl_func, __LINE__, cpl_error_get_where());
223  return (int)cpl_error_get_code();
224  }
225 
226  if (plugin == NULL) {
227  cpl_msg_error(cpl_func, "Null plugin");
228  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
229  }
230 
231  /* Verify plugin type */
232  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
233  cpl_msg_error(cpl_func, "Plugin is not a recipe");
234  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
235  }
236 
237  /* Get the recipe */
238  recipe = (cpl_recipe *)plugin;
239 
240  /* Verify parameter and frame lists */
241  if (recipe->parameters == NULL) {
242  cpl_msg_error(cpl_func, "Recipe invoked with NULL parameter list");
243  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
244  }
245  if (recipe->frames == NULL) {
246  cpl_msg_error(cpl_func, "Recipe invoked with NULL frame set");
247  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
248  }
249 
250  /* Invoke the recipe */
251  recipe_status = gravi_dual(recipe->frames, recipe->parameters);
252 
253  /* Ensure DFS-compliance of the products */
254 
255  if (cpl_dfs_update_product_header(recipe->frames)) {
256  if (!recipe_status){
257  recipe_status = (int)cpl_error_get_code();
258  }
259  }
260 
261  if (!cpl_errorstate_is_equal(initial_errorstate)) {
262  /* Dump the error history since recipe execution start.
263  At this point the recipe cannot recover from the error */
264  cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
265  }
266 
267  return recipe_status;
268 }
269 
270 /*----------------------------------------------------------------------------*/
276 /*----------------------------------------------------------------------------*/
277 static int gravi_dual_destroy(cpl_plugin * plugin)
278 {
279  cpl_recipe * recipe;
280 
281  if (plugin == NULL) {
282  cpl_msg_error(cpl_func, "Null plugin");
283  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
284  }
285 
286  /* Verify plugin type */
287  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
288  cpl_msg_error(cpl_func, "Plugin is not a recipe");
289  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
290  }
291 
292  /* Get the recipe */
293  recipe = (cpl_recipe *)plugin;
294 
295  cpl_parameterlist_delete(recipe->parameters);
296 
297  return 0;
298 }
299 
300 
301 /*----------------------------------------------------------------------------*/
309 /*----------------------------------------------------------------------------*/
310 static int gravi_dual(cpl_frameset * frameset,
311  const cpl_parameterlist * parlist)
312 {
313  cpl_frameset * recipe_frameset, * wave_frameset, * dark_frameset,
314  * darkcalib_frameset, * preproc_frameset, * badpix_frameset,
315  * gain_frameset, * p2vm_frameset, * sky_frameset;
316  cpl_propertylist * applist, * primary_hdr, * primary_hdr_dark,
317  * wave_plist, *bad_primary_hdr;
318 
319  cpl_parameterlist * preproc_parlist;
320  cpl_frame * frame;
321  const cpl_parameter * p;
322  cpl_parameter * par;
323  char * out_dark, * preproc_name, * vis_name;
324  const char * frame_tag, * filename/*, * insname*/;
325  gravi_data * p2vm_map, * data, * dark_map, * wave_map,
326  * profile_map, * badpix_map;
327  gravi_data ** calib_datas;
328  gravi_data * preproc_data;
329  gravi_data ** raw_data, * p2vm_reduce;
330  gravi_data * oi_vis;
331  dark_map = NULL, wave_map = NULL;
332  int nb_frame, i, j, nwave_ft, nwave_sc;
333  int * shutter, nb_vis;
334  double darkmean, darkrms, wavemin, wavemax;
335 
336  /* Identify the RAW and CALIB frames in the input frameset */
337 
338  cpl_ensure_code(gravi_dfs_set_groups(frameset) == CPL_ERROR_NONE,
339  cpl_error_get_code()) ;
340 
341  preproc_frameset = gravi_frameset_extract_preproc(frameset);
342  p2vm_frameset = gravi_frameset_extract_p2vm_file(frameset);
343  if (cpl_frameset_is_empty(preproc_frameset)) {
344  /* - Extract a set of frame p2vm and set of frame dark wave */
345 // cpl_frameset * frameset = cpl_frameset_duplicate(_frameset);
346  recipe_frameset = gravi_frameset_extract_dual_data(frameset);
347  sky_frameset = gravi_frameset_extract_sky_data(frameset);
348 // p2vm_frameset = gravi_frameset_extract_p2vm_file(frameset);
349  darkcalib_frameset = gravi_frameset_extract_dark_file(frameset);
350  wave_frameset = gravi_frameset_extract_wave_file(frameset);
351  dark_frameset = gravi_frameset_extract_dark(frameset);
352  gain_frameset = gravi_frameset_extract_flat_file(frameset);
353  badpix_frameset = gravi_frameset_extract_badpix(frameset);
354 
355  if (cpl_frameset_is_empty(recipe_frameset)) {
356  /* To use this recipe the frameset must contain at least
357  * one p2vm frame. */
358  cpl_frameset_delete(darkcalib_frameset);
359  cpl_frameset_delete(wave_frameset);
360  cpl_frameset_delete(dark_frameset);
361  cpl_frameset_delete(gain_frameset);
362  cpl_frameset_delete(p2vm_frameset);
363  cpl_frameset_delete(recipe_frameset);
364 
365  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
366  "No dual frame on the frameset") ;
367  }
368 
369  if ((cpl_frameset_is_empty(p2vm_frameset)) ||
370  (cpl_frameset_is_empty(wave_frameset)) ||
371  (cpl_frameset_is_empty(gain_frameset))) {
372  /* To use this recipe the frameset must contain the p2vm, wave and
373  * gain calibration file. */
374  cpl_frameset_delete(darkcalib_frameset);
375  cpl_frameset_delete(recipe_frameset);
376  cpl_frameset_delete(wave_frameset);
377  cpl_frameset_delete(dark_frameset);
378  cpl_frameset_delete(gain_frameset);
379  cpl_frameset_delete(p2vm_frameset);
380  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
381  "No p2vm or gain or wave file on the frameset") ;
382  }
383 
384  /* Get the number of the p2vm frame contained in the frameset */
385  nb_frame = cpl_frameset_get_size(recipe_frameset);
386 
387  /* Identify and extract the dark and wave fits files */
388 
389  /* Check and get the dark frame */
390 
391  if (cpl_frameset_is_empty(sky_frameset)){
392 
393  if (!cpl_frameset_is_empty(dark_frameset)) {
394  frame = cpl_frameset_get_position(dark_frameset, 0);
395 
396  filename = cpl_frame_get_filename(frame);
397  data = gravi_data_load(filename);
398  primary_hdr = gravi_data_get_propertylist(data,
399  GRAVI_PRIMARY_HDR_NAME_EXT);
400  shutter = gravi_shutters_check(primary_hdr);
401  if (!((shutter[0] == 0) && (shutter[1] == 0) && (shutter[2] == 0)
402  && (shutter[3] == 0))){
403  cpl_frameset_delete(darkcalib_frameset);
404  cpl_frameset_delete(dark_frameset);
405  cpl_frameset_delete(wave_frameset);
406  cpl_frameset_delete(gain_frameset);
407  cpl_frameset_delete(p2vm_frameset);
408  cpl_frameset_delete(recipe_frameset);
409  gravi_data_delete(data);
410  return (int)cpl_error_set_message(cpl_func,
411  CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem");
412  }
413  /* The dark file must contains all the shutter close */
414 
415  cpl_msg_info (NULL, "This file %s is a dark file",
416  filename);
417  dark_map = gravi_compute_dark(data);
418  if (cpl_error_get_code()) {
419  cpl_frameset_delete(darkcalib_frameset);
420  cpl_frameset_delete(dark_frameset);
421  cpl_frameset_delete(wave_frameset);
422  cpl_frameset_delete(gain_frameset);
423  gravi_data_delete(dark_map);
424  cpl_frameset_delete(p2vm_frameset);
425  cpl_frameset_delete(recipe_frameset);
426  cpl_propertylist_delete(applist);
427  gravi_data_delete(data);
428  return (int)cpl_error_set_message(cpl_func,
429  CPL_ERROR_ILLEGAL_OUTPUT,
430  "Error while computing the dark_map");
431  }
432 
433  /* Save the dark map */
434 
435  primary_hdr_dark = gravi_data_get_propertylist(dark_map,
436  GRAVI_PRIMARY_HDR_NAME_EXT);
437  applist = gravi_propertylist_get_qc (primary_hdr_dark);
438 // dit = gravi_pfits_get_dit(primary_hdr_dark);
439  //insname = gravi_pfits_get_insname(primary_hdr_dark);
440  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
441  DARK);
442 
443 // cpl_propertylist_append_double(applist, GRAVI_DET_DIT, dit);
444  //cpl_propertylist_append_string(applist, "INSNAME", insname);
445  cpl_propertylist_append_double(applist, QC_MEANDARK, darkmean);
446  cpl_propertylist_append_double(applist, QC_DARKRMS, darkrms);
447  out_dark = "gravi_final_dark.fits";
448 
449  if (gravi_data_save(dark_map, frameset, out_dark, parlist,
450  dark_frameset, frame, "gravi_dual", applist)
451  != CPL_ERROR_NONE){
452  cpl_frameset_delete(darkcalib_frameset);
453  cpl_frameset_delete(dark_frameset);
454  cpl_frameset_delete(wave_frameset);
455  cpl_frameset_delete(gain_frameset);
456  gravi_data_delete(dark_map);
457  cpl_frameset_delete(p2vm_frameset);
458  cpl_frameset_delete(recipe_frameset);
459  cpl_propertylist_delete(applist);
460  gravi_data_delete(data);
461  cpl_free(shutter);
462 
463  return (int) cpl_error_set_message(cpl_func,
464  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the dark_map"
465  " on the output file");
466  }
467  cpl_propertylist_delete(applist);
468 
469 
470  gravi_data_delete(data);
471  cpl_free(shutter);
472 
473 
474  }
475  else if (!cpl_frameset_is_empty(darkcalib_frameset)) {
476  frame = cpl_frameset_get_position(darkcalib_frameset, 0);
477 
478  frame_tag = cpl_frame_get_tag(frame) ;
479  filename = cpl_frame_get_filename(frame);
480  cpl_msg_info (NULL, "This file %s is a dark file already "
481  "computed", filename);
482  dark_map = gravi_data_load(filename);
483  cpl_frameset_insert (dark_frameset, cpl_frame_duplicate (frame));
484  }
485 
486  /* Check that the dark_map in the input frameset */
487  else {
488  cpl_frameset_delete(darkcalib_frameset);
489  cpl_frameset_delete(p2vm_frameset);
490  cpl_frameset_delete(dark_frameset);
491  cpl_frameset_delete(wave_frameset);
492  cpl_frameset_delete(gain_frameset);
493  gravi_data_delete(dark_map);
494  cpl_frameset_delete(recipe_frameset);
495 
496  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
497  "No dark frames in the frameset");
498  }
499  }
500  else {
501  frame = cpl_frameset_get_position(sky_frameset, 0);
502 
503  filename = cpl_frame_get_filename(frame);
504  data = gravi_data_load(filename);
505  primary_hdr = gravi_data_get_propertylist(data,
506  GRAVI_PRIMARY_HDR_NAME_EXT);
507  const char * dpr_type = cpl_propertylist_get_string (primary_hdr, DPR_TYPE);
508  if (cpl_error_get_code()){
509  cpl_frameset_delete(darkcalib_frameset);
510  cpl_frameset_delete(dark_frameset);
511  cpl_frameset_delete(wave_frameset);
512  cpl_frameset_delete(gain_frameset);
513  cpl_frameset_delete(p2vm_frameset);
514  cpl_frameset_delete(recipe_frameset);
515  cpl_frameset_delete(sky_frameset);
516  gravi_data_delete(data);
517  return (int)cpl_error_set_message(cpl_func,
518  CPL_ERROR_ILLEGAL_OUTPUT, "The keyword DPR_CATG is missed");
519  }
520 
521  if (strstr (dpr_type, "SKY") == NULL){
522  cpl_frameset_delete(darkcalib_frameset);
523  cpl_frameset_delete(dark_frameset);
524  cpl_frameset_delete(wave_frameset);
525  cpl_frameset_delete(gain_frameset);
526  cpl_frameset_delete(p2vm_frameset);
527  cpl_frameset_delete(recipe_frameset);
528  cpl_frameset_delete(sky_frameset);
529  gravi_data_delete(data);
530  return (int)cpl_error_set_message(cpl_func,
531  CPL_ERROR_ILLEGAL_OUTPUT, "The file is not a sky file");
532  }
533  /* The dark file must contains all the shutter close */
534 
535  cpl_msg_info (NULL, "This file %s is a sky file",
536  filename);
537  dark_map = gravi_compute_dark(data);
538 
539 
540  if (cpl_error_get_code()) {
541  cpl_frameset_delete(darkcalib_frameset);
542  cpl_frameset_delete(dark_frameset);
543  cpl_frameset_delete(wave_frameset);
544  cpl_frameset_delete(gain_frameset);
545  gravi_data_delete(dark_map);
546  cpl_frameset_delete(p2vm_frameset);
547  cpl_frameset_delete(recipe_frameset);
548  cpl_propertylist_delete(applist);
549  gravi_data_delete(data);
550  return (int)cpl_error_set_message(cpl_func,
551  CPL_ERROR_ILLEGAL_OUTPUT,
552  "Error while computing the dark_map");
553  }
554  gravi_data_delete(data);
555 
556  cpl_frameset_insert (dark_frameset, cpl_frame_duplicate (frame));
557 
558  /* Save the dark map */
559 
560  primary_hdr_dark = gravi_data_get_propertylist(dark_map,
561  GRAVI_PRIMARY_HDR_NAME_EXT);
562  applist = gravi_propertylist_get_qc (primary_hdr_dark);
563 // dit = gravi_pfits_get_dit(primary_hdr_dark);
564  //insname = gravi_pfits_get_insname(primary_hdr_dark);
565  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
566  DARK);
567 
568 // cpl_propertylist_append_double(applist, GRAVI_DET_DIT, dit);
569  //cpl_propertylist_append_string(applist, "INSNAME", insname);
570  cpl_propertylist_append_double(applist, QC_MEANDARK, darkmean);
571  cpl_propertylist_append_double(applist, QC_DARKRMS, darkrms);
572  out_dark = "gravi_final_dark.fits";
573 
574  if (gravi_data_save(dark_map, frameset, out_dark, parlist,
575  sky_frameset, frame, "gravi_single", applist)
576  != CPL_ERROR_NONE){
577  cpl_frameset_delete(darkcalib_frameset);
578  cpl_frameset_delete(dark_frameset);
579  cpl_frameset_delete(wave_frameset);
580  cpl_frameset_delete(gain_frameset);
581  gravi_data_delete(dark_map);
582  cpl_frameset_delete(p2vm_frameset);
583  cpl_frameset_delete(recipe_frameset);
584  cpl_propertylist_delete(applist);
585 
586  cpl_free(shutter);
587 
588  return (int) cpl_error_set_message(cpl_func,
589  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the dark_map"
590  " on the output file");
591  }
592  cpl_propertylist_delete(applist);
593  }
594 
595 
596  cpl_frameset_delete(sky_frameset);
597  /* Compute the bad pixel map */
598  if (!cpl_frameset_is_empty(badpix_frameset)){
599  frame = cpl_frameset_get_position(badpix_frameset, 0);
600  filename = cpl_frame_get_filename(frame);
601  cpl_msg_info (NULL, "This file %s is a bad pixel map", filename);
602 
603  badpix_map = gravi_data_load(filename);
604  }
605  else {
606 
607  badpix_map = gravi_compute_badpix(dark_map, parlist);
608 
609  if (cpl_error_get_code()) {
610  gravi_data_delete(badpix_map);
611  cpl_frameset_delete(dark_frameset);
612  cpl_frameset_delete(wave_frameset);
613  cpl_frameset_delete(gain_frameset);
614  cpl_frameset_delete(p2vm_frameset);
615  cpl_frameset_delete(darkcalib_frameset);
616  gravi_data_delete(dark_map);
617  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
618  "Error while computing the bad pixel map");
619 
620  }
621  /* Save the pad pixel map */
622  bad_primary_hdr = gravi_data_get_propertylist (badpix_map,
623  GRAVI_PRIMARY_HDR_NAME_EXT);
624  applist = gravi_propertylist_get_qc (bad_primary_hdr);
625 
626  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, BAD);
627 
628  frame = cpl_frameset_get_position (dark_frameset, 0);
629 
630  if (gravi_data_save (badpix_map, frameset, "gravi_bad_map.fits", parlist,
631  dark_frameset, frame, "gravi_all_flat", applist)
632  != CPL_ERROR_NONE){
633 
634  gravi_data_delete(badpix_map);
635  cpl_frameset_delete(dark_frameset);
636  cpl_frameset_delete(wave_frameset);
637  cpl_frameset_delete(gain_frameset);
638  cpl_frameset_delete(p2vm_frameset);
639  cpl_frameset_delete(darkcalib_frameset);
640  cpl_frameset_delete(badpix_frameset);
641  gravi_data_delete(dark_map);
642  return (int) cpl_error_set_message(cpl_func,
643  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the bad pixel map");
644  }
645  cpl_propertylist_delete (applist);
646  }
647 
648  /* Identify the flat file */
649 
650  frame = cpl_frameset_get_position(gain_frameset, 0);
651  filename = cpl_frame_get_filename(frame);
652  cpl_msg_info (NULL, "This file %s is a flat file already "
653  "computed", filename);
654 
655  profile_map = gravi_data_load(filename);
656 
657  /* Check and get the wave frame */
658  frame = cpl_frameset_get_position(wave_frameset, 0);
659  filename = cpl_frame_get_filename(frame);
660  cpl_msg_info (NULL, "This file %s is a wave file already "
661  "computed", filename);
662  wave_map = gravi_data_load(filename);
663 
664  /* Check that wave_map exist in the input frameset */
665  if ((wave_map == NULL) || (profile_map == NULL)){
666  cpl_frameset_delete(darkcalib_frameset);
667  cpl_frameset_delete(p2vm_frameset);
668  cpl_frameset_delete(dark_frameset);
669  cpl_frameset_delete(wave_frameset);
670  cpl_frameset_delete(gain_frameset);
671  gravi_data_delete(wave_map);
672  gravi_data_delete(profile_map);
673  gravi_data_delete(badpix_map);
674  cpl_frameset_delete(recipe_frameset);
675 
676  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
677  "No wave frames in the frameset");
678  }
679 
680  /* Load the p2vm data */
681  frame = cpl_frameset_get_position(p2vm_frameset, 0);
682  filename = cpl_frame_get_filename(frame);
683  cpl_msg_info (NULL, "This file %s is a p2vm file already "
684  "computed", filename);
685 
686  p2vm_map = gravi_data_load (filename);
687 
688  if (cpl_error_get_code()) {
689  cpl_frameset_delete(darkcalib_frameset);
690  cpl_frameset_delete(p2vm_frameset);
691  cpl_frameset_delete(dark_frameset);
692  cpl_frameset_delete(wave_frameset);
693  cpl_frameset_delete(gain_frameset);
694  gravi_data_delete(profile_map);
695  gravi_data_delete(dark_map);
696  gravi_data_delete(wave_map);
697  gravi_data_delete(p2vm_map);
698  cpl_frameset_delete(recipe_frameset);
699 
700  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
701  "Error while loading the p2vm_map");
702  }
703 
704  /* Check if the data with the p2vm have the same spectral n */
705  wave_plist = gravi_data_get_propertylist (p2vm_map,
706  GRAVI_IO_WAVELENGTH_SC_EXT);
707  nwave_sc = gravi_pfits_get_nwave (wave_plist);
708  wave_plist = gravi_data_get_propertylist (p2vm_map,
709  GRAVI_IO_WAVELENGTH_FT_EXT);
710  nwave_ft = gravi_pfits_get_nwave (wave_plist);
711  primary_hdr = gravi_data_get_propertylist (wave_map,
712  GRAVI_PRIMARY_HDR_NAME_EXT);//pour ft et sc
713 
714  if (cpl_error_get_code()) {
715  cpl_frameset_delete(darkcalib_frameset);
716  cpl_frameset_delete(p2vm_frameset);
717  cpl_frameset_delete(dark_frameset);
718  cpl_frameset_delete(wave_frameset);
719  cpl_frameset_delete(gain_frameset);
720  gravi_data_delete(profile_map);
721  gravi_data_delete(dark_map);
722  gravi_data_delete(wave_map);
723  gravi_data_delete(p2vm_map);
724  cpl_frameset_delete(recipe_frameset);
725 
726  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
727  "Missed one the preproc parameters");
728  }
729 
730  wavemin = cpl_propertylist_get_double (primary_hdr, QC_MINWAVE_SC);
731  wavemax = cpl_propertylist_get_double (primary_hdr, QC_MAXWAVE_SC);
732 
733  /* Construction of the parameterlist to compute the preprocing */
734  cpl_size nb_par = cpl_parameterlist_get_size (parlist);
735 
736  preproc_parlist = cpl_parameterlist_new ();
737  p = cpl_parameterlist_get_first_const (parlist);
738  for (i = 0; i < nb_par; i ++){
739  cpl_type type = cpl_parameter_get_type (p);
740  switch (type) {
741  case CPL_TYPE_DOUBLE :
742  par = cpl_parameter_new_value(cpl_parameter_get_name (p), type,
743  cpl_parameter_get_help(p),
744  cpl_parameter_get_context(p),
745  cpl_parameter_get_double (p));
746  break;
747  case CPL_TYPE_BOOL :
748  par = cpl_parameter_new_value(cpl_parameter_get_name (p), type,
749  cpl_parameter_get_help(p),
750  cpl_parameter_get_context(p),
751  cpl_parameter_get_bool (p));
752  break;
753  case CPL_TYPE_INT :
754  par = cpl_parameter_new_value(cpl_parameter_get_name (p), type,
755  cpl_parameter_get_help(p),
756  cpl_parameter_get_context(p),
757  cpl_parameter_get_int (p));
758  break;
759  case CPL_TYPE_STRING :
760  par = cpl_parameter_new_value(cpl_parameter_get_name (p), type,
761  cpl_parameter_get_help(p),
762  cpl_parameter_get_context(p),
763  cpl_parameter_get_string (p));
764  break;
765  default :
766  cpl_msg_warning(cpl_func, "Type of the parameter is different %s",
767  cpl_type_get_name (type));
768  break;
769  }
770 
771 
772  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI,
773  cpl_parameter_get_alias (p, CPL_PARAMETER_MODE_CLI));
774  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
775  cpl_parameterlist_append(preproc_parlist, par);
776  p = cpl_parameterlist_get_next_const (parlist);
777  }
778  /* --the minimum wavelength */
779 
780  par = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.min_wave",
781  CPL_TYPE_DOUBLE, "the minimum wavelength",
782  "gravi.gravi_all_p2vm", wavemin + 0.0001);
783  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, "lambdamin");
784  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
785  cpl_parameterlist_append(preproc_parlist, par);
786 
787  /* --the maximum wavelength */
788  par = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.max_wave",
789  CPL_TYPE_DOUBLE, "the maximum wavelength",
790  "gravi.gravi_all_p2vm", wavemax - 0.0001);
791  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, "lambdamax");
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.gravi_all_p2vm.preproc_param.nspectrum_FT",
797  CPL_TYPE_INT, "the number of the spectral",
798  "gravi.gravi_all_dark", nwave_ft);
799  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, "nlambda_ft");
800  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
801  cpl_parameterlist_append(preproc_parlist, par);
802 
803  /* --the number of the spectral element to compute */
804  par = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.nspectrum_SC",
805  CPL_TYPE_INT, "the number of the spectral",
806  "gravi.gravi_all_dark", nwave_sc);
807  cpl_parameter_set_alias(par, CPL_PARAMETER_MODE_CLI, "nlambda_sc");
808  cpl_parameter_disable(par, CPL_PARAMETER_MODE_ENV);
809  cpl_parameterlist_append(preproc_parlist, par);
810 
811 
812 // printf("nb_frameset = %d nb_frameset_dark = %d nb_frameset_wave = %d nb_frameset_p2vm = %d nb_gain_frame = %d\n",
813 // nb_frame, cpl_frameset_get_size(dark_frameset), cpl_frameset_get_size(wave_frameset),
814 // cpl_frameset_get_size(p2vm_frameset), cpl_frameset_get_size(gain_frameset));
815 
816 
817  /* Construction of the calibration data */
818  calib_datas = cpl_malloc(4 * sizeof(gravi_data *));
819  calib_datas[0] = dark_map;
820  calib_datas[1] = wave_map;
821  calib_datas[2] = profile_map;
822  calib_datas[3] = badpix_map;
823 
824 
825  p = cpl_parameterlist_find_const(parlist, "gravi.gravi_all_p2vm."
826  "preproc_param.preproc_file");
827 
828  /* Construction of the preproc data and extract the spectra using
829  * the results of the spectral calibration */
830 
831  nb_vis = 0;
832  oi_vis = gravi_data_new(0);
833  for (i = 0; i < nb_frame; i++){
834  frame = cpl_frameset_get_position (recipe_frameset, i);
835  filename = cpl_frame_get_filename (frame);
836 
837  data = gravi_data_load(filename);
838  primary_hdr = gravi_data_get_propertylist (data,
839  GRAVI_PRIMARY_HDR_NAME_EXT);
840  /* Check the shutter for extracting the files can be used to compute
841  * the visibilities */
842  shutter = gravi_shutters_check(primary_hdr);
843  if ((shutter[0] == 1) && (shutter[1] == 1) &&
844  (shutter[2] == 1) && (shutter[3] == 1)){
845  cpl_msg_info (NULL, "Calibration of this file %s", filename);
846  preproc_data = gravi_preproc(data, calib_datas, 4, preproc_parlist);
847  gravi_data_delete(data);
848  cpl_free(shutter);
849  cpl_frameset_insert (preproc_frameset, cpl_frame_duplicate (frame));
850  }
851  else {
852  gravi_data_delete(data);
853  cpl_free(shutter);
854  continue;
855  }
856  if (cpl_error_get_code()) {
857  cpl_frameset_delete(darkcalib_frameset);
858  cpl_frameset_delete(p2vm_frameset);
859  cpl_frameset_delete(dark_frameset);
860  cpl_frameset_delete(wave_frameset);
861  cpl_frameset_delete(gain_frameset);
862 
863 
864  gravi_data_delete(preproc_data);
865 
866  cpl_free(preproc_data);
867  cpl_free(calib_datas);
868  gravi_data_delete(profile_map);
869  gravi_data_delete(dark_map);
870  gravi_data_delete(wave_map);
871  gravi_data_delete(badpix_map);
872  gravi_data_delete(p2vm_map);
873  cpl_frameset_delete(recipe_frameset);
874 
875  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
876  "Error while computing the preproc data_map");
877  }
878 
879  /* Option save the proproc file */
880  if (cpl_parameter_get_bool(p)){
881  preproc_name = cpl_sprintf("gravi_preproc_%s", filename);
882  cpl_frameset * preproc_frame = cpl_frameset_new ();
883  cpl_frameset_insert (preproc_frame, cpl_frame_duplicate (frame));
884 
885  applist = gravi_propertylist_get_qc (gravi_data_get_propertylist
886  (preproc_data, GRAVI_PRIMARY_HDR_NAME_EXT));
887 
888 
889  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, PREPROC);
890 
891 // gravi_data_save(preproc_data[i], frameset, preproc_name, parlist,
892 // recipe_frameset, "gravi_dual", applist);
893  if (gravi_data_save(preproc_data, frameset, preproc_name, parlist,
894  preproc_frame, frame, "gravi_dual", applist)
895  != CPL_ERROR_NONE){
896  cpl_frameset_delete(darkcalib_frameset);
897  cpl_frameset_delete(dark_frameset);
898  cpl_frameset_delete(wave_frameset);
899  cpl_frameset_delete(gain_frameset);
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(p2vm_map);
905  cpl_frameset_delete(p2vm_frameset);
906  cpl_frameset_delete(recipe_frameset);
907  cpl_propertylist_delete(applist);
908 
909  gravi_data_delete(preproc_data);
910 
911  cpl_free(preproc_name);
912 
913  return (int) cpl_error_set_message(cpl_func,
914  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the preproc data"
915  " on the output file");
916  }
917 
918 
919 
920  cpl_free(preproc_name);
921  cpl_propertylist_delete (applist);
922  cpl_frameset_delete (preproc_frame);
923  }
924 
925  cpl_msg_info (NULL, "reduce the p2vm of the file %s",
926  cpl_frame_get_filename(frame));
927  /* Compute the flux and visibilities for each telescope and
928  * per acquisition */
929  p2vm_reduce = gravi_p2vm_reduce (preproc_data, p2vm_map, "gravi_dual");
930  gravi_data_delete(preproc_data);
931  if (cpl_error_get_code()){
932  gravi_data_delete(p2vm_reduce);
933  gravi_data_delete(preproc_data);
934  gravi_data_delete(p2vm_map);
935  cpl_frameset_delete(p2vm_frameset);
936  cpl_frameset_delete(recipe_frameset);
937 
938 
939  return (int) cpl_error_set_message(cpl_func,
940  CPL_ERROR_ILLEGAL_OUTPUT, "error while reducing the p2vm");
941  }
942  char * p2vm_name = cpl_sprintf("dual_reduced_%s",
943  cpl_frame_get_filename(frame));
944 
945  gravi_data_save_data(p2vm_reduce, p2vm_name, CPL_IO_CREATE);
946  cpl_free(p2vm_name);
947 
948  /* For each Binning frames the visibility are averaged and the followings
949  * are saved in Visibility data in tables VIS, VIS2 and T3 */
950  gravi_vis_reduce (oi_vis, p2vm_reduce, nb_vis, parlist, "gravi_dual");
951  nb_vis++;
952  gravi_data_delete(p2vm_reduce);
953 
954  }
955 
956  cpl_free(calib_datas);
957  gravi_data_delete(profile_map);
958  gravi_data_delete(dark_map);
959  gravi_data_delete(wave_map);
960  gravi_data_delete(badpix_map);
961  gravi_data_delete(p2vm_map);
962  cpl_parameterlist_delete (preproc_parlist);
963  cpl_frameset_delete(darkcalib_frameset);
964  cpl_frameset_delete(wave_frameset);
965  cpl_frameset_delete(dark_frameset);
966  cpl_frameset_delete(gain_frameset);
967  cpl_frameset_delete(badpix_frameset);
968  }
969  /* Initialization of the output name */
970 
971  else {
972 
973  /*test*/
974  recipe_frameset = cpl_frameset_duplicate (preproc_frameset);
975  nb_vis = cpl_frameset_get_size (recipe_frameset);
976  nb_frame = cpl_frameset_get_size(recipe_frameset);
977  oi_vis = gravi_data_new(0);
978 
979  /* Load the p2vm data */
980  frame = cpl_frameset_get_position(p2vm_frameset, 0);
981  filename = cpl_frame_get_filename(frame);
982  cpl_msg_info (NULL, "This file %s is a p2vm file already "
983  "computed", filename);
984 
985  p2vm_map = gravi_data_load (filename);
986  /* Compute the complex visibilty, squared visibity and the cloture phases */
987  /* To compute the visibility from a set of observable */
988 
989  /* by inverting the V2PM to compute the P2VM. The matrix inversion is
990  * done using the singular value decomposition method */
991  for (i = 0; i < nb_frame; i++){
992  frame = cpl_frameset_get_position(preproc_frameset, i);
993  filename = cpl_frame_get_filename(frame);
994  printf("Calibration of this file %s\n", filename);
995  preproc_data = gravi_data_load(filename);
996  cpl_msg_info (NULL, "reduce the p2vm of the file %s",
997  cpl_frame_get_filename(frame));
998  /* Compute the flux and visibilities for each telescope and
999  * per acquisition */
1000  p2vm_reduce = gravi_p2vm_reduce (preproc_data, p2vm_map, "gravi_dual");
1001  gravi_data_delete(preproc_data);
1002  if (cpl_error_get_code()){
1003  gravi_data_delete(p2vm_reduce);
1004  gravi_data_delete(preproc_data);
1005  gravi_data_delete(p2vm_map);
1006  cpl_frameset_delete(p2vm_frameset);
1007  cpl_frameset_delete(recipe_frameset);
1008 
1009 
1010  return (int) cpl_error_set_message(cpl_func,
1011  CPL_ERROR_ILLEGAL_OUTPUT, "error while reducing the p2vm");
1012  }
1013  char * p2vm_name = cpl_sprintf("dual_reduced_%s",
1014  cpl_frame_get_filename(frame));
1015 
1016  gravi_data_save_data(p2vm_reduce, p2vm_name, CPL_IO_CREATE);
1017  cpl_free(p2vm_name);
1018 
1019  /* For each Binning frames the visibility are averaged and the followings
1020  * are saved in Visibility data in tables VIS, VIS2 and T3 */
1021  gravi_vis_reduce (oi_vis, p2vm_reduce, j, parlist, "gravi_dual");
1022  gravi_data_delete(p2vm_reduce);
1023  }
1024 
1025 
1026  gravi_data_delete(p2vm_map);
1027 
1028  }
1029 
1030 // char tag[20] = "VIS";
1031 
1032 // gravi_data_save_data(oi_vis, vis_name, CPL_IO_CREATE);
1033  /* Save the out put data file */
1034  frame = cpl_frameset_get_position (recipe_frameset, 0);
1035  frame_tag = cpl_frame_get_tag (frame);
1036  primary_hdr = gravi_data_get_propertylist(oi_vis,
1037  GRAVI_PRIMARY_HDR_NAME_EXT);
1038  applist = gravi_propertylist_get_qc (primary_hdr);
1039 
1040  cpl_propertylist_append_int(applist, GRAVI_NIGHT_OBS,
1041  cpl_propertylist_get_int (primary_hdr, GRAVI_NIGHT_OBS));
1042  cpl_propertylist_append_string(applist, "DATE-OBS",
1043  cpl_propertylist_get_string (primary_hdr, "DATE-OBS"));
1044 
1045  if ((strcmp(frame_tag, GRAVI_DUAL_CALIB) == 0)) {
1046  filename = cpl_frame_get_filename(
1047  cpl_frameset_get_position (preproc_frameset, 0));
1048  vis_name = "vis_dual_calib.fits";
1049  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, VIS_DUAL_CALIB);
1050  }
1051  else if ((strcmp(frame_tag, GRAVI_DUAL_SCIENCE) == 0)) {
1052  filename = cpl_frame_get_filename(
1053  cpl_frameset_get_position (preproc_frameset, 0));
1054  vis_name = "vis_dual_science.fits";
1055  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, VIS_DUAL_SCIENCE);
1056  }
1057  else {
1058  vis_name = "vis_dual_science.fits";
1059  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, VIS_SCIENCE);
1060  }
1061 
1062  if (gravi_data_save(oi_vis, frameset, vis_name, parlist,
1063  recipe_frameset, frame, "gravi_dual", applist)
1064  != CPL_ERROR_NONE){
1065 // gravi_data_delete(p2vm_map);
1066  gravi_data_delete(oi_vis);
1067  cpl_frameset_delete(p2vm_frameset);
1068  cpl_frameset_delete(recipe_frameset);
1069  cpl_propertylist_delete(applist);
1070 
1071  return (int) cpl_error_set_message(cpl_func,
1072  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the oi_vis"
1073  " on the output file");
1074  }
1075 
1076  cpl_propertylist_delete(applist);
1077 // if (gravi_save_qc (oi_vis, frameset, recipe_frameset,
1078 // vis_name, parlist, tag, "gravi_dual") != CPL_ERROR_NONE){
1079 // printf("wayylouzzzzzzzze\n");
1080 // cpl_frameset_delete(wave_frameset);
1081 // cpl_frameset_delete(dark_frameset);
1082 // cpl_frameset_delete(gain_frameset);
1083 // gravi_data_delete(profile_map);
1084 // for (i = 0; i < nb_vis; i++){
1085 // gravi_data_delete(preproc_data[i]);
1086 // }
1087 // cpl_free(preproc_data);
1088 // for (i = 0; i < j; j++){
1089 // gravi_data_delete(p2vm_reduce[i]);
1090 // }
1091 // cpl_free(p2vm_reduce);
1092 // cpl_free(calib_datas);
1093 // gravi_data_delete(dark_map);
1094 // gravi_data_delete(wave_map);
1095 // gravi_data_delete(p2vm_map);
1096 // gravi_data_delete(oi_vis);
1097 // cpl_frameset_delete(p2vm_frameset);
1098 // gravi_data_delete(badpix_map);
1099 // cpl_frameset_delete(recipe_frameset);
1100 //
1101 // return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
1102 // "Error while save of the visibility file");
1103 // }
1104  gravi_data_delete(oi_vis);
1105 
1106  /* Deallocation of all variables */
1107 
1108  cpl_frameset_delete(p2vm_frameset);
1109  cpl_frameset_delete(recipe_frameset);
1110  cpl_frameset_delete(preproc_frameset);
1111 
1112 
1113  return (int)cpl_error_get_code();
1114 }
1115 
1116