GRAVI Pipeline Reference Manual  0.7.12
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 compute the effective wavelength of each element of the spectra \n"
64  "for SC and FT. It is computed from a set of raw wavelength integration with \n"
65  "scans on fddls."
66  "The master wave frame is created.\n"
67  "\n"
68  "Description DO category\n"
69  "Required input :\n"
70  " Raw dark file "GRAVI_DARK "\n"
71  " Raw flat file (4 files) "GRAVI_DARK "\n"
72  " Raw wave file "GRAVI_WAVE "\n"
73  "Or (optionally)\n"
74  " Master dark " DARK "\n"
75  " Master flat " FLAT "\n"
76  " Bad pixel map " BAD "\n"
77  "\n"
78  "Output :\n"
79  " Master wave " WAVE "\n"
80  " Master dark (opt.) " DARK "\n"
81  " Bad pixel map (opt.) " BAD "\n"
82  " Master flat (opt.) " FLAT "\n"
83  "\n";
84 
85 /*-----------------------------------------------------------------------------
86  Function code
87  -----------------------------------------------------------------------------*/
88 
89 /*----------------------------------------------------------------------------*/
99 /*----------------------------------------------------------------------------*/
100 int cpl_plugin_get_info(cpl_pluginlist * list)
101 {
102  cpl_recipe * recipe = cpl_calloc(1, sizeof *recipe );
103  cpl_plugin * plugin = &recipe->interface;
104 
105  if (cpl_plugin_init(plugin,
106  CPL_PLUGIN_API,
107  GRAVI_BINARY_VERSION,
108  CPL_PLUGIN_TYPE_RECIPE,
109  "gravi_all_wave",
110  "This recipe reduce the raw wavelength calibration file.",
111  gravi_all_wave_description,
112  "Firstname Lastname",
113  PACKAGE_BUGREPORT,
114  gravi_get_license(),
115  gravi_all_wave_create,
116  gravi_all_wave_exec,
117  gravi_all_wave_destroy)) {
118  cpl_msg_error(cpl_func, "Plugin initialization failed");
119  (void)cpl_error_set_where(cpl_func);
120  return 1;
121  }
122 
123  if (cpl_pluginlist_append(list, plugin)) {
124  cpl_msg_error(cpl_func, "Error adding plugin to list");
125  (void)cpl_error_set_where(cpl_func);
126  return 1;
127  }
128 
129  return 0;
130 }
131 
132 /*----------------------------------------------------------------------------*/
140 /*----------------------------------------------------------------------------*/
141 static int gravi_all_wave_create(cpl_plugin * plugin)
142 {
143  cpl_recipe * recipe;
144  cpl_parameter * p;
145 
146  /* Do not create the recipe if an error code is already set */
147  if (cpl_error_get_code() != CPL_ERROR_NONE) {
148  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
149  cpl_func, __LINE__, cpl_error_get_where());
150  return (int)cpl_error_get_code();
151  }
152 
153  if (plugin == NULL) {
154  cpl_msg_error(cpl_func, "Null plugin");
155  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
156  }
157 
158  /* Verify plugin type */
159  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
160  cpl_msg_error(cpl_func, "Plugin is not a recipe");
161  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
162  }
163 
164  /* Get the recipe */
165  recipe = (cpl_recipe *)plugin;
166 
167  /* Create the parameters list in the cpl_recipe object */
168  recipe->parameters = cpl_parameterlist_new();
169  if (recipe->parameters == NULL) {
170  cpl_msg_error(cpl_func, "Parameter list allocation failed");
171  cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
172  }
173 
174  /* --the width of the profile element */
175  p = cpl_parameter_new_value("gravi.gravi_all_flat."
176  "profile_width", CPL_TYPE_INT, "profile width option (if no master"
177  "flat as input)", "gravi.gravi_all_flat", 5);
178  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "profile-width");
179  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
180  cpl_parameterlist_append(recipe->parameters, p);
181 
182  p = cpl_parameter_new_value("gravi."
183  "flat_param.Bad_dark_threshold", CPL_TYPE_INT, "the rms factor for "
184  "dark bad pixel threshold (if no bad pix as input)",
185  "gravi.gravi_all_wave", 10);
186  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "bad-dark-threshold");
187  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
188  cpl_parameterlist_append(recipe->parameters, p);
189 
190 
191  /* Fill the parameters list */
192  return 0;
193 }
194 
195 /*----------------------------------------------------------------------------*/
201 /*----------------------------------------------------------------------------*/
202 static int gravi_all_wave_exec(cpl_plugin * plugin)
203 {
204 
205  cpl_recipe * recipe;
206  int recipe_status;
207  cpl_errorstate initial_errorstate = cpl_errorstate_get();
208 
209  /* Return immediately if an error code is already set */
210  if (cpl_error_get_code() != CPL_ERROR_NONE) {
211  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
212  cpl_func, __LINE__, cpl_error_get_where());
213  return (int)cpl_error_get_code();
214  }
215 
216  if (plugin == NULL) {
217  cpl_msg_error(cpl_func, "Null plugin");
218  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
219  }
220 
221  /* Verify plugin type */
222  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
223  cpl_msg_error(cpl_func, "Plugin is not a recipe");
224  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
225  }
226 
227  /* Get the recipe */
228  recipe = (cpl_recipe *)plugin;
229 
230  /* Verify parameter and frame lists */
231  if (recipe->parameters == NULL) {
232  cpl_msg_error(cpl_func, "Recipe invoked with NULL parameter list");
233  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
234  }
235  if (recipe->frames == NULL) {
236  cpl_msg_error(cpl_func, "Recipe invoked with NULL frame set");
237  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
238  }
239 
240  /* Invoke the recipe */
241  recipe_status = gravi_all_wave(recipe->frames, recipe->parameters);
242 
243  /* Ensure DFS-compliance of the products */
244  if (cpl_dfs_update_product_header(recipe->frames)) {
245  if (!recipe_status) recipe_status = (int)cpl_error_get_code();
246  }
247 
248  if (!cpl_errorstate_is_equal(initial_errorstate)) {
249  /* Dump the error history since recipe execution start.
250  At this point the recipe cannot recover from the error */
251  cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
252  }
253 
254  return recipe_status;
255 }
256 
257 /*----------------------------------------------------------------------------*/
263 /*----------------------------------------------------------------------------*/
264 static int gravi_all_wave_destroy(cpl_plugin * plugin)
265 {
266  cpl_recipe * recipe;
267 
268  if (plugin == NULL) {
269  cpl_msg_error(cpl_func, "Null plugin");
270  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
271  }
272 
273  /* Verify plugin type */
274  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
275  cpl_msg_error(cpl_func, "Plugin is not a recipe");
276  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
277  }
278 
279  /* Get the recipe */
280  recipe = (cpl_recipe *)plugin;
281 
282  cpl_parameterlist_delete(recipe->parameters);
283 
284  return 0;
285 }
286 
287 
288 /*----------------------------------------------------------------------------*/
296 /*----------------------------------------------------------------------------*/
297 static int gravi_all_wave(cpl_frameset * frameset,
298  const cpl_parameterlist * parlist)
299 {
300  cpl_frameset * waveRaw_frameset = NULL, * usedframes, * flatcalib_frameset,
301  * darkcalib_frameset, * flat_frameset, *badpix_frameset,
302  * dark_frameset, * waveArgon_frameset, * wave_frameset,
303  * darkArgon_frameset;
304  cpl_frame * frame, * frame_;
305  cpl_propertylist * applist, * primary_hdr, *primary_hdr_dark, * bad_primary_hdr;
306  const char * input, * filename, * filename_, * temp;
307  char * output;
308  //const cpl_parameter * param_;
309  double /*dit,*/ gain_ft, gain_sc, acq_mjd;
310  const char * acq_start;
311  gravi_data * raw_wave, * reduced_wave, * profile_map, * dark_map, * bad_map,
312  ** raw_data, * data, ** calib_datas;
313  gravi_data * argon_data, * reduced_wave_argon, * darkArgon_map = NULL;
314  int * shutter;
315  int comp, nb_frame, nb_frame_flat, i;
316  clock_t start, end;
317 
318  /* Message */
319  cpl_msg_set_time_on();
320  cpl_msg_set_component_on();
321  cpl_msg_info(cpl_func,"Start function");
322 
323  /* Identify the RAW and CALIB frames in the input frameset */
324  cpl_ensure_code(gravi_dfs_set_groups(frameset) == CPL_ERROR_NONE,
325  cpl_error_get_code()) ;
326 
327  /* - Extract a set of frame wave */
328  waveRaw_frameset = gravi_frameset_extract_wave(frameset);
329  wave_frameset = gravi_frameset_extract_wave_file(frameset);
330 
331  waveArgon_frameset = gravi_frameset_extract_waveArgon(frameset);
332  darkArgon_frameset = gravi_frameset_extract_darkArgon(frameset);
333  flatcalib_frameset = gravi_frameset_extract_flat_file(frameset);
334  darkcalib_frameset = gravi_frameset_extract_dark_file(frameset);
335  flat_frameset = gravi_frameset_extract_flat(frameset);
336  dark_frameset = gravi_frameset_extract_dark(frameset);
337  badpix_frameset = gravi_frameset_extract_badpix(frameset);
338  if (cpl_frameset_is_empty(waveRaw_frameset) && cpl_frameset_is_empty(wave_frameset) ) {
339  /* To use this recipe the frameset must contain at least
340  * one wave frame. */
341  cpl_frameset_delete(darkcalib_frameset);
342  cpl_frameset_delete(flatcalib_frameset);
343  cpl_frameset_delete(waveRaw_frameset);
344  cpl_frameset_delete(dark_frameset);
345  cpl_frameset_delete(flat_frameset);
346  cpl_frameset_delete(badpix_frameset);
347  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_INPUT,
348  "No wave file in the frameset") ;
349  }
350 
351  if (cpl_frameset_is_empty(flatcalib_frameset) && cpl_frameset_is_empty(flat_frameset) ) {
352  /* To use this recipe the frameset must contain at least
353  * one wave frame. */
354  cpl_frameset_delete(darkcalib_frameset);
355  cpl_frameset_delete(flatcalib_frameset);
356  cpl_frameset_delete(waveRaw_frameset);
357  cpl_frameset_delete(dark_frameset);
358  cpl_frameset_delete(flat_frameset);
359  cpl_frameset_delete(badpix_frameset);
360  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_INPUT,
361  "No flat file in the frameset") ;
362  }
363 
364  if (cpl_frameset_is_empty(darkcalib_frameset) &&
365  cpl_frameset_is_empty(dark_frameset) &&
366  cpl_frameset_is_empty(wave_frameset)) {
367  /* To use this recipe the frameset must contain at least
368  * one wave frame. */
369  cpl_frameset_delete(darkcalib_frameset);
370  cpl_frameset_delete(flatcalib_frameset);
371  cpl_frameset_delete(waveRaw_frameset);
372  cpl_frameset_delete(dark_frameset);
373  cpl_frameset_delete(flat_frameset);
374  cpl_frameset_delete(badpix_frameset);
375  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_INPUT,
376  "No dark file in the frameset") ;
377  }
378 
379  /* Check and get the dark frame */
380 
381  if (!cpl_frameset_is_empty(dark_frameset)) {
382  frame = cpl_frameset_get_position(dark_frameset, 0);
383 
384  filename_ = cpl_frame_get_filename(frame);
385  temp = strrchr(filename_, '/');
386  filename = temp ? temp + 1 : filename_;
387  cpl_msg_info (cpl_func, "This file %s is a dark file", filename);
388  data = gravi_data_load(filename_);
389  primary_hdr = gravi_data_get_propertylist(data,
390  GRAVI_PRIMARY_HDR_NAME_EXT);
391  shutter = gravi_shutters_check(primary_hdr);
392 
393 // /* The dark file must contains all the shutter close */
394 // if (!((shutter[0] == 0) && (shutter[1] == 0) && (shutter[2] == 0)
395 // && (shutter[3] == 0))){
396 // cpl_frameset_delete(darkcalib_frameset);
397 // cpl_frameset_delete(waveRaw_frameset);
398 // cpl_frameset_delete(flatcalib_frameset);
399 // gravi_data_delete(data);
400 // cpl_frameset_delete(dark_frameset);
401 // cpl_frameset_delete(flat_frameset);
402 // return (int)cpl_error_set_message(cpl_func,
403 // CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem this file "
404 // "is not a dark file");
405 // }
406 
407  /* Compute the master dark */
408  dark_map = gravi_compute_dark(data);
409  if (cpl_error_get_code()) {
410  cpl_frameset_delete(darkcalib_frameset);
411  cpl_frameset_delete(waveRaw_frameset);
412  cpl_frameset_delete(flatcalib_frameset);
413  gravi_data_delete(dark_map);
414  gravi_data_delete(data);
415  cpl_frameset_delete(dark_frameset);
416  cpl_frameset_delete(flat_frameset);
417  return (int)cpl_error_set_message(cpl_func,
418  CPL_ERROR_ILLEGAL_OUTPUT,
419  "Error while computing the dark_map");
420  }
421 
422  /* Save the dark map */
423  primary_hdr_dark = gravi_data_get_propertylist(dark_map,
424  GRAVI_PRIMARY_HDR_NAME_EXT);
425  applist = gravi_propertylist_get_qc(primary_hdr_dark);
426 // dit = gravi_pfits_get_dit(primary_hdr_dark);
427  //insname = gravi_pfits_get_insname(primary_hdr_dark);
428 
429  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, DARK);
430 // frame = cpl_frameset_get_first (dark_frameset);
431 
432  // output = cpl_sprintf("master_dark.%s", filename);
433  output = gravi_data_product_name (filename, "dark");
434 
435  if (gravi_data_save(dark_map, frameset, output, parlist,
436  dark_frameset, frame, "gravi_all_wave", applist)
437  != CPL_ERROR_NONE){
438 
439  cpl_frameset_delete(darkcalib_frameset);
440  cpl_frameset_delete(waveRaw_frameset);
441  cpl_frameset_delete(flatcalib_frameset);
442  gravi_data_delete(dark_map);
443  cpl_propertylist_delete(applist);
444  gravi_data_delete(data);
445  cpl_frameset_delete(dark_frameset);
446  cpl_frameset_delete(flat_frameset);
447  return (int) cpl_error_set_message(cpl_func,
448  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the dark_map"
449  " on the output file");
450  }
451 
452  cpl_propertylist_delete(applist);
453  gravi_data_delete(data);
454  cpl_free(shutter);
455  cpl_free (output);
456 
457  }
458  else if (!cpl_frameset_is_empty(darkcalib_frameset)){
459  frame = cpl_frameset_get_position(darkcalib_frameset, 0);
460  cpl_frameset_insert (dark_frameset, cpl_frame_duplicate (frame));
461  filename_ = cpl_frame_get_filename(frame);
462  temp = strrchr(filename_, '/');
463  filename = temp ? temp + 1 : filename_;
464 
465  cpl_msg_info (cpl_func, "This file %s is a dark file already "
466  "computed", filename);
467  dark_map = gravi_data_load(filename_);
468 
469  }
470 
471  /* Compute the bad pixel map */
472  if (!cpl_frameset_is_empty(badpix_frameset)){
473  frame = cpl_frameset_get_position(badpix_frameset, 0);
474  filename_ = cpl_frame_get_filename(frame);
475  temp = strrchr(filename_, '/');
476  filename = temp ? temp + 1 : filename_;
477  cpl_msg_info (cpl_func, "This file %s is a bad pixel map", filename);
478 
479  bad_map = gravi_data_load(filename_);
480  }
481  else {
482  cpl_msg_info (cpl_func, "Compute bad pixel map");
483  bad_map = gravi_compute_badpix(dark_map, parlist);
484 
485  if (cpl_error_get_code()) {
486  gravi_data_delete(bad_map);
487  cpl_frameset_delete(darkcalib_frameset);
488  cpl_frameset_delete(waveRaw_frameset);
489  cpl_frameset_delete(flatcalib_frameset);
490  gravi_data_delete(dark_map);
491  gravi_data_delete(data);
492  cpl_frameset_delete(dark_frameset);
493  cpl_frameset_delete(badpix_frameset);
494  cpl_frameset_delete(flat_frameset);
495  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
496  "Error while computing the bad pixel map");
497 
498  }
499  /* Save the pad pixel map */
500  bad_primary_hdr = gravi_data_get_propertylist (bad_map,
501  GRAVI_PRIMARY_HDR_NAME_EXT);
502  applist = gravi_propertylist_get_qc (bad_primary_hdr);
503 
504  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, BAD);
505 
506  frame = cpl_frameset_get_position (dark_frameset, 0);
507 
508  temp = strrchr(filename, '/');
509  filename = temp?temp+1:filename;
510 
511  // output = cpl_sprintf("badpix.%s", filename);
512  output = gravi_data_product_name (filename, "badpix");
513 
514  if (gravi_data_save (bad_map, frameset, output, parlist,
515  dark_frameset, frame, "gravi_all_wave", applist)
516  != CPL_ERROR_NONE){
517  gravi_data_delete(data);
518  gravi_data_delete(bad_map);
519  cpl_frameset_delete(darkcalib_frameset);
520  cpl_frameset_delete(waveRaw_frameset);
521  cpl_frameset_delete(flatcalib_frameset);
522  gravi_data_delete(dark_map);
523  cpl_frameset_delete(dark_frameset);
524  cpl_frameset_delete(flat_frameset);
525  return (int) cpl_error_set_message(cpl_func,
526  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the bad pixel map");
527  }
528  cpl_propertylist_delete (applist);
529  cpl_free (output);
530  }
531 
532  cpl_frameset_delete(darkcalib_frameset);
533  cpl_frameset_delete(badpix_frameset);
534  cpl_frameset_delete(dark_frameset);
535 
536  /* Extract or conpute the profile map */
537 
538  if (!cpl_frameset_is_empty(flat_frameset)) {
539 
540  /* Construction of the raw data */
541  nb_frame_flat = cpl_frameset_get_size (flat_frameset);
542  raw_data = cpl_malloc(nb_frame_flat * sizeof(gravi_data *));
543  for (i = 0; i < nb_frame_flat; i++){
544  frame = cpl_frameset_get_position(flat_frameset, i);
545 
546  filename = cpl_frame_get_filename(frame);
547  raw_data[i] = gravi_data_load(filename);
548  }
549 
550 
551  /* Compute the profile */
552  profile_map = gravi_compute_profile(raw_data, dark_map, bad_map,
553  nb_frame_flat, parlist);
554 
555  if (cpl_error_get_code()){
556 
557  cpl_frameset_delete(waveRaw_frameset);
558  cpl_frameset_delete(flatcalib_frameset);
559  gravi_data_delete(profile_map);
560  gravi_data_delete(dark_map);
561  for (i = 0; i < nb_frame_flat; i++){
562  gravi_data_delete(raw_data[i]);
563  }
564  cpl_free(raw_data);
565  cpl_frameset_delete(flat_frameset);
566  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
567  "Compute of the profile map failed");
568  }
569 
570  /* Compute the gain and extract the gain map*/
571  gain_sc = gravi_compute_gain(raw_data, nb_frame_flat, dark_map, bad_map,
572  GRAVI_IMAGING_DATA_SC_EXT);
573  gain_ft = gravi_compute_gain(raw_data, nb_frame_flat, dark_map, bad_map,
574  GRAVI_IMAGING_DATA_FT_EXT);
575 // printf("gain_sc = %e gain_ft = %e\n",gain_sc, gain_ft);
576  /* Check that the gain map in the input frameset */
577 
578  if ((gain_ft == 0) || (gain_sc == 0)){
579 
580  cpl_frameset_delete(flatcalib_frameset);
581  cpl_frameset_delete(waveRaw_frameset);
582  gravi_data_delete(dark_map);
583  gravi_data_delete(bad_map);
584  for (i = 0; i < nb_frame_flat; i++){
585  gravi_data_delete(raw_data[i]);
586  }
587  cpl_free(raw_data);
588  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
589  "Compute of the gain failed");
590  }
591  /* Save the profile map */
592  applist = cpl_propertylist_new();
593  cpl_propertylist_append_double (applist, QC_MEANGAIN_SC, gain_sc);
594  cpl_propertylist_append_double (applist, QC_MEANGAIN_FT, gain_ft);
595 
596  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, FLAT);
597  frame = cpl_frameset_get_position(flat_frameset, 0);
598  temp = strrchr(filename, '/');
599  filename_ = temp?temp+1:filename;
600 
601 
602  // output = cpl_sprintf("master_profile.%s", filename_);
603  output = gravi_data_product_name (filename, "flat");
604 
605  if (gravi_data_save(profile_map, frameset, output,
606  parlist, flat_frameset, frame, "gravi_all_wave", applist)
607  != CPL_ERROR_NONE){
608 
609  cpl_frameset_delete(waveRaw_frameset);
610 
611  cpl_frameset_delete(flatcalib_frameset);
612 
613  for (i = 0; i < nb_frame_flat; i++){
614  gravi_data_delete(raw_data[i]);
615  }
616  cpl_free(raw_data);
617  gravi_data_delete(bad_map);
618  gravi_data_delete(dark_map);
619  gravi_data_delete(profile_map);
620  cpl_propertylist_delete(applist);
621  cpl_frameset_delete(flat_frameset);
622  return (int) cpl_error_set_message(cpl_func,
623  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the profile_map"
624  " on the output file");
625  }
626  cpl_propertylist_delete(applist);
627  cpl_free (output);
628  for (i = 0; i < nb_frame_flat; i++){
629  gravi_data_delete(raw_data[i]);
630  }
631  cpl_free(raw_data);
632 
633  }
634  else if (!cpl_frameset_is_empty(flatcalib_frameset)){
635 
636  frame = cpl_frameset_get_position(flatcalib_frameset, 0);
637  filename_ = cpl_frame_get_filename(frame);
638  temp = strrchr(filename_, '/');
639  filename = temp ? temp + 1 : filename_;
640  cpl_msg_info (cpl_func, "This file %s is a flat file already "
641  "computed", filename);
642  profile_map = gravi_data_load(filename_);
643 
644  }
645 
646  cpl_frameset_delete(flatcalib_frameset);
647 
648  cpl_frameset_delete(flat_frameset);
649 
650  /* Apply the treatment for each wave frame contained in the frameset */
651 
652  if (!cpl_frameset_is_empty(waveRaw_frameset)) {
653  cpl_table * opl_table = NULL, * p2vm_met, * metrology_table;
654 
655  cpl_propertylist * met_plist;
656  nb_frame = cpl_frameset_get_size(waveRaw_frameset);
657  for (comp = 0; comp < nb_frame; comp++){
658 
659  /* Find the file name and initialization of the output name */
660  frame = cpl_frameset_get_position(waveRaw_frameset, comp);
661  input = cpl_frame_get_filename(frame) ;
662  if (input == NULL) {
663  /* The file name does not exist */
664 
665  cpl_frameset_delete (waveRaw_frameset);
666  gravi_data_delete(bad_map);
667  gravi_data_delete(profile_map);
668  gravi_data_delete(dark_map);
669 
670  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
671  "SOF does not have any file tagged ") ;
672  }
673  temp = strrchr(input, '/');
674  filename = temp ? temp + 1 : input;
675  cpl_msg_info (cpl_func, "This file %s is a raw wave file", filename);
676 
677 
678  // output = cpl_sprintf("master_wave.%s", filename);
679  output = gravi_data_product_name (filename, "wave");
680 
681  /* This function computes the relation between spectral
682  * element and wavelength */
683  raw_wave = gravi_data_load(input);
684 
685  primary_hdr = gravi_data_get_propertylist (raw_wave,
686  GRAVI_PRIMARY_HDR_NAME_EXT);
687  shutter = gravi_shutters_check(primary_hdr);
688 
689  if ((shutter [0] != 1) || (shutter [1] != 1) ||
690  (shutter [2] != 1) || (shutter [3] != 1)){
691  cpl_msg_info (cpl_func, "The shutters of this file are not all open");
692  gravi_data_delete(raw_wave);
693  cpl_free(shutter);
694  cpl_free(output);
695 
696  continue;
697  }
698  cpl_free(shutter);
699  /* Compute the p2vm of the metrology */
700 
701  metrology_table = gravi_data_get_table(raw_wave,
702  GRAVI_METROLOGY_EXT);
703 
704  met_plist = cpl_propertylist_duplicate (gravi_data_get_propertylist(raw_wave,
705  GRAVI_METROLOGY_EXT));
706  //mjd_obs = gravi_pfits_get_mjd (primary_hdr);
707  acq_start = gravi_pfits_get_acq_start (primary_hdr);
708 
709  acq_mjd = gravi_convert_to_mjd (acq_start);
710 
711  opl_table = cpl_table_new (cpl_table_get_nrow(metrology_table));
712  start = clock();
713  p2vm_met = gravi_metrology_calibration (metrology_table,
714  opl_table, 0);
715  end = clock();
716  cpl_msg_info(cpl_func,"Execution time gravi_metrology_calibration : %f", (end - start) / (double)CLOCKS_PER_SEC);
717  if (cpl_error_get_code()) {
718  cpl_free(output);
719  gravi_data_delete(bad_map);
720  gravi_data_delete(raw_wave);
721  gravi_data_delete(profile_map);
722  gravi_data_delete(dark_map);
723  cpl_frameset_delete(waveRaw_frameset);
724  cpl_propertylist_delete (met_plist);
725  cpl_table_delete(p2vm_met);
726  cpl_table_delete(opl_table);
727 
728  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
729  "Error while computing p2vm of the metrology");
730  }
731 
732  start = clock();
733  reduced_wave = gravi_compute_wave (raw_wave, profile_map, dark_map, bad_map,
734  opl_table, parlist);//gravi_data_duplicate(raw_wave); //gravi_extract_spectrum(raw_wave, profile_map, NULL);//gravi_compute_wave (raw_wave, profile_map);
735  end = clock();
736 
737  gravi_data_delete(raw_wave);
738  cpl_msg_info(cpl_func,"Execution time gravi_compute_wave : %f", (end - start) / (double)CLOCKS_PER_SEC);
739 
740  if (cpl_error_get_code()) {
741  cpl_free(output);
742  gravi_data_delete(bad_map);
743  gravi_data_delete(reduced_wave);
744  gravi_data_delete(profile_map);
745  gravi_data_delete(dark_map);
746  cpl_frameset_delete(waveRaw_frameset);
747  cpl_propertylist_delete (met_plist);
748  cpl_table_delete(p2vm_met);
749  cpl_table_delete(opl_table);
750 
751  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
752  "Error while computing the wavelength");
753  }
754 
755  cpl_propertylist_set_string (met_plist, "EXTNAME",
756  GRAVI_P2VM_MET_EXT);
757 
758  gravi_data_add (reduced_wave, met_plist, p2vm_met);
759 
760  cpl_table_delete (opl_table);
761  cpl_propertylist_delete (met_plist);
762 
763  primary_hdr = gravi_data_get_propertylist(reduced_wave,
764  GRAVI_PRIMARY_HDR_NAME_EXT);
765 
766  /* Create product frame, add DataFlow keywords, save the file, log the
767  * saved file in the input frameset*/
768  usedframes = cpl_frameset_new();
769  cpl_frameset_insert(usedframes, cpl_frame_duplicate(frame));
770  applist = gravi_propertylist_get_qc (primary_hdr);
771  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, WAVE);
772 
773  if (gravi_data_save(reduced_wave, frameset, output, parlist,
774  usedframes, frame, "gravi_all_wave", applist)
775  != CPL_ERROR_NONE){
776  cpl_free(output);
777  gravi_data_delete(bad_map);
778  gravi_data_delete(reduced_wave);
779  gravi_data_delete(profile_map);
780  gravi_data_delete(dark_map);
781  cpl_frameset_delete(waveRaw_frameset);
782  cpl_frameset_delete(usedframes);
783  cpl_propertylist_delete(applist);
784 
785  return (int) cpl_error_set_message(cpl_func,
786  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the raw_wave"
787  " on the output file");
788  }
789 
790  cpl_free(output);
791  cpl_propertylist_delete(applist);
792  /* Find the file name and initialization of the output name
793  * and compute the calibration of the wavelength corrected
794  * by the argon if it exists in the input frameset*/
795 
796  if (!cpl_frameset_is_empty (waveArgon_frameset)){
797 
798 
799  if (!cpl_frameset_is_empty (darkArgon_frameset)){
800  frame = cpl_frameset_get_position(darkArgon_frameset, 0);
801 
802  filename_ = cpl_frame_get_filename(frame);
803  temp = strrchr(filename_, '/');
804  filename = temp ? temp + 1 : filename_;
805  cpl_msg_info (cpl_func, "This file %s is a dark Argon file", filename);
806  data = gravi_data_load(filename_);
807  primary_hdr = gravi_data_get_propertylist(data,
808  GRAVI_PRIMARY_HDR_NAME_EXT);
809  shutter = gravi_shutters_check(primary_hdr);
810 
811  // /* The dark file must contains all the shutter close */
812  // if (!((shutter[0] == 0) && (shutter[1] == 0) && (shutter[2] == 0)
813  // && (shutter[3] == 0))){
814  // cpl_frameset_delete(darkcalib_frameset);
815  // cpl_frameset_delete(waveRaw_frameset);
816  // cpl_frameset_delete(flatcalib_frameset);
817  // gravi_data_delete(data);
818  // cpl_frameset_delete(dark_frameset);
819  // cpl_frameset_delete(flat_frameset);
820  // return (int)cpl_error_set_message(cpl_func,
821  // CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem this file "
822  // "is not a dark file");
823  // }
824 
825  /* Compute the master dark */
826  darkArgon_map = gravi_compute_dark(data);
827  gravi_data_delete (data);
828  cpl_free (shutter);
829  }
830  else {
831  darkArgon_map = gravi_data_duplicate (dark_map);
832  }
833 
834 
835  frame_ = cpl_frameset_get_position(waveArgon_frameset, 0);
836  input = cpl_frame_get_filename(frame_) ;
837  if (input == NULL) {
838  /* The file name does not exist */
839 
840  cpl_frameset_delete (waveRaw_frameset);
841  gravi_data_delete(bad_map);
842  gravi_data_delete(profile_map);
843  gravi_data_delete(dark_map);
844  gravi_data_delete(darkArgon_map);
845 
846  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
847  "SOF does not have any file tagged ") ;
848  }
849  temp = strrchr(input, '/');
850  filename = temp ? temp + 1 : input;
851  cpl_msg_info (cpl_func, "This file %s is a raw wave file", filename);
852 
853  argon_data = gravi_data_load(input);
854  // output = cpl_sprintf("master_waveArgon.%s", filename);
855  output = gravi_data_product_name (filename, "waveArgon");
856 
857  start = clock();
858  reduced_wave_argon = gravi_fit_argon (argon_data, reduced_wave,
859  profile_map, darkArgon_map, bad_map);//gravi_data_duplicate(raw_wave); //gravi_extract_spectrum(raw_wave, profile_map, NULL);//gravi_compute_wave (raw_wave, profile_map);
860  end = clock();
861 
862  gravi_data_delete (argon_data);
863 
864  cpl_frameset_join (usedframes, cpl_frameset_duplicate (waveArgon_frameset));
865  primary_hdr = gravi_data_get_propertylist(reduced_wave_argon, GRAVI_PRIMARY_HDR_NAME_EXT);
866  applist = gravi_propertylist_get_qc (primary_hdr);
867  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, WAVE);
868 
869  if (gravi_data_save(reduced_wave_argon, frameset, output, parlist,
870  usedframes, frame_, "gravi_all_wave", applist)
871  != CPL_ERROR_NONE){
872  cpl_free(output);
873  gravi_data_delete(bad_map);
874  gravi_data_delete(reduced_wave);
875  gravi_data_delete(profile_map);
876  gravi_data_delete(dark_map);
877  gravi_data_delete(darkArgon_map);
878  cpl_frameset_delete(waveRaw_frameset);
879  cpl_frameset_delete(usedframes);
880  cpl_propertylist_delete(applist);
881 
882  return (int) cpl_error_set_message(cpl_func,
883  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the raw_wave"
884  " on the output file");
885  }
886  cpl_propertylist_delete(applist);
887 
888  cpl_free(output);
889 
890  gravi_data * waveCorrected = gravi_compute_wave_offset (reduced_wave_argon, reduced_wave);
891  // output = cpl_sprintf("waveCorrected.%s", filename);
892  output = gravi_data_product_name (filename, "waveOffset");
893  primary_hdr = gravi_data_get_propertylist(waveCorrected, GRAVI_PRIMARY_HDR_NAME_EXT);
894  applist = gravi_propertylist_get_qc (primary_hdr);
895  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, WAVE);
896 
897  if (gravi_data_save(waveCorrected, frameset, output, parlist,
898  usedframes, frame_, "gravi_all_wave", applist)
899  != CPL_ERROR_NONE){
900  cpl_free(output);
901  gravi_data_delete(bad_map);
902  gravi_data_delete(reduced_wave);
903  gravi_data_delete(profile_map);
904  gravi_data_delete(dark_map);
905  gravi_data_delete(darkArgon_map);
906  cpl_frameset_delete(waveRaw_frameset);
907  cpl_frameset_delete(usedframes);
908  cpl_propertylist_delete(applist);
909  //cpl_free(shutter);
910  return (int) cpl_error_set_message(cpl_func,
911  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the wave corrected "
912  "calibration on the output file");
913  }
914 
915  cpl_propertylist_delete(applist);
916  gravi_data_delete(waveCorrected);
917  gravi_data_delete(reduced_wave_argon);
918  cpl_free(output);
919  }
920  gravi_data_delete(reduced_wave);
921 
922  cpl_frameset_delete(usedframes);
923 
924  }
925  }
926 
927  /* The case where the wavelength is already calibrated
928  * using gravi_compute_wave and the argon file is in the input frameset */
929 
930  else if (!cpl_frameset_is_empty(wave_frameset)) {
931 
932  frame = cpl_frameset_get_position(wave_frameset, 0);
933  input = cpl_frame_get_filename(frame) ;
934  if (input == NULL) {
935  /* The file name does not exist */
936 
937  cpl_frameset_delete (waveRaw_frameset);
938  cpl_frameset_delete (wave_frameset);
939  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
940  "SOF does not have any file tagged ") ;
941  }
942 
943  temp = strrchr(input, '/');
944  filename = temp ? temp + 1 : input;
945  cpl_msg_info (cpl_func, "This file %s is wave calibrated file", filename);
946 
947  reduced_wave = gravi_data_load(input);
948 
949  if (!cpl_frameset_is_empty (darkArgon_frameset)){
950  frame = cpl_frameset_get_position(darkArgon_frameset, 0);
951 
952  filename_ = cpl_frame_get_filename(frame);
953  temp = strrchr(filename_, '/');
954  filename = temp ? temp + 1 : filename_;
955  cpl_msg_info (cpl_func, "This file %s is a dark Argon file", filename);
956  data = gravi_data_load(filename_);
957  primary_hdr = gravi_data_get_propertylist(data,
958  GRAVI_PRIMARY_HDR_NAME_EXT);
959  shutter = gravi_shutters_check(primary_hdr);
960 
961  // /* The dark file must contains all the shutter close */
962  // if (!((shutter[0] == 0) && (shutter[1] == 0) && (shutter[2] == 0)
963  // && (shutter[3] == 0))){
964  // cpl_frameset_delete(darkcalib_frameset);
965  // cpl_frameset_delete(waveRaw_frameset);
966  // cpl_frameset_delete(flatcalib_frameset);
967  // gravi_data_delete(data);
968  // cpl_frameset_delete(dark_frameset);
969  // cpl_frameset_delete(flat_frameset);
970  // return (int)cpl_error_set_message(cpl_func,
971  // CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem this file "
972  // "is not a dark file");
973  // }
974 
975  /* Compute the master dark */
976  darkArgon_map = gravi_compute_dark(data);
977  gravi_data_delete (data);
978  cpl_free (shutter);
979  }
980  else {
981  darkArgon_map = gravi_data_duplicate (dark_map);
982  }
983 
984  /* This function computes the relation between spectral
985  * element and wavelength */
986 
987  frame_ = cpl_frameset_get_position(waveArgon_frameset, 0);
988  input = cpl_frame_get_filename(frame_) ;
989  if (input == NULL) {
990  /* The file name does not exist */
991 
992  cpl_frameset_delete (waveRaw_frameset);
993  gravi_data_delete(bad_map);
994  gravi_data_delete(profile_map);
995  gravi_data_delete(dark_map);
996 
997  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
998  "SOF does not have any file tagged ") ;
999  }
1000  temp = strrchr(input, '/');
1001  filename = temp ? temp + 1 : input;
1002  cpl_msg_info (cpl_func, "This file %s is a raw argon wave file", filename);
1003 
1004 
1005  // output = cpl_sprintf("master_waveArgon.%s", filename);
1006  output = gravi_data_product_name (filename, "waveArgon");
1007 
1008  argon_data = gravi_data_load(input);
1009  primary_hdr = gravi_data_get_propertylist (reduced_wave,
1010  GRAVI_PRIMARY_HDR_NAME_EXT);
1011 
1012  start = clock();
1013  reduced_wave_argon = gravi_fit_argon (argon_data, reduced_wave,
1014  profile_map, darkArgon_map, bad_map); //gravi_data_duplicate(argon_data); ////gravi_extract_spectrum(raw_wave, profile_map, NULL);//gravi_compute_wave (raw_wave, profile_map);
1015  end = clock();
1016 
1017  gravi_data_delete (argon_data);
1018 
1019  cpl_frameset_join (waveArgon_frameset, cpl_frameset_duplicate (wave_frameset));
1020  applist = gravi_propertylist_get_qc (primary_hdr);
1021  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, WAVE);
1022 
1023  if (gravi_data_save(reduced_wave_argon, frameset, output, parlist,
1024  waveArgon_frameset, frame_, "gravi_all_wave", applist)
1025  != CPL_ERROR_NONE){
1026  cpl_free(output);
1027  gravi_data_delete(bad_map);
1028  gravi_data_delete(reduced_wave);
1029  gravi_data_delete(profile_map);
1030  gravi_data_delete(dark_map);
1031  gravi_data_delete(darkArgon_map);
1032  cpl_frameset_delete(waveRaw_frameset);
1033  cpl_frameset_delete(usedframes);
1034  cpl_propertylist_delete(applist);
1035  //cpl_free(shutter);
1036  return (int) cpl_error_set_message(cpl_func,
1037  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the argon wave caibration"
1038  " on the output file");
1039  }
1040  cpl_free(output);
1041  cpl_propertylist_delete(applist);
1042 
1043  gravi_data * waveCorrected = gravi_compute_wave_offset (reduced_wave_argon, reduced_wave);
1044  /*gravi_data_duplicate(reduced_wave_argon);*/
1045 
1046  // output = cpl_sprintf("waveCorrected.%s", filename);
1047  output = gravi_data_product_name (filename, "waveOffset");
1048  primary_hdr = gravi_data_get_propertylist (waveCorrected,
1049  GRAVI_PRIMARY_HDR_NAME_EXT);
1050  applist = gravi_propertylist_get_qc (primary_hdr);
1051  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, WAVE);
1052 
1053  if (gravi_data_save(waveCorrected, frameset, output, parlist,
1054  waveArgon_frameset, frame_, "gravi_all_wave", applist)
1055  != CPL_ERROR_NONE){
1056  cpl_free(output);
1057  gravi_data_delete(bad_map);
1058  gravi_data_delete(reduced_wave);
1059  gravi_data_delete(profile_map);
1060  gravi_data_delete(dark_map);
1061  gravi_data_delete(darkArgon_map);
1062  cpl_frameset_delete(waveRaw_frameset);
1063  cpl_frameset_delete(usedframes);
1064  cpl_propertylist_delete(applist);
1065  //cpl_free(shutter);
1066  return (int) cpl_error_set_message(cpl_func,
1067  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the wave corrected "
1068  "calibration on the output file");
1069  }
1070 
1071 
1072  cpl_free(output);
1073  gravi_data_delete(waveCorrected);
1074  gravi_data_delete(reduced_wave);
1075  gravi_data_delete(reduced_wave_argon);
1076 
1077  }
1078 
1079  /* Deallocation of all variables */
1080  gravi_data_delete(bad_map);
1081  gravi_data_delete(profile_map);
1082  gravi_data_delete(dark_map);
1083  gravi_data_delete(darkArgon_map);
1084  cpl_frameset_delete(waveRaw_frameset);
1085  cpl_frameset_delete(wave_frameset);
1086  cpl_frameset_delete(waveArgon_frameset);
1087 
1088 
1089  return (int)cpl_error_get_code();
1090 }
1091 
1092