GRAVI Pipeline Reference Manual  0.6.3
gravi_all_wave.c
1 /* $Id: gravi_all_wave.c,v 1.29 2011/11/21 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/03/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 
40 #include "gravi_utils.h"
41 #include "gravi_pfits.h"
42 #include "gravi_dfs.h"
43 #include "gravi_calib.h"
44 
45 #include "gravi_data.h"
46 #include <time.h>
47 #include <math.h>
48 
49 /*-----------------------------------------------------------------------------
50  Private function prototypes
51  -----------------------------------------------------------------------------*/
52 
53 static int gravi_all_wave_create(cpl_plugin *);
54 static int gravi_all_wave_exec(cpl_plugin *);
55 static int gravi_all_wave_destroy(cpl_plugin *);
56 static int gravi_all_wave(cpl_frameset *, const cpl_parameterlist *);
57 
58 /*-----------------------------------------------------------------------------
59  Static variables
60  -----------------------------------------------------------------------------*/
61 
62 static char gravi_all_wave_description[] =
63 "This recipe is used to compute the effective wavelength of each element of the \n"
64 "spectra for SC and FT. This is computed from a set of raw wavelength integration.\n"
65 "The master wave frame is created.\n"
66 "\n"
67 "Description DO category\n"
68 "Required input :\n"
69 "Raw wave file (one file) " GRAVI_WAVE "\n"
70 "Raw flat file (There is 4 files per profile map) " GRAVI_FLAT "\n"
71 "Raw dark file " GRAVI_DARK "\n"
72 "Or\n"
73 "Master dark " DARK "\n"
74 "Profile map " FLAT "\n"
75 "Bad pixel map " BAD "\n"
76 "Ouput :\n"
77 "Master wave (one file) " WAVE "\n"
78 "Profile map (if there is raw flat files in the input) " FLAT "\n"
79 "Master dark (if there is raw dark file in the input) " DARK "\n"
80 "Bad pixel map (if there is not bad pixel map in the input) " BAD "\n"
81 "\n";
82 
83 /*-----------------------------------------------------------------------------
84  Function code
85  -----------------------------------------------------------------------------*/
86 
87 /*----------------------------------------------------------------------------*/
97 /*----------------------------------------------------------------------------*/
98 int cpl_plugin_get_info(cpl_pluginlist * list)
99 {
100  cpl_recipe * recipe = cpl_calloc(1, sizeof *recipe );
101  cpl_plugin * plugin = &recipe->interface;
102 
103  if (cpl_plugin_init(plugin,
104  CPL_PLUGIN_API,
105  GRAVI_BINARY_VERSION,
106  CPL_PLUGIN_TYPE_RECIPE,
107  "gravi_all_wave",
108  "This recipe reduce the raw spectral file "
109  "for spectrograph calibration",
110  gravi_all_wave_description,
111  "Firstname Lastname",
112  PACKAGE_BUGREPORT,
113  gravi_get_license(),
114  gravi_all_wave_create,
115  gravi_all_wave_exec,
116  gravi_all_wave_destroy)) {
117  cpl_msg_error(cpl_func, "Plugin initialization failed");
118  (void)cpl_error_set_where(cpl_func);
119  return 1;
120  }
121 
122  if (cpl_pluginlist_append(list, plugin)) {
123  cpl_msg_error(cpl_func, "Error adding plugin to list");
124  (void)cpl_error_set_where(cpl_func);
125  return 1;
126  }
127 
128  return 0;
129 }
130 
131 /*----------------------------------------------------------------------------*/
139 /*----------------------------------------------------------------------------*/
140 static int gravi_all_wave_create(cpl_plugin * plugin)
141 {
142  cpl_recipe * recipe;
143  cpl_parameter * p;
144 
145  /* Do not create the recipe if an error code is already set */
146  if (cpl_error_get_code() != CPL_ERROR_NONE) {
147  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
148  cpl_func, __LINE__, cpl_error_get_where());
149  return (int)cpl_error_get_code();
150  }
151 
152  if (plugin == NULL) {
153  cpl_msg_error(cpl_func, "Null plugin");
154  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
155  }
156 
157  /* Verify plugin type */
158  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
159  cpl_msg_error(cpl_func, "Plugin is not a recipe");
160  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
161  }
162 
163  /* Get the recipe */
164  recipe = (cpl_recipe *)plugin;
165 
166  /* Create the parameters list in the cpl_recipe object */
167  recipe->parameters = cpl_parameterlist_new();
168  if (recipe->parameters == NULL) {
169  cpl_msg_error(cpl_func, "Parameter list allocation failed");
170  cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
171  }
172 
173  /* --the width of the profile element */
174  p = cpl_parameter_new_value("gravi.gravi_all_flat."
175  "profile_width", CPL_TYPE_INT, "profile width option",
176  "gravi.gravi_all_flat", 5);
177  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "profile_width");
178  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
179  cpl_parameterlist_append(recipe->parameters, p);
180 
181  /* --Extract the real opd from the metrology */
182  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.opd_met",
183  CPL_TYPE_BOOL, "extract the real opd from the metrology",
184  "gravi.gravi_all_p2vm", TRUE);
185  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "extmetrology");
186  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
187  cpl_parameterlist_append(recipe->parameters, p);
188 
189  p = cpl_parameter_new_value("gravi."
190  "flat_param.Bad_dark_threshold", CPL_TYPE_INT, "the rms factor for "
191  "dark bad pixel threshold", "gravi.gravi_all_wave", 5);
192  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "Bad_dark_threshold");
193  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
194  cpl_parameterlist_append(recipe->parameters, p);
195 
196 
197  /* Fill the parameters list */
198  return 0;
199 }
200 
201 /*----------------------------------------------------------------------------*/
207 /*----------------------------------------------------------------------------*/
208 static int gravi_all_wave_exec(cpl_plugin * plugin)
209 {
210 
211  cpl_recipe * recipe;
212  int recipe_status;
213  cpl_errorstate initial_errorstate = cpl_errorstate_get();
214 
215  /* Return immediately if an error code is already set */
216  if (cpl_error_get_code() != CPL_ERROR_NONE) {
217  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
218  cpl_func, __LINE__, cpl_error_get_where());
219  return (int)cpl_error_get_code();
220  }
221 
222  if (plugin == NULL) {
223  cpl_msg_error(cpl_func, "Null plugin");
224  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
225  }
226 
227  /* Verify plugin type */
228  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
229  cpl_msg_error(cpl_func, "Plugin is not a recipe");
230  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
231  }
232 
233  /* Get the recipe */
234  recipe = (cpl_recipe *)plugin;
235 
236  /* Verify parameter and frame lists */
237  if (recipe->parameters == NULL) {
238  cpl_msg_error(cpl_func, "Recipe invoked with NULL parameter list");
239  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
240  }
241  if (recipe->frames == NULL) {
242  cpl_msg_error(cpl_func, "Recipe invoked with NULL frame set");
243  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
244  }
245 
246  /* Invoke the recipe */
247  recipe_status = gravi_all_wave(recipe->frames, recipe->parameters);
248 
249  /* Ensure DFS-compliance of the products */
250  if (cpl_dfs_update_product_header(recipe->frames)) {
251  if (!recipe_status) recipe_status = (int)cpl_error_get_code();
252  }
253 
254  if (!cpl_errorstate_is_equal(initial_errorstate)) {
255  /* Dump the error history since recipe execution start.
256  At this point the recipe cannot recover from the error */
257  cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
258  }
259 
260  return recipe_status;
261 }
262 
263 /*----------------------------------------------------------------------------*/
269 /*----------------------------------------------------------------------------*/
270 static int gravi_all_wave_destroy(cpl_plugin * plugin)
271 {
272  cpl_recipe * recipe;
273 
274  if (plugin == NULL) {
275  cpl_msg_error(cpl_func, "Null plugin");
276  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
277  }
278 
279  /* Verify plugin type */
280  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
281  cpl_msg_error(cpl_func, "Plugin is not a recipe");
282  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
283  }
284 
285  /* Get the recipe */
286  recipe = (cpl_recipe *)plugin;
287 
288  cpl_parameterlist_delete(recipe->parameters);
289 
290  return 0;
291 }
292 
293 
294 /*----------------------------------------------------------------------------*/
302 /*----------------------------------------------------------------------------*/
303 static int gravi_all_wave(cpl_frameset * frameset,
304  const cpl_parameterlist * parlist)
305 {
306  cpl_frameset * wave_frameset = NULL, * usedframes, * flatcalib_frameset,
307  * darkcalib_frameset, * flat_frameset, *badpix_frameset,
308  * dark_frameset;
309  cpl_frame * frame;
310  cpl_propertylist * applist, * primary_hdr, *primary_hdr_dark, * bad_primary_hdr;
311  const char * input, * filename;
312  char * output;
313  const cpl_parameter * p;
314  double /*dit,*/ gain_ft, gain_sc, acq_mjd;
315  const char * acq_start;
316  gravi_data * raw_wave, * reduced_wave, * profile_map, * dark_map, * bad_map,
317  ** raw_data, * data, ** calib_datas;
318  int * shutter;
319  int comp, nb_frame, nb_frame_flat, i;
320 
321  /* Identify the RAW and CALIB frames in the input frameset */
322  cpl_ensure_code(gravi_dfs_set_groups(frameset) == CPL_ERROR_NONE,
323  cpl_error_get_code()) ;
324 
325  /* - Extract a set of frame wave */
326  wave_frameset = gravi_frameset_extract_wave(frameset);
327  flatcalib_frameset = gravi_frameset_extract_flat_file(frameset);
328  darkcalib_frameset = gravi_frameset_extract_dark_file(frameset);
329  flat_frameset = gravi_frameset_extract_flat(frameset);
330  dark_frameset = gravi_frameset_extract_dark(frameset);
331  badpix_frameset = gravi_frameset_extract_badpix(frameset);
332  if (cpl_frameset_is_empty(wave_frameset)) {
333  /* To use this recipe the frameset must contain at least
334  * one wave frame. */
335  cpl_frameset_delete(darkcalib_frameset);
336  cpl_frameset_delete(flatcalib_frameset);
337  cpl_frameset_delete(wave_frameset);
338  cpl_frameset_delete(dark_frameset);
339  cpl_frameset_delete(flat_frameset);
340  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
341  "No wave frame on the frameset") ;
342  }
343  nb_frame = cpl_frameset_get_size(wave_frameset);
344 
345  /* Check and get the dark frame */
346 
347  if (!cpl_frameset_is_empty(dark_frameset)) {
348  frame = cpl_frameset_get_position(dark_frameset, 0);
349 
350  filename = cpl_frame_get_filename(frame);
351  cpl_msg_info (NULL, "This file %s is a dark file", filename);
352  data = gravi_data_load(filename);
353  primary_hdr = gravi_data_get_propertylist(data,
354  GRAVI_PRIMARY_HDR_NAME_EXT);
355  shutter = gravi_shutters_check(primary_hdr);
356 
357  /* The dark file must contains all the shutter close */
358  if (!((shutter[0] == 0) && (shutter[1] == 0) && (shutter[2] == 0)
359  && (shutter[3] == 0))){
360  cpl_frameset_delete(darkcalib_frameset);
361  cpl_frameset_delete(wave_frameset);
362  cpl_frameset_delete(flatcalib_frameset);
363  gravi_data_delete(data);
364  cpl_frameset_delete(dark_frameset);
365  cpl_frameset_delete(flat_frameset);
366  return (int)cpl_error_set_message(cpl_func,
367  CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem this file "
368  "is not a dark file");
369  }
370 
371  /* Compute the master dark */
372  dark_map = gravi_compute_dark(data);
373  if (cpl_error_get_code()) {
374  cpl_frameset_delete(darkcalib_frameset);
375  cpl_frameset_delete(wave_frameset);
376  cpl_frameset_delete(flatcalib_frameset);
377  gravi_data_delete(dark_map);
378  gravi_data_delete(data);
379  cpl_frameset_delete(dark_frameset);
380  cpl_frameset_delete(flat_frameset);
381  return (int)cpl_error_set_message(cpl_func,
382  CPL_ERROR_ILLEGAL_OUTPUT,
383  "Error while computing the dark_map");
384  }
385 
386  /* Save the dark map */
387  primary_hdr_dark = gravi_data_get_propertylist(dark_map,
388  GRAVI_PRIMARY_HDR_NAME_EXT);
389  applist = gravi_propertylist_get_qc(primary_hdr_dark);
390 // dit = gravi_pfits_get_dit(primary_hdr_dark);
391  //insname = gravi_pfits_get_insname(primary_hdr_dark);
392 
393  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, DARK);
394 // frame = cpl_frameset_get_first (dark_frameset);
395 
396 
397  if (gravi_data_save(dark_map, frameset, "gravi_final_dark.fits", parlist,
398  dark_frameset, frame, "gravi_all_wave", applist)
399  != CPL_ERROR_NONE){
400 
401  cpl_frameset_delete(darkcalib_frameset);
402  cpl_frameset_delete(wave_frameset);
403  cpl_frameset_delete(flatcalib_frameset);
404  gravi_data_delete(dark_map);
405  cpl_propertylist_delete(applist);
406  gravi_data_delete(data);
407  cpl_frameset_delete(dark_frameset);
408  cpl_frameset_delete(flat_frameset);
409  return (int) cpl_error_set_message(cpl_func,
410  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the dark_map"
411  " on the output file");
412  }
413 
414  cpl_propertylist_delete(applist);
415  gravi_data_delete(data);
416  cpl_free(shutter);
417 
418  }
419  else if (!cpl_frameset_is_empty(darkcalib_frameset)){
420  frame = cpl_frameset_get_position(darkcalib_frameset, 0);
421  cpl_frameset_insert (dark_frameset, cpl_frame_duplicate (frame));
422  filename = cpl_frame_get_filename(frame);
423 
424  cpl_msg_info (NULL, "This file %s is a dark file already "
425  "computed", filename);
426  dark_map = gravi_data_load(filename);
427 
428  }
429  /* Check that the dark_map in the input frameset */
430  else {
431  cpl_frameset_delete(darkcalib_frameset);
432  cpl_frameset_delete(wave_frameset);
433  cpl_frameset_delete(flatcalib_frameset);
434  gravi_data_delete(dark_map);
435  cpl_frameset_delete(dark_frameset);
436  cpl_frameset_delete(flat_frameset);
437  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_INPUT,
438  "No dark frames in the frameset");
439  }
440 
441  /* Compute the bad pixel map */
442  if (!cpl_frameset_is_empty(badpix_frameset)){
443  frame = cpl_frameset_get_position(badpix_frameset, 0);
444  filename = cpl_frame_get_filename(frame);
445  cpl_msg_info (NULL, "This file %s is a bad pixel map", filename);
446 
447  bad_map = gravi_data_load(filename);
448  }
449  else {
450  cpl_msg_info (NULL, "Compute bad pixel map");
451  bad_map = gravi_compute_badpix(dark_map, parlist);
452 
453  if (cpl_error_get_code()) {
454  gravi_data_delete(bad_map);
455  cpl_frameset_delete(darkcalib_frameset);
456  cpl_frameset_delete(wave_frameset);
457  cpl_frameset_delete(flatcalib_frameset);
458  gravi_data_delete(dark_map);
459  gravi_data_delete(data);
460  cpl_frameset_delete(dark_frameset);
461  cpl_frameset_delete(badpix_frameset);
462  cpl_frameset_delete(flat_frameset);
463  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
464  "Error while computing the bad pixel map");
465 
466  }
467  /* Save the pad pixel map */
468  bad_primary_hdr = gravi_data_get_propertylist (bad_map,
469  GRAVI_PRIMARY_HDR_NAME_EXT);
470  applist = gravi_propertylist_get_qc (bad_primary_hdr);
471 
472  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, BAD);
473 
474  frame = cpl_frameset_get_position (dark_frameset, 0);
475 
476  if (gravi_data_save (bad_map, frameset, "gravi_bad_map.fits", parlist,
477  dark_frameset, frame, "gravi_all_flat", applist)
478  != CPL_ERROR_NONE){
479  gravi_data_delete(data);
480  gravi_data_delete(bad_map);
481  cpl_frameset_delete(darkcalib_frameset);
482  cpl_frameset_delete(wave_frameset);
483  cpl_frameset_delete(flatcalib_frameset);
484  gravi_data_delete(dark_map);
485  cpl_frameset_delete(dark_frameset);
486  cpl_frameset_delete(flat_frameset);
487  return (int) cpl_error_set_message(cpl_func,
488  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the bad pixel map");
489  }
490  cpl_propertylist_delete (applist);
491  }
492 
493  cpl_frameset_delete(darkcalib_frameset);
494  cpl_frameset_delete(badpix_frameset);
495  cpl_frameset_delete(dark_frameset);
496 
497  /* Extract or conpute the profile map */
498 
499  if (!cpl_frameset_is_empty(flat_frameset)) {
500 
501  /* Construction of the raw data */
502  nb_frame_flat = cpl_frameset_get_size (flat_frameset);
503  raw_data = cpl_malloc(nb_frame_flat * sizeof(gravi_data *));
504  for (i = 0; i < nb_frame_flat; i++){
505  frame = cpl_frameset_get_position(flat_frameset, i);
506 
507  filename = cpl_frame_get_filename(frame);
508  raw_data[i] = gravi_data_load(filename);
509  }
510 
511 
512  /* Compute the profile */
513  profile_map = gravi_compute_profile(raw_data, dark_map, bad_map,
514  nb_frame_flat, parlist);
515 
516  if (cpl_error_get_code()){
517 // cpl_frameset_delete(darkcalib_frameset);
518 // cpl_frameset_delete(wave_frameset);
519 // cpl_frameset_delete(flatcalib_frameset);
520 // gravi_data_delete(profile_map);
521 // gravi_data_delete(dark_map);
522 // for (i = 0; i < nb_frame_flat; i++){
523 // gravi_data_delete(raw_data[i]);
524 // }
525 // cpl_free(raw_data);
526 // cpl_frameset_delete(dark_frameset);
527 // cpl_frameset_delete(flat_frameset);
528  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
529  "Compute of the profile map failed");
530  }
531 
532  /* Compute the gain and extract the gain map*/
533  gain_sc = gravi_compute_gain(raw_data, nb_frame_flat, dark_map,
534  GRAVI_IMAGING_DATA_SC_EXT);
535  gain_ft = gravi_compute_gain(raw_data, nb_frame_flat, dark_map,
536  GRAVI_IMAGING_DATA_FT_EXT);
537 // printf("gain_sc = %e gain_ft = %e\n",gain_sc, gain_ft);
538  /* Check that the gain map in the input frameset */
539 
540  if ((gain_ft == 0) || (gain_sc == 0)){
541 
542  cpl_frameset_delete(flatcalib_frameset);
543  cpl_frameset_delete(wave_frameset);
544  gravi_data_delete(dark_map);
545  gravi_data_delete(bad_map);
546  for (i = 0; i < nb_frame_flat; i++){
547  gravi_data_delete(raw_data[i]);
548  }
549  cpl_free(raw_data);
550  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
551  "Compute of the gain failed");
552  }
553  /* Save the profile map */
554  applist = cpl_propertylist_new();
555  cpl_propertylist_append_double (applist, QC_MEANGAIN_SC, gain_sc);
556  cpl_propertylist_append_double (applist, QC_MEANGAIN_FT, gain_ft);
557 
558  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, FLAT);
559  frame = cpl_frameset_get_position(flat_frameset, 0);
560  if (gravi_data_save(profile_map, frameset, "gravi_final_profile.fits",
561  parlist, flat_frameset, frame, "gravi_all_wave", applist)
562  != CPL_ERROR_NONE){
563 
564  cpl_frameset_delete(wave_frameset);
565 
566  cpl_frameset_delete(flatcalib_frameset);
567 
568  for (i = 0; i < nb_frame_flat; i++){
569  gravi_data_delete(raw_data[i]);
570  }
571  cpl_free(raw_data);
572  gravi_data_delete(bad_map);
573  gravi_data_delete(dark_map);
574  gravi_data_delete(profile_map);
575  cpl_propertylist_delete(applist);
576  cpl_frameset_delete(flat_frameset);
577  return (int) cpl_error_set_message(cpl_func,
578  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the profile_map"
579  " on the output file");
580  }
581  cpl_propertylist_delete(applist);
582  for (i = 0; i < nb_frame_flat; i++){
583  gravi_data_delete(raw_data[i]);
584  }
585  cpl_free(raw_data);
586 
587  }
588  else if (!cpl_frameset_is_empty(flatcalib_frameset)){
589 
590  frame = cpl_frameset_get_position(flatcalib_frameset, 0);
591  filename = cpl_frame_get_filename(frame);
592  cpl_msg_info (NULL, "This file %s is a flat file already "
593  "computed", filename);
594  profile_map = gravi_data_load(filename);
595 
596  }
597  else {
598 
599  cpl_frameset_delete(wave_frameset);
600  cpl_frameset_delete(flatcalib_frameset);
601  gravi_data_delete(profile_map);
602  gravi_data_delete(dark_map);
603  for (i = 0; i < nb_frame_flat; i++){
604  gravi_data_delete(raw_data[i]);
605  }
606  cpl_free(raw_data);
607  gravi_data_delete(bad_map);
608 
609  cpl_frameset_delete(flat_frameset);
610  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_INPUT,
611  "No profile frames in the frameset");
612  }
613 
614 
615  cpl_frameset_delete(flatcalib_frameset);
616 
617  cpl_frameset_delete(flat_frameset);
618 
619  /* Apply the treatment for each wave frame contained in the frameset */
620 
621 
622  cpl_table * opl_table = NULL, * p2vm_met, * metrology_table;
623  int met_check = 1;
624  cpl_propertylist * met_plist;
625  for (comp = 0; comp < nb_frame; comp++){
626 
627  /* Find the file name and initialization of the output name */
628  frame = cpl_frameset_get_position(wave_frameset, comp);
629  input = cpl_frame_get_filename(frame) ;
630  cpl_msg_info (NULL, "This file %s is a raw wave file", input);
631  output = cpl_sprintf("gravi_all_wave_0%d.fits", comp + 1);
632 
633  if (input == NULL) {
634  /* The file name does not exist */
635  cpl_free(output);
636  cpl_frameset_delete (wave_frameset);
637  gravi_data_delete(bad_map);
638  gravi_data_delete(profile_map);
639  gravi_data_delete(dark_map);
640 
641  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
642  "SOF does not have any file tagged ") ;
643  }
644 
645  /* This function computes the relation between spectral
646  * element and wavelength */
647  raw_wave = gravi_data_load(input);
648 
649  primary_hdr = gravi_data_get_propertylist (raw_wave,
650  GRAVI_PRIMARY_HDR_NAME_EXT);
651  shutter = gravi_shutters_check(primary_hdr);
652 
653  if ((shutter [0] != 1) || (shutter [1] != 1) ||
654  (shutter [2] != 1) || (shutter [3] != 1)){
655  cpl_msg_info (NULL, "The shutters of this file are not all open");
656  gravi_data_delete(raw_wave);
657  cpl_free(shutter);
658  cpl_free(output);
659 
660  continue;
661  }
662  /* Compute the p2vm of the metrology */
663  p = cpl_parameterlist_find_const(parlist, "gravi.gravi_all_p2vm."
664  "opd_met");
665  metrology_table = gravi_data_get_table(raw_wave,
666  GRAVI_METROLOGY_EXT);
667  clock_t start, end;
668  if ((cpl_parameter_get_bool (p)) && (met_check)){
669 // int rest;
670 // if ((cpl_table_get_nrow(metrology_table)%4) != 0)
671 // rest = 4 + (cpl_table_get_nrow(metrology_table)%4) ;
672 // else
673 // rest = 4;
674  met_plist = cpl_propertylist_duplicate (gravi_data_get_propertylist(raw_wave,
675  GRAVI_METROLOGY_EXT));
676  //mjd_obs = gravi_pfits_get_mjd (primary_hdr);
677  acq_start = gravi_pfits_get_acq_start (primary_hdr);
678 
679  acq_mjd = gravi_convert_to_mjd (acq_start);
680 
681  opl_table = cpl_table_new (cpl_table_get_nrow(metrology_table));
682  start = clock();
683  p2vm_met = gravi_metrology_calibration (metrology_table,
684  opl_table, 0);
685  end = clock();
686  printf ("Temps gravi_metrology_calibration : %f\n", (end - start) / (double)CLOCKS_PER_SEC);
687  if (cpl_error_get_code()) {
688  cpl_free(output);
689  gravi_data_delete(bad_map);
690  gravi_data_delete(raw_wave);
691  gravi_data_delete(profile_map);
692  gravi_data_delete(dark_map);
693  cpl_frameset_delete(wave_frameset);
694  cpl_propertylist_delete (met_plist);
695  cpl_table_delete(p2vm_met);
696  cpl_table_delete(opl_table);
697  cpl_free(shutter);
698  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
699  "Error while computing p2vm of the metrology");
700  }
701  met_check = 0;
702 
703  }
704  start = clock();
705  reduced_wave = gravi_compute_wave (raw_wave, profile_map, dark_map, bad_map,
706  opl_table, parlist);//gravi_data_duplicate(raw_wave); //gravi_extract_spectrum(raw_wave, profile_map, NULL);//gravi_compute_wave (raw_wave, profile_map);
707  end = clock();
708 
709  gravi_data_delete(raw_wave);
710  printf ("Temps gravi_compute_wave : %f\n", (end - start) / (double)CLOCKS_PER_SEC);
711 
712  if (cpl_error_get_code()) {
713  cpl_free(output);
714  gravi_data_delete(bad_map);
715  gravi_data_delete(reduced_wave);
716  gravi_data_delete(profile_map);
717  gravi_data_delete(dark_map);
718  cpl_frameset_delete(wave_frameset);
719  cpl_propertylist_delete (met_plist);
720  cpl_table_delete(p2vm_met);
721  cpl_table_delete(opl_table);
722  cpl_free(shutter);
723  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
724  "Error while computing the wavelength");
725  }
726  if ((cpl_parameter_get_bool (p)) && (met_check == 0)){
727  cpl_propertylist_set_string (met_plist, "EXTNAME",
728  GRAVI_P2VM_MET_EXT);
729 
730  gravi_data_add (reduced_wave, met_plist, p2vm_met);
731 
732 
733  cpl_table_delete (opl_table);
734  cpl_table_delete (p2vm_met);
735  cpl_propertylist_delete (met_plist);
736 
737  }
738 
739  primary_hdr = gravi_data_get_propertylist(reduced_wave,
740  GRAVI_PRIMARY_HDR_NAME_EXT);
741 
742  /* Create product frame, add DataFlow keywords, save the file, log the
743  * saved file in the input frameset*/
744  usedframes = cpl_frameset_new();
745  cpl_frameset_insert(usedframes, cpl_frame_duplicate(frame));
746  applist = gravi_propertylist_get_qc (primary_hdr);
747  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, WAVE);
748 
749  if (gravi_data_save(reduced_wave, frameset, output, parlist,
750  usedframes, frame, "gravi_all_wave", applist)
751  != CPL_ERROR_NONE){
752  cpl_free(output);
753  gravi_data_delete(bad_map);
754  gravi_data_delete(reduced_wave);
755  gravi_data_delete(profile_map);
756  gravi_data_delete(dark_map);
757  cpl_frameset_delete(wave_frameset);
758  cpl_frameset_delete(usedframes);
759  cpl_propertylist_delete(applist);
760  cpl_free(shutter);
761  return (int) cpl_error_set_message(cpl_func,
762  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the raw_wave"
763  " on the output file");
764  }
765 
766  gravi_data_delete(reduced_wave);
767 
768  cpl_frameset_delete(usedframes);
769  cpl_propertylist_delete(applist);
770  cpl_free(output);
771  cpl_free(shutter);
772 
773  }
774 
775 
776 
777  /* Deallocation of all variables */
778  gravi_data_delete(bad_map);
779  gravi_data_delete(profile_map);
780  gravi_data_delete(dark_map);
781 
782  cpl_frameset_delete(wave_frameset);
783 
784  return (int)cpl_error_get_code();
785 }
786 
787