GRAVI Pipeline Reference Manual  0.6.3
gravi_all_p2vm.c
1 /* $Id: gravi_all_p2vm.c,v 1.29 2009/02/10 09:16:12 llundin 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: llundin $
23  * $Date: 2009/02/10 09:16:12 $
24  * $Revision: 1.29 $
25  * $Name: $
26  */
27 
28 #ifdef HAVE_CONFIG_H
29 #include <config.h>
30 #endif
31 
32 /*-----------------------------------------------------------------------------
33  Includes
34  -----------------------------------------------------------------------------*/
35 
36 #include <cpl.h>
37 #include <stdio.h>
38 #include <string.h>
39 #include <time.h>
40 
41 #include "gravi_utils.h"
42 #include "gravi_pfits.h"
43 #include "gravi_dfs.h"
44 #include "gravi_calib.h"
45 
46 #include "gravi_data.h"
47 
48 
49 
50 /*-----------------------------------------------------------------------------
51  Private function prototypes
52  -----------------------------------------------------------------------------*/
53 
54 static int gravi_all_p2vm_create(cpl_plugin *);
55 static int gravi_all_p2vm_exec(cpl_plugin *);
56 static int gravi_all_p2vm_destroy(cpl_plugin *);
57 static int gravi_all_p2vm(cpl_frameset *, const cpl_parameterlist *);
58 
59 /*-----------------------------------------------------------------------------
60  Static variables
61  -----------------------------------------------------------------------------*/
62 
63 static char gravi_all_p2vm_description[] =
64 "This recipe is used to compute the p2vm matrix.\n"
65 "The given output FITS file contain a p2vm table with "
66 "the values of the transmission, phase and coherence extract "
67 "using the p2vm matrix \n"
68 "The description should include the required FITS-files and\n"
69 "their associated tags, e.g.\n"
70 "\n"
71 "Description DO category\n"
72 "Required input :\n"
73 "Raw p2vm files " GRAVI_P2VM "\n"
74 "Raw wave file (one file) " GRAVI_WAVE "\n"
75 "Raw dark file " GRAVI_DARK "\n"
76 "Or\n"
77 "Master dark " DARK "\n"
78 "Profile map " FLAT "\n"
79 "Bad pixel map " BAD "\n"
80 "Master wave (one file) " WAVE "\n"
81 "Ouput :\n"
82 "Master wave (one file) " WAVE "\n"
83 "Profile map (if there is raw flat files in the input) " FLAT "\n"
84 "Master dark (if there is raw dark file in the input) " DARK "\n"
85 "Bad pixel map (if there is not bad pixel map in the input) " BAD "\n"
86 "P2vm map " P2VM "\n"
87 "\n"
88 "Additionally, it should describe functionality of the expected output."
89 "\n";
90 
91 /*-----------------------------------------------------------------------------
92  Function code
93  -----------------------------------------------------------------------------*/
94 
95 /*----------------------------------------------------------------------------*/
105 /*----------------------------------------------------------------------------*/
106 int cpl_plugin_get_info(cpl_pluginlist * list)
107 {
108  cpl_recipe * recipe = cpl_calloc(1, sizeof *recipe );
109  cpl_plugin * plugin = &recipe->interface;
110 
111  if (cpl_plugin_init(plugin,
112  CPL_PLUGIN_API,
113  GRAVI_BINARY_VERSION,
114  CPL_PLUGIN_TYPE_RECIPE,
115  "gravi_all_p2vm",
116  "This recipe is used to compute p2vm matrix",
117  gravi_all_p2vm_description,
118  "Firstname Lastname",
119  PACKAGE_BUGREPORT,
120  gravi_get_license(),
121  gravi_all_p2vm_create,
122  gravi_all_p2vm_exec,
123  gravi_all_p2vm_destroy)) {
124  cpl_msg_error(cpl_func, "Plugin initialization failed");
125  (void)cpl_error_set_where(cpl_func);
126  return 1;
127  }
128 
129  if (cpl_pluginlist_append(list, plugin)) {
130  cpl_msg_error(cpl_func, "Error adding plugin to list");
131  (void)cpl_error_set_where(cpl_func);
132  return 1;
133  }
134 
135  return 0;
136 }
137 
138 /*----------------------------------------------------------------------------*/
146 /*----------------------------------------------------------------------------*/
147 static int gravi_all_p2vm_create(cpl_plugin * plugin)
148 {
149  cpl_recipe * recipe;
150  cpl_parameter * p;
151 
152  /* Do not create the recipe if an error code is already set */
153  if (cpl_error_get_code() != CPL_ERROR_NONE) {
154  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
155  cpl_func, __LINE__, cpl_error_get_where());
156  return (int)cpl_error_get_code();
157  }
158 
159  if (plugin == NULL) {
160  cpl_msg_error(cpl_func, "Null plugin");
161  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
162  }
163 
164  /* Verify plugin type */
165  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
166  cpl_msg_error(cpl_func, "Plugin is not a recipe");
167  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
168  }
169 
170  /* Get the recipe */
171  recipe = (cpl_recipe *)plugin;
172 
173  /* Create the parameters list in the cpl_recipe object */
174  recipe->parameters = cpl_parameterlist_new();
175  if (recipe->parameters == NULL) {
176  cpl_msg_error(cpl_func, "Parameter list allocation failed");
177  cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
178  }
179 
180  /* Fill the parameters list */
181 
182  /* --Save the preproc files */
183  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.preproc_file",
184  CPL_TYPE_BOOL, "Save the preproc file", "gravi.gravi_all_p2vm", FALSE);
185  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "preprocfile");
186  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
187  cpl_parameterlist_append(recipe->parameters, p);
188 
189  /* --Extract the real opd from the metrology */
190  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.opd_met",
191  CPL_TYPE_BOOL, "extract the real opd from the metrology",
192  "gravi.gravi_all_p2vm", TRUE);
193  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "extmetrology");
194  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
195  cpl_parameterlist_append(recipe->parameters, p);
196 
197  /* --the minimum wavelength */
198  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.min_wave",
199  CPL_TYPE_DOUBLE, "the minimum wavelength", "gravi.gravi_all_p2vm", 2.0);
200  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdamin");
201  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
202  cpl_parameterlist_append(recipe->parameters, p);
203 
204  /* --the maximum wavelength */
205  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.max_wave",
206  CPL_TYPE_DOUBLE, "the maximum wavelength", "gravi.gravi_all_p2vm", 2.6);
207  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdamax");
208  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
209  cpl_parameterlist_append(recipe->parameters, p);
210 
211  /* --the sigma readout SC */
212  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.readoutSC",
213  CPL_TYPE_DOUBLE, "the readout error sigma SC", "gravi.gravi_all_p2vm", 1.0);
214  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_readout_SC");
215  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
216  cpl_parameterlist_append(recipe->parameters, p);
217 
218  /* --the sigma readout FT */
219  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.readoutFT",
220  CPL_TYPE_DOUBLE, "the readout error sigma FT", "gravi.gravi_all_p2vm", 1.0);
221  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sigma_readout_FT");
222  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
223  cpl_parameterlist_append(recipe->parameters, p);
224 
225  /* --the number of the spectral element to compute for FT data */
226  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.nspectrum_FT",
227  CPL_TYPE_INT, "the number of the spectral in the FT data", "gravi.gravi_all_p2vm", 5);
228  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "nlambda_ft");
229  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
230  cpl_parameterlist_append(recipe->parameters, p);
231 
232  /* --the number of the spectral element to compute for SC data */
233  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.nspectrum_SC",
234  CPL_TYPE_INT, "the number of the spectral in the SC data", "gravi.gravi_all_p2vm", 5);
235  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "nlambda_sc");
236  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
237  cpl_parameterlist_append(recipe->parameters, p);
238 
239  /* --the width of the profile element */
240  p = cpl_parameter_new_value("gravi.gravi_all_flat."
241  "profile_width", CPL_TYPE_INT, "profile width option",
242  "gravi.gravi_all_flat", 5);
243  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "profile_width");
244  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
245  cpl_parameterlist_append(recipe->parameters, p);
246 
247  /* --the background correction */
248  p = cpl_parameter_new_value("gravi.gravi_all_p2vm.preproc_param.correction",
249  CPL_TYPE_STRING, "the background correction", "gravi.gravi_all_p2vm", "DARK");
250  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "background");
251  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
252  cpl_parameterlist_append(recipe->parameters, p);
253 
254  p = cpl_parameter_new_value("gravi."
255  "flat_param.Bad_dark_threshold", CPL_TYPE_INT, "the rms factor for "
256  "dark bad pixel threshold", "gravi.gravi_all_flat", 5);
257  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "Bad_dark_threshold");
258  cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV);
259  cpl_parameterlist_append(recipe->parameters, p);
260 
261  return 0;
262 }
263 
264 /*----------------------------------------------------------------------------*/
270 /*----------------------------------------------------------------------------*/
271 static int gravi_all_p2vm_exec(cpl_plugin * plugin)
272 {
273 
274  cpl_recipe * recipe;
275  int recipe_status;
276  cpl_errorstate initial_errorstate = cpl_errorstate_get();
277 
278  /* Return immediately if an error code is already set */
279  if (cpl_error_get_code() != CPL_ERROR_NONE) {
280  cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
281  cpl_func, __LINE__, cpl_error_get_where());
282  return (int)cpl_error_get_code();
283  }
284 
285  if (plugin == NULL) {
286  cpl_msg_error(cpl_func, "Null plugin");
287  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
288  }
289 
290  /* Verify plugin type */
291  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
292  cpl_msg_error(cpl_func, "Plugin is not a recipe");
293  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
294  }
295 
296  /* Get the recipe */
297  recipe = (cpl_recipe *)plugin;
298 
299  /* Verify parameter and frame lists */
300  if (recipe->parameters == NULL) {
301  cpl_msg_error(cpl_func, "Recipe invoked with NULL parameter list");
302  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
303  }
304  if (recipe->frames == NULL) {
305  cpl_msg_error(cpl_func, "Recipe invoked with NULL frame set");
306  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
307  }
308 
309  /* Invoke the recipe */
310  recipe_status = gravi_all_p2vm(recipe->frames, recipe->parameters);
311 
312  /* Ensure DFS-compliance of the products */
313  if (cpl_dfs_update_product_header(recipe->frames)) {
314  if (!recipe_status) recipe_status = (int)cpl_error_get_code();
315  }
316 
317  if (!cpl_errorstate_is_equal(initial_errorstate)) {
318  /* Dump the error history since recipe execution start.
319  At this point the recipe cannot recover from the error */
320  cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
321  }
322 
323  return recipe_status;
324 }
325 
326 /*----------------------------------------------------------------------------*/
332 /*----------------------------------------------------------------------------*/
333 static int gravi_all_p2vm_destroy(cpl_plugin * plugin)
334 {
335  cpl_recipe * recipe;
336 
337  if (plugin == NULL) {
338  cpl_msg_error(cpl_func, "Null plugin");
339  cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
340  }
341 
342  /* Verify plugin type */
343  if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
344  cpl_msg_error(cpl_func, "Plugin is not a recipe");
345  cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
346  }
347 
348  /* Get the recipe */
349  recipe = (cpl_recipe *)plugin;
350 
351  cpl_parameterlist_delete(recipe->parameters);
352 
353  return 0;
354 }
355 
356 
357 /*----------------------------------------------------------------------------*/
364 /*----------------------------------------------------------------------------*/
365 static int gravi_all_p2vm(cpl_frameset * frameset,
366  const cpl_parameterlist * parlist)
367 {
368  cpl_frameset * p2vm_frameset, * wavecalib_frameset, * darkcalib_frameset,
369  * gaincalib_frameset, * dark_frameset, * wave_frameset,
370  * badpix_frameset, * gain_frameset, * preproc_frameset, *norma_frameset;
371  cpl_propertylist * applist, * primary_hdr, * primary_hdr_dark, * p2vm_plist,
372  * primary_hdr_wave, * bad_primary_hdr, * profile_primary_hdr, * plist;
373  cpl_frame * frame;
374  const cpl_parameter * p;
375  char * out_dark, * out_wave, * preproc_name, * out_gain;
376  const char * filename, * origin, * acq_start;/*, * insname;*/
377  gravi_data * p2vm_data, * data, * dark_map, * wave_map,
378  * profile_map, * badpix_map;
379  gravi_data ** calib_datas;
380  gravi_data * preproc_data;
381  gravi_data ** raw_data;
382  dark_map = NULL, wave_map = NULL;
383  int nb_frame, i, nb_frame_gain, j;
384  int rest;
385  double gain_ft, gain_sc, mjd_obs, acq_mjd;
386  int * shutter;
387  cpl_table * p2vm_met = NULL, * metrology_table, * opl_table = NULL, * detector_table,
388  *p2vm_table;
389  cpl_propertylist * met_plist;
390  cpl_frameset * preproc_frame;
391  int ** valid_trans = cpl_malloc (2 * sizeof (int*));
392 // valid_trans[0][4] = {0, 0, 0, 0};
393 // valid_trans[1][4] = {0, 0, 0, 0};
394  int ** valid_CP = cpl_malloc (2 * sizeof (int*)), type_data;
395  int n_tel = 4, n_wave, n_region;
396  cpl_propertylist * oiwave_plist;
397  int met_check = 1, def_p2vm = 1;
398  cpl_propertylist * p2vm_primary_hdr;
399  clock_t start, end;
400 
401  for (i = 0 ; i < 2; i++){
402  valid_trans[i] = cpl_calloc (4, sizeof (int));
403  valid_CP[i] = cpl_calloc (6, sizeof (int));
404  }
405 // valid_CP[0][6] = {0, 0, 0, 0, 0, 0};
406 // valid_CP[1][6] = {0, 0, 0, 0, 0, 0};
407 
408 // double dit, darkmean, minwave, maxwave, darkrms;
409 
410  /* Identify the RAW and CALIB frames in the input frameset */
411 
412  cpl_ensure_code(gravi_dfs_set_groups(frameset) == CPL_ERROR_NONE,
413  cpl_error_get_code()) ;
414 
415  norma_frameset = gravi_frameset_extract_norma(frameset);
416 
417  if (cpl_frameset_is_empty(norma_frameset)) {
418 
419  preproc_frameset = gravi_frameset_extract_preproc(frameset);
420 
421  if (cpl_frameset_is_empty(preproc_frameset)) {
422  /* - Extract a set of frame p2vm and set of frame dark wave */
423  p2vm_frameset = gravi_frameset_extract_p2vm_data(frameset);
424  wavecalib_frameset = gravi_frameset_extract_wave_file(frameset);
425  darkcalib_frameset = gravi_frameset_extract_dark_file(frameset);
426  gaincalib_frameset = gravi_frameset_extract_flat_file(frameset);
427  wave_frameset = gravi_frameset_extract_wave(frameset);
428  dark_frameset = gravi_frameset_extract_dark(frameset);
429  gain_frameset = gravi_frameset_extract_flat(frameset);
430  badpix_frameset = gravi_frameset_extract_badpix(frameset);
431  if (cpl_frameset_is_empty(p2vm_frameset)) {
432  /* To use this recipe the frameset must contain at least
433  * one p2vm frame. */
434  cpl_frameset_delete(dark_frameset);
435  cpl_frameset_delete(wave_frameset);
436  cpl_frameset_delete(gain_frameset);
437  cpl_frameset_delete(p2vm_frameset);
438  cpl_frameset_delete(wavecalib_frameset);
439  cpl_frameset_delete(wavecalib_frameset);
440  cpl_frameset_delete(gaincalib_frameset);
441  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
442  "No p2vm frame on the frameset") ;
443  }
444 
445  /* Identify and extract the dark and wave fits files */
446  /* Check and get the dark frame */
447 
448  if (!cpl_frameset_is_empty(dark_frameset)) {
449  frame = cpl_frameset_get_position(dark_frameset, 0);
450 
451  filename = cpl_frame_get_filename(frame);
452  cpl_msg_info (NULL, "This file %s is a dark file", filename);
453  data = gravi_data_load(filename);
454  primary_hdr = gravi_data_get_propertylist(data,
455  GRAVI_PRIMARY_HDR_NAME_EXT);
456  shutter = gravi_shutters_check(primary_hdr);
457  if (!((shutter[0] == 0) && (shutter[1] == 0) && (shutter[2] == 0)
458  && (shutter[3] == 0))){
459  cpl_frameset_delete(dark_frameset);
460  cpl_frameset_delete(wave_frameset);
461  cpl_frameset_delete(gain_frameset);
462  cpl_frameset_delete(darkcalib_frameset);
463  cpl_frameset_delete(wavecalib_frameset);
464  cpl_frameset_delete(gaincalib_frameset);
465  cpl_frameset_delete(p2vm_frameset);
466  gravi_data_delete(data);
467  return (int)cpl_error_set_message(cpl_func,
468  CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem");
469  }
470  /* The dark file must contains all the shutter close */
471 
472  dark_map = gravi_compute_dark(data);
473  if (cpl_error_get_code()) {
474  cpl_frameset_delete(dark_frameset);
475  cpl_frameset_delete(wave_frameset);
476  cpl_frameset_delete(gain_frameset);
477  cpl_frameset_delete(darkcalib_frameset);
478  cpl_frameset_delete(wavecalib_frameset);
479  cpl_frameset_delete(gaincalib_frameset);
480  gravi_data_delete(dark_map);
481  cpl_frameset_delete(p2vm_frameset);
482  cpl_propertylist_delete(applist);
483  gravi_data_delete(data);
484  return (int)cpl_error_set_message(cpl_func,
485  CPL_ERROR_ILLEGAL_OUTPUT,
486  "Error while computing the dark_map");
487  }
488 
489  /* Save the dark map */
490  cpl_frameset_insert(darkcalib_frameset, cpl_frame_duplicate(frame));
491  primary_hdr_dark = gravi_data_get_propertylist(dark_map,
492  GRAVI_PRIMARY_HDR_NAME_EXT);
493  applist = gravi_propertylist_get_qc (primary_hdr_dark);
494 // dit = gravi_pfits_get_dit(primary_hdr_dark);
495  //insname = gravi_pfits_get_insname(primary_hdr_dark);
496 
497  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
498  DARK);
499 
500 // cpl_propertylist_append_double(applist, GRAVI_DET_DIT, dit);
501  //cpl_propertylist_append_string(applist, "INSNAME", insname);
502 
503  out_dark = "gravi_final_dark.fits";
504 
505  if (gravi_data_save(dark_map, frameset, out_dark, parlist,
506  darkcalib_frameset, frame, "gravi_all_p2vm", applist)
507  != CPL_ERROR_NONE){
508  cpl_frameset_delete(dark_frameset);
509  cpl_frameset_delete(wave_frameset);
510  cpl_frameset_delete(gain_frameset);
511  cpl_frameset_delete(darkcalib_frameset);
512  cpl_frameset_delete(wavecalib_frameset);
513  cpl_frameset_delete(gaincalib_frameset);
514  gravi_data_delete(dark_map);
515  cpl_frameset_delete(p2vm_frameset);
516  cpl_propertylist_delete(applist);
517  gravi_data_delete(data);
518 
519  return (int) cpl_error_set_message(cpl_func,
520  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the dark_map"
521  " on the output file");
522  }
523  cpl_propertylist_delete(applist);
524  gravi_data_delete(data);
525  cpl_free(shutter);
526 
527  }
528  else if (!cpl_frameset_is_empty(darkcalib_frameset)){
529  frame = cpl_frameset_get_position(darkcalib_frameset, 0);
530  cpl_frameset_insert (dark_frameset, cpl_frame_duplicate (frame));
531  filename = cpl_frame_get_filename(frame);
532 
533  cpl_msg_info (NULL, "This file %s is a dark file already "
534  "computed", filename);
535  dark_map = gravi_data_load(filename);
536 
537  }
538 
539  /* Check that the dark_map in the input frameset */
540  else {
541  cpl_frameset_delete(dark_frameset);
542  cpl_frameset_delete(wave_frameset);
543  cpl_frameset_delete(gain_frameset);
544  cpl_frameset_delete(p2vm_frameset);
545  cpl_frameset_delete(darkcalib_frameset);
546  cpl_frameset_delete(wavecalib_frameset);
547  cpl_frameset_delete(gaincalib_frameset);
548  gravi_data_delete(dark_map);
549  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
550  "No dark frames in the frameset");
551  }
552 
553 
554 
555  /* Compute the bad pixel map */
556  if (!cpl_frameset_is_empty(badpix_frameset)){
557  frame = cpl_frameset_get_position(badpix_frameset, 0);
558  filename = cpl_frame_get_filename(frame);
559  cpl_msg_info (NULL, "This file %s is a bad pixel map", filename);
560 
561  badpix_map = gravi_data_load(filename);
562  }
563  else {
564 
565  badpix_map = gravi_compute_badpix(dark_map, parlist);
566 
567  if (cpl_error_get_code()) {
568  gravi_data_delete(badpix_map);
569  cpl_frameset_delete(dark_frameset);
570  cpl_frameset_delete(wave_frameset);
571  cpl_frameset_delete(gain_frameset);
572  cpl_frameset_delete(p2vm_frameset);
573  cpl_frameset_delete(darkcalib_frameset);
574  cpl_frameset_delete(wavecalib_frameset);
575  cpl_frameset_delete(gaincalib_frameset);
576  gravi_data_delete(dark_map);
577  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
578  "Error while computing the bad pixel map");
579 
580  }
581  /* Save the pad pixel map */
582  bad_primary_hdr = gravi_data_get_propertylist (badpix_map,
583  GRAVI_PRIMARY_HDR_NAME_EXT);
584  applist = gravi_propertylist_get_qc (bad_primary_hdr);
585 
586  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, BAD);
587 
588  frame = cpl_frameset_get_position (dark_frameset, 0);
589 
590  if (gravi_data_save (badpix_map, frameset, "gravi_bad_map.fits", parlist,
591  dark_frameset, frame, "gravi_all_flat", applist)
592  != CPL_ERROR_NONE){
593 
594  gravi_data_delete(badpix_map);
595  cpl_frameset_delete(dark_frameset);
596  cpl_frameset_delete(wave_frameset);
597  cpl_frameset_delete(gain_frameset);
598  cpl_frameset_delete(p2vm_frameset);
599  cpl_frameset_delete(darkcalib_frameset);
600  cpl_frameset_delete(wavecalib_frameset);
601  cpl_frameset_delete(gaincalib_frameset);
602  cpl_frameset_delete(badpix_frameset);
603  gravi_data_delete(dark_map);
604  return (int) cpl_error_set_message(cpl_func,
605  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the bad pixel map");
606  }
607  cpl_propertylist_delete (applist);
608  }
609 
610 
611  cpl_frameset_delete(darkcalib_frameset);
612  cpl_frameset_delete(dark_frameset);
613  cpl_frameset_delete(badpix_frameset);
614 
615  /* Check that the gain map in the input frameset */
616  if (cpl_error_get_code()){
617  cpl_frameset_delete(p2vm_frameset);
618  cpl_frameset_delete(wavecalib_frameset);
619  cpl_frameset_delete(wave_frameset);
620  cpl_frameset_delete(gain_frameset);
621  gravi_data_delete(badpix_map);
622  gravi_data_delete(dark_map);
623  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
624  "Compute of the gain failed");
625  }
626 
627  if ((!cpl_frameset_is_empty(gain_frameset)) &&
628  (cpl_frameset_is_empty(gaincalib_frameset)) ) {
629  /* Identify the flat file */
630  nb_frame_gain = cpl_frameset_get_size (gain_frameset);//nb_frame;
631  raw_data = cpl_malloc(nb_frame_gain * sizeof(gravi_data *));
632 
633 
634 
635  for (i = 0; i < nb_frame_gain; i++){
636  frame = cpl_frameset_get_position(gain_frameset, i);
637  filename = cpl_frame_get_filename(frame);
638  raw_data[i] = gravi_data_load(filename);
639  primary_hdr = gravi_data_get_propertylist(raw_data[i],
640  GRAVI_PRIMARY_HDR_NAME_EXT);
641  shutter = gravi_shutters_check(primary_hdr);
642  cpl_free(shutter);
643 
644  //frame = cpl_frameset_get_next(gain_frameset);
645  }
646 
647 
648  /* Compute the profile */
649  profile_map = gravi_compute_profile(raw_data, dark_map, badpix_map,
650  nb_frame_gain, parlist);
651 
652  if (cpl_error_get_code()){
653  cpl_frameset_delete(p2vm_frameset);
654  cpl_frameset_delete(wavecalib_frameset);
655  cpl_frameset_delete(wave_frameset);
656  cpl_frameset_delete(gain_frameset);
657  gravi_data_delete(profile_map);
658  gravi_data_delete(dark_map);
659  for (i = 0; i < nb_frame_gain; i++){
660  gravi_data_delete(raw_data[i]);
661  }
662  cpl_free(raw_data);
663  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
664  "Compute of the profile map failed");
665  }
666  /* Compute the gain and extract the gain map*/
667  gain_sc = gravi_compute_gain(raw_data, nb_frame_gain, dark_map,
668  GRAVI_IMAGING_DATA_SC_EXT);
669  gain_ft = gravi_compute_gain(raw_data, nb_frame_gain, dark_map,
670  GRAVI_IMAGING_DATA_FT_EXT);
671 
672  profile_primary_hdr = gravi_data_get_propertylist(profile_map,
673  GRAVI_PRIMARY_HDR_NAME_EXT);
674  /* Save the profile map */
675  applist = gravi_propertylist_get_qc (profile_primary_hdr);
676  cpl_propertylist_append_double (applist, QC_MEANGAIN_FT, gain_ft);
677  cpl_propertylist_append_double (applist, QC_MEANGAIN_SC, gain_sc);
678 
679  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, FLAT);
680 
681  out_gain = "gravi_final_profile.fits";
682  frame = cpl_frameset_get_position(gain_frameset, 0);
683  if (gravi_data_save(profile_map, frameset, out_gain, parlist,
684  gain_frameset, frame, "gravi_all_p2vm", applist)
685  != CPL_ERROR_NONE){
686 
687  cpl_frameset_delete(wavecalib_frameset);
688  cpl_frameset_delete(gaincalib_frameset);
689  cpl_frameset_delete(wave_frameset);
690  cpl_frameset_delete(gain_frameset);
691  for (i = 0; i < nb_frame_gain; i++){
692  gravi_data_delete(raw_data[i]);
693  }
694  cpl_free(raw_data);
695  gravi_data_delete(dark_map);
696  gravi_data_delete(profile_map);
697  cpl_frameset_delete(p2vm_frameset);
698  cpl_propertylist_delete(applist);
699 
700  return (int) cpl_error_set_message(cpl_func,
701  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the profile_map"
702  " on the output file");
703  }
704  cpl_propertylist_delete(applist);
705 
706  for (i = 0; i < nb_frame_gain; i++){
707  gravi_data_delete(raw_data[i]);
708  }
709  cpl_free(raw_data);
710  }
711 
712  else {
713 
714  frame = cpl_frameset_get_position (gaincalib_frameset, 0);
715 
716  filename = cpl_frame_get_filename(frame);
717  cpl_msg_info (NULL, "This file %s is a flat file already "
718  "computed", filename);
719  profile_map = gravi_data_load(filename);
720 
721  }
722 
723  cpl_frameset_delete(gaincalib_frameset);
724  cpl_frameset_delete(gain_frameset);
725 
726 
727  /* Check and get the wave frame */
728 
729 
730  p = cpl_parameterlist_find_const(parlist, "gravi.gravi_all_p2vm."
731  "opd_met");
732  if ((!cpl_frameset_is_empty(wave_frameset)) &&
733  (cpl_frameset_is_empty(wavecalib_frameset))) {
734  frame = cpl_frameset_get_position(wave_frameset, 0);
735 
736  filename = cpl_frame_get_filename(frame);
737  cpl_msg_info (NULL, "This file %s is a wave file", filename);
738  data = gravi_data_load(filename);
739  primary_hdr = gravi_data_get_propertylist(data,
740  GRAVI_PRIMARY_HDR_NAME_EXT);
741  shutter = gravi_shutters_check(primary_hdr);
742  if (!((shutter[0] == 1) && (shutter[1] == 1) && (shutter[2] == 1)
743  && (shutter[3] == 1))){
744  cpl_frameset_delete(wavecalib_frameset);
745  cpl_frameset_delete(wave_frameset);
746  gravi_data_delete(dark_map);
747  cpl_frameset_delete(p2vm_frameset);
748  gravi_data_delete(data);
749  gravi_data_delete(profile_map);
750  return (int)cpl_error_set_message(cpl_func,
751  CPL_ERROR_ILLEGAL_OUTPUT, "Shutter problem");
752  }
753 
754 
755  /* Compute the p2vm of the metrology */
756 
757  if ((cpl_parameter_get_bool (p)) && (met_check)){
758 // int rest;
759 // if ((cpl_table_get_nrow(metrology_table)%4) != 0)
760 // rest = 4 + (cpl_table_get_nrow(metrology_table)%4) ;
761 // else
762 // rest = 4;
763  metrology_table = gravi_data_get_table(data,
764  GRAVI_METROLOGY_EXT);
765  met_plist = cpl_propertylist_duplicate (gravi_data_get_propertylist(data,
766  GRAVI_METROLOGY_EXT));
767  //mjd_obs = gravi_pfits_get_mjd (primary_hdr);
768  acq_start = gravi_pfits_get_acq_start (primary_hdr);
769 
770  acq_mjd = gravi_convert_to_mjd (acq_start);
771 
772  opl_table = cpl_table_new (cpl_table_get_nrow(metrology_table));
773  start = clock();
774  p2vm_met = gravi_metrology_calibration (metrology_table,
775  opl_table, 0);
776  end = clock();
777  printf ("Temps gravi_metrology_calibration : %f\n", (end - start) / (double)CLOCKS_PER_SEC);
778  if (cpl_error_get_code()) {
779 
780  gravi_data_delete(badpix_map);
781  cpl_frameset_delete(wavecalib_frameset);
782  cpl_frameset_delete(wave_frameset);
783  gravi_data_delete(dark_map);
784  gravi_data_delete(wave_map);
785  cpl_frameset_delete(p2vm_frameset);
786  gravi_data_delete(data);
787  gravi_data_delete(profile_map);
788  cpl_propertylist_delete (met_plist);
789  cpl_table_delete(p2vm_met);
790  cpl_table_delete(opl_table);
791  cpl_free(shutter);
792  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
793  "Error while computing p2vm of the metrology");
794  }
795  met_check = 0;
796 
797  }
798  /* The wave file must contains all the shutters open */
799  wave_map = gravi_compute_wave(data, profile_map, dark_map, badpix_map,
800  opl_table, parlist);
801 
802  cpl_table_delete (opl_table);
803 
804  if (cpl_error_get_code()) {
805  cpl_frameset_delete(wavecalib_frameset);
806  cpl_frameset_delete(wave_frameset);
807  gravi_data_delete(dark_map);
808  gravi_data_delete(wave_map);
809  cpl_frameset_delete(p2vm_frameset);
810  gravi_data_delete(data);
811  gravi_data_delete(profile_map);
812  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
813  "Error while computing the wave_map");
814  }
815  /* Save the wave map */
816 
817  primary_hdr_wave = gravi_data_get_propertylist(wave_map,
818  GRAVI_PRIMARY_HDR_NAME_EXT);
819  applist = gravi_propertylist_get_qc (primary_hdr_wave);
820 // dit = gravi_pfits_get_dit(primary_hdr_wave);
821  //insname = gravi_pfits_get_insname(primary_hdr_wave);
822 
823  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG,
824  WAVE);
825 
826 // cpl_propertylist_append_double(applist, GRAVI_DET_DIT, dit);
827  //cpl_propertylist_append_string(applist, "INSNAME", insname);
828 
829  out_wave = "gravi_final_wave.fits";
830  if (gravi_data_save(wave_map, frameset, out_wave, parlist,
831  wave_frameset, frame, "gravi_all_p2vm", applist)
832  != CPL_ERROR_NONE){
833 
834  cpl_frameset_delete(wavecalib_frameset);
835  cpl_frameset_delete(wave_frameset);
836  gravi_data_delete(dark_map);
837  gravi_data_delete(wave_map);
838  cpl_frameset_delete(p2vm_frameset);
839  cpl_propertylist_delete(applist);
840  gravi_data_delete(data);
841  gravi_data_delete(profile_map);
842  return (int) cpl_error_set_message(cpl_func,
843  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the wave_map"
844  " on the output file");
845  }
846 
847  cpl_propertylist_delete(applist);
848 
849  gravi_data_delete(data);
850  cpl_free(shutter);
851 
852  }
853  else {
854 
855  frame = cpl_frameset_get_position(wavecalib_frameset, 0);
856 
857  filename = cpl_frame_get_filename(frame);
858 
859  cpl_msg_info (NULL, "This file %s is a wave file already "
860  "computed", filename);
861  wave_map = gravi_data_load(filename);
862 
863  }
864 
865 
866  /* Check that wave_map exist in the input frameset */
867  if (wave_map == NULL){
868  cpl_frameset_delete(p2vm_frameset);
869  cpl_frameset_delete(wavecalib_frameset);
870  cpl_frameset_delete(wave_frameset);
871  gravi_data_delete(wave_map);
872  gravi_data_delete(profile_map);
873  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_INVALID_TYPE,
874  "No wave frames in the frameset");
875  }
876 
877  if ((gravi_data_has_extension (wave_map, GRAVI_P2VM_MET_EXT)) && (met_check)){
878  met_plist = cpl_propertylist_duplicate (
879  gravi_data_get_propertylist (wave_map, GRAVI_P2VM_MET_EXT));
880  p2vm_met = cpl_table_duplicate (
881  gravi_data_get_table (wave_map, GRAVI_P2VM_MET_EXT));
882  met_check = 0;
883  }
884 
885  cpl_frameset_delete(wavecalib_frameset);
886  cpl_frameset_delete(wave_frameset);
887 
888  calib_datas = cpl_malloc(4 * sizeof(gravi_data *));
889  calib_datas[0] = dark_map;
890  calib_datas[1] = wave_map;
891  calib_datas[2] = profile_map;
892  calib_datas[3] = badpix_map;
893 
894  /* Get the number of the p2vm frame contained in the frameset */
895  nb_frame = cpl_frameset_get_size(p2vm_frameset);
896 
897  p = cpl_parameterlist_find_const(parlist, "gravi.gravi_all_p2vm."
898  "preproc_param.preproc_file");
899 
900  for (i = 0; i < nb_frame; i++){
901  frame = cpl_frameset_get_position(p2vm_frameset, i);
902  filename = cpl_frame_get_filename(frame);
903  cpl_msg_info (NULL, "Calibration of this file %s", filename);
904  data = gravi_data_load(filename);
905  primary_hdr = gravi_data_get_propertylist(data,
906  GRAVI_PRIMARY_HDR_NAME_EXT);
907  origin = gravi_pfits_get_origin (primary_hdr);
908  shutter = gravi_shutters_check(primary_hdr);
909  if ((shutter[0] == 1) && (shutter[1] == 1) && (shutter[2] == 1)
910  && (shutter[3] == 1) && (met_check)){
911 
912  /* Compute the p2vm of the metrology */
913  cpl_msg_info (NULL, "Compute the p2vm of the metrology %s", filename);
914  metrology_table = gravi_data_get_table(data,
915  GRAVI_METROLOGY_EXT);
916 
917  if ((p2vm_met == NULL)/* && (cpl_parameter_get_bool (p))*/){
918 
919  met_plist = cpl_propertylist_duplicate (gravi_data_get_propertylist(data,
920  GRAVI_METROLOGY_EXT));
921  //mjd_obs = gravi_pfits_get_mjd (primary_hdr);
922  acq_start = gravi_pfits_get_acq_start (primary_hdr);
923 
924  acq_mjd = gravi_convert_to_mjd (acq_start);
925 
926  opl_table = cpl_table_new (cpl_table_get_nrow(metrology_table));
927  start = clock();
928  p2vm_met = gravi_metrology_calibration (metrology_table,
929  opl_table, 0);
930  end = clock();
931  printf ("Temps gravi_metrology_calibration : %f\n", (end - start) / (double)CLOCKS_PER_SEC);
932  if (cpl_error_get_code()) {
933  cpl_frameset_delete(p2vm_frameset);
934  cpl_free(calib_datas);
935  gravi_data_delete(dark_map);
936  gravi_data_delete(wave_map);
937  gravi_data_delete(profile_map);
938  gravi_data_delete(data);
939  cpl_table_delete (opl_table);
940  cpl_table_delete (p2vm_met);
941  cpl_free(shutter);
942  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
943  "Error while computing p2vm of the metrology");
944  }
945  met_check = 0;
946 
947  }
948 
949  cpl_free (shutter);
950  gravi_data_delete (data);
951  continue;
952  }
953 
954  cpl_free (shutter);
955 
956  start = clock();
957  preproc_data = gravi_preproc(data, calib_datas, 4, parlist);
958  end = clock();
959  cpl_msg_info (NULL, "Temps gravi_preproc %s : %f", filename, (end - start) / (double)CLOCKS_PER_SEC);
960  gravi_data_delete(data);
961  if (cpl_error_get_code()) {
962  cpl_frameset_delete(p2vm_frameset);
963  gravi_data_delete(preproc_data);
964  cpl_free(calib_datas);
965  gravi_data_delete(dark_map);
966  gravi_data_delete(wave_map);
967  gravi_data_delete(profile_map);
968  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
969  "Error while computing the preproc data_map");
970  }
971 
972  /* Construction of the p2vm data */
973 
974  if (def_p2vm){
975  cpl_msg_info (NULL, "Construction of the p2vm map");
976  p2vm_data = gravi_data_new(0);
977  p2vm_primary_hdr = cpl_propertylist_new ();
978 
979  for (j = 0; j < gravi_data_get_size (preproc_data); j++){
980  plist = gravi_data_get_propertylist_x (preproc_data, j);
981  const char * plist_name = gravi_pfits_get_extname (plist);
982  if (plist_name == NULL)
983  continue;
984  /* Get the type of the extention */
985  type_data = gravi_pfits_get_extension_type (plist);
986 
987  if (!(strcmp (plist_name, INS_DESCRIPTION) &&
988  strcmp (plist_name, INS_TRAIN) &&
989  strcmp (plist_name, GRAVI_IMAGING_DETECTOR_FT_EXT) &&
990  strcmp (plist_name, GRAVI_IMAGING_DETECTOR_SC_EXT) &&
991  strcmp (plist_name, GRAVI_IO_WAVELENGTH_FT_EXT) &&
992  strcmp (plist_name, GRAVI_IO_WAVELENGTH_SC_EXT))){
993  if (type_data == 2)
994  gravi_data_add (p2vm_data, plist,
995  gravi_data_get_table (preproc_data, plist_name));
996  else if (type_data == 3)
997  gravi_data_add_cube (p2vm_data, plist,
998  gravi_data_get_cube (preproc_data, plist_name));
999  }
1000  }
1001  detector_table = gravi_data_get_table (preproc_data,
1002  GRAVI_IMAGING_DETECTOR_SC_EXT);
1003  oiwave_plist = gravi_data_get_propertylist
1004  (preproc_data, GRAVI_IO_WAVELENGTH_SC_EXT);
1005 
1006 
1007  n_wave = gravi_pfits_get_nwave(oiwave_plist);
1008  n_region = cpl_table_get_nrow(detector_table);
1009 
1010  p2vm_table = gravi_p2vm_new(n_region, n_wave, n_tel);
1011  plist = cpl_propertylist_new();
1012 
1013  cpl_propertylist_append_string(plist, "ORIGIN", origin);
1014  cpl_propertylist_append_int(plist, "NREGION", n_region);
1015  cpl_propertylist_append_int(plist, "NWAVE", n_wave);
1016  cpl_propertylist_append_string(plist, "EXTNAME", GRAVI_P2VM_DATA_SC_EXT);
1017 
1018  gravi_data_add (p2vm_data, plist, p2vm_table);
1019  cpl_table_delete (p2vm_table);
1020 
1021  detector_table = gravi_data_get_table (preproc_data,
1022  GRAVI_IMAGING_DETECTOR_FT_EXT);
1023  oiwave_plist = gravi_data_get_propertylist
1024  (preproc_data, GRAVI_IO_WAVELENGTH_FT_EXT);
1025 
1026 
1027  n_wave = gravi_pfits_get_nwave(oiwave_plist);
1028  n_region = cpl_table_get_nrow(detector_table);
1029  p2vm_table = gravi_p2vm_new(n_region, n_wave, n_tel);
1030 
1031  cpl_propertylist_set_int(plist, "NREGION", n_region);
1032  cpl_propertylist_set_int(plist, "NWAVE", n_wave);
1033  cpl_propertylist_set_string(plist, "EXTNAME", GRAVI_P2VM_DATA_FT_EXT);
1034 
1035 
1036  gravi_data_add (p2vm_data, plist, p2vm_table);
1037 
1038  gravi_data_set_propertylist (p2vm_data, GRAVI_PRIMARY_HDR_NAME_EXT,
1039  p2vm_primary_hdr);
1040  cpl_propertylist_delete(p2vm_primary_hdr);
1041 
1042 
1043  cpl_propertylist_delete (plist);
1044  cpl_table_delete (p2vm_table);
1045  def_p2vm = 0;
1046  }
1047 
1048 
1049  if (gravi_compute_p2vm (p2vm_data, preproc_data, 0, valid_trans, valid_CP)
1050  != CPL_ERROR_NONE){
1051 
1052  cpl_frameset_delete(p2vm_frameset);
1053 
1054  gravi_data_delete(preproc_data);
1055  cpl_free(calib_datas);
1056  gravi_data_delete(dark_map);
1057  gravi_data_delete(wave_map);
1058  gravi_data_delete(profile_map);
1059  gravi_data_delete (p2vm_data);
1060  return (int) cpl_error_set_message(cpl_func,
1061  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the p2vm_map"
1062  " on the output file");
1063  }
1064 
1065 // gravi_data_save_data (p2vm_data, "p2vm_data_norma.fits", CPL_IO_CREATE);
1066 // int ke;
1067 // for (j = 0; j < 2; j++){
1068 // for (ke = 0; ke < 4; ke++)
1069 // printf("valid_trans[%d][%d] = %d ", j, ke, valid_trans[j][ke]);
1070 //
1071 // printf("\n");
1072 // }
1073 
1074  /* Option save the proproc file */
1075  if (cpl_parameter_get_bool(p)){
1076  preproc_frame = cpl_frameset_new ();
1077  cpl_frameset_insert (preproc_frame, cpl_frame_duplicate (frame));
1078  preproc_name = cpl_sprintf("gravi_preproc_%s", filename);
1079 
1080  applist = gravi_propertylist_get_qc (gravi_data_get_propertylist
1081  (preproc_data, GRAVI_PRIMARY_HDR_NAME_EXT));
1082 
1083 
1084  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, PREPROC);
1085 
1086 
1087  gravi_data_save(preproc_data, frameset, preproc_name, parlist,
1088  preproc_frame, frame, "gravi_all_p2vm", applist);
1089 
1090 // gravi_data_save_data(preproc_data[i], preproc_name, CPL_IO_CREATE);
1091 
1092  cpl_propertylist_delete (applist);
1093  cpl_frameset_delete (preproc_frame);
1094  cpl_free (preproc_name);
1095 
1096  }
1097 // printf("cpl_frameset_delete (preproc_frame);\n");
1098  gravi_data_delete(preproc_data);
1099 // frame = cpl_frameset_get_next(p2vm_frameset);
1100 // printf("data\n");
1101 
1102 
1103 // printf("fin\n");
1104  }
1105 // cpl_frameset_delete (preproc_frame);
1106  cpl_free(calib_datas);
1107  gravi_data_delete(dark_map);
1108  gravi_data_delete(wave_map);
1109  gravi_data_delete(profile_map);
1110  gravi_data_delete(badpix_map);
1111  }
1112 
1113  /* Initialization of the output name */
1114 
1115  else{
1116  p2vm_frameset = cpl_frameset_duplicate (preproc_frameset);
1117  nb_frame = cpl_frameset_get_size(preproc_frameset);
1118 
1119  /*test*/
1120 
1121  for (i = 0; i < nb_frame; i++){
1122  frame = cpl_frameset_get_position(preproc_frameset, i);
1123  filename = cpl_frame_get_filename(frame);
1124  cpl_msg_info(NULL, "Load of this file %s", filename);
1125  start = clock();
1126  preproc_data = gravi_data_load(filename);
1127  end = clock();
1128  cpl_msg_info (NULL, "charger le fichier preproc %s : %f", filename, (end - start) / (double)CLOCKS_PER_SEC);
1129  primary_hdr = gravi_data_get_propertylist(preproc_data,
1130  GRAVI_PRIMARY_HDR_NAME_EXT);
1131  shutter = gravi_shutters_check(primary_hdr);
1132  if ((shutter[0] == 1) && (shutter[1] == 1) && (shutter[2] == 1)
1133  && (shutter[3] == 1) && (met_check)){
1134 
1135  /* Compute the p2vm of the metrology */
1136  metrology_table = gravi_data_get_table(preproc_data,
1137  GRAVI_METROLOGY_EXT);
1138 
1139  if ((p2vm_met == NULL)/* && (cpl_parameter_get_bool (p))*/){
1140 
1141  met_plist = cpl_propertylist_duplicate (gravi_data_get_propertylist(data,
1142  GRAVI_METROLOGY_EXT));
1143  //mjd_obs = gravi_pfits_get_mjd (primary_hdr);
1144  acq_start = gravi_pfits_get_acq_start (primary_hdr);
1145 
1146  acq_mjd = gravi_convert_to_mjd (acq_start);
1147 
1148  opl_table = cpl_table_new (cpl_table_get_nrow(metrology_table));
1149  start = clock();
1150  p2vm_met = gravi_metrology_calibration (metrology_table,
1151  opl_table, 0);
1152  end = clock();
1153  printf ("Temps gravi_metrology_calibration : %f\n", (end - start) / (double)CLOCKS_PER_SEC);
1154  if (cpl_error_get_code()) {
1155  cpl_frameset_delete(preproc_frameset);
1156  gravi_data_delete(preproc_data);
1157 
1158  cpl_table_delete (opl_table);
1159  cpl_table_delete (p2vm_met);
1160  cpl_free(shutter);
1161  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
1162  "Error while computing p2vm of the metrology");
1163  }
1164  met_check = 0;
1165 
1166  }
1167  cpl_free (shutter);
1168  gravi_data_delete (preproc_data);
1169  continue;
1170  }
1171  start = clock();
1172  if (def_p2vm){
1173  cpl_msg_info (NULL, "Construction of the p2vm map");
1174  p2vm_data = gravi_data_new(0);
1175  p2vm_primary_hdr = cpl_propertylist_new ();
1176 
1177  for (j = 0; j < gravi_data_get_size (preproc_data); j++){
1178  plist = gravi_data_get_propertylist_x (preproc_data, j);
1179  const char * plist_name = gravi_pfits_get_extname (plist);
1180  /* Get the type of the extention */
1181  type_data = gravi_pfits_get_extension_type (plist);
1182 
1183  if (!(strcmp (plist_name, INS_DESCRIPTION) &&
1184  strcmp (plist_name, INS_TRAIN) &&
1185  strcmp (plist_name, GRAVI_IMAGING_DETECTOR_FT_EXT) &&
1186  strcmp (plist_name, GRAVI_IMAGING_DETECTOR_SC_EXT) &&
1187  strcmp (plist_name, GRAVI_IO_WAVELENGTH_FT_EXT) &&
1188  strcmp (plist_name, GRAVI_IO_WAVELENGTH_SC_EXT))){
1189  if (type_data == 2)
1190  gravi_data_add (p2vm_data, plist,
1191  gravi_data_get_table (preproc_data, plist_name));
1192  else if (type_data == 3)
1193  gravi_data_add_cube (p2vm_data, plist,
1194  gravi_data_get_cube (preproc_data, plist_name));
1195  }
1196  }
1197  detector_table = gravi_data_get_table (preproc_data,
1198  GRAVI_IMAGING_DETECTOR_SC_EXT);
1199  oiwave_plist = gravi_data_get_propertylist
1200  (preproc_data, GRAVI_IO_WAVELENGTH_SC_EXT);
1201  n_wave = gravi_pfits_get_nwave(oiwave_plist);
1202  n_region = cpl_table_get_nrow(detector_table);
1203 
1204  p2vm_table = gravi_p2vm_new(n_region, n_wave, n_tel);
1205  plist = cpl_propertylist_new();
1206  origin = gravi_pfits_get_origin (primary_hdr);
1207  cpl_propertylist_append_string(plist, "ORIGIN", origin);
1208  cpl_propertylist_append_int(plist, "NREGION", n_region);
1209  cpl_propertylist_append_int(plist, "NWAVE", n_wave);
1210  cpl_propertylist_append_string(plist, "EXTNAME", GRAVI_P2VM_DATA_SC_EXT);
1211 
1212  gravi_data_add (p2vm_data, plist, p2vm_table);
1213 
1214  cpl_table_delete (p2vm_table);
1215  detector_table = gravi_data_get_table (preproc_data,
1216  GRAVI_IMAGING_DETECTOR_FT_EXT);
1217  oiwave_plist = gravi_data_get_propertylist
1218  (preproc_data, GRAVI_IO_WAVELENGTH_FT_EXT);
1219  n_wave = gravi_pfits_get_nwave(oiwave_plist);
1220  n_region = cpl_table_get_nrow(detector_table);
1221  cpl_propertylist_set_int(plist, "NREGION", n_region);
1222  cpl_propertylist_set_int(plist, "NWAVE", n_wave);
1223  p2vm_table = gravi_p2vm_new(n_region, n_wave, n_tel);
1224  cpl_propertylist_set_string(plist, "EXTNAME", GRAVI_P2VM_DATA_FT_EXT);
1225 
1226  gravi_data_add (p2vm_data, plist, p2vm_table);
1227 
1228  gravi_data_set_propertylist (p2vm_data, GRAVI_PRIMARY_HDR_NAME_EXT,
1229  p2vm_primary_hdr);
1230  cpl_propertylist_delete(p2vm_primary_hdr);
1231 
1232 
1233  cpl_propertylist_delete (plist);
1234  cpl_table_delete (p2vm_table);
1235  def_p2vm = 0;
1236  }
1237 
1238  end = clock();
1239  cpl_msg_info (NULL, "entre les deux %s : %f", filename, (end - start) / (double)CLOCKS_PER_SEC);
1240  if (gravi_compute_p2vm (p2vm_data, preproc_data, 0, valid_trans, valid_CP)
1241  != CPL_ERROR_NONE){
1242 
1243  cpl_frameset_delete(p2vm_frameset);
1244  cpl_frameset_delete(preproc_frameset);
1245  gravi_data_delete(preproc_data);
1246  gravi_data_delete (p2vm_data);
1247  cpl_free (shutter);
1248  for (i = 0 ; i < 2; i++){
1249  cpl_free (valid_trans[i]);
1250  cpl_free (valid_CP[i]);
1251  }
1252  cpl_free (valid_trans);
1253  cpl_free (valid_CP);
1254  return (int) cpl_error_set_message(cpl_func,
1255  CPL_ERROR_ILLEGAL_OUTPUT, "error while computing the p2vm_map"
1256  " on the output file");
1257  }
1258  start = clock();
1259  cpl_msg_info (NULL, "le p2vm de ce fichier %s : %f", filename, (start - end) / (double)CLOCKS_PER_SEC);
1260 
1261 // gravi_data_save_data (p2vm_data, "p2vm_data_norma.fits", CPL_IO_CREATE);
1262 // int ke;
1263 // for (j = 0; j < 2; j++){
1264 // for (ke = 0; ke < 4; ke++)
1265 // printf("valid_trans[%d][%d] = %d ", j, ke, valid_trans[j][ke]);
1266 //
1267 // printf("\n");
1268 // }
1269 
1270  gravi_data_delete(preproc_data);
1271  cpl_free (shutter);
1272 
1273 // frame = cpl_frameset_get_next(preproc_frameset);
1274  }
1275  }
1276 
1277  /* Compute the p2vm table of a set of p2vm frames */
1278  gravi_data_save_data (p2vm_data, "p2vm_data_norma.fits", CPL_IO_CREATE);
1279  }
1280  else {
1281 
1282 // int k;
1283 // for (k = 0; k < 2; k++){
1284 // if (k = 0)
1285 // printf("c_matrix SC =\n");
1286 // else
1287 // printf("c_matrix FT =\n");
1288 // for (i = 0 ; i < cpl_matrix_get_nrow (c_matrix[k]); i++){
1289 // for (j = 0; j < cpl_matrix_get_ncol (c_matrix[k]); j++){
1290 // printf("%e ", cpl_matrix_get(c_matrix[k], i, j));
1291 // }
1292 // printf("\n");
1293 // }
1294 // }
1295  int k;
1296  for (i = 0 ; i < 2; i++){
1297  for (k = 0; k < 4; k++)
1298  valid_trans[i][k] = 1;
1299  for (k = 0; k < 6; k++)
1300  valid_CP[i][k] = 1;
1301  }
1302 
1303  p2vm_frameset = cpl_frameset_duplicate (norma_frameset);
1304  preproc_frameset = cpl_frameset_duplicate (norma_frameset);
1305  frame = cpl_frameset_get_position(norma_frameset, 0);
1306  filename = cpl_frame_get_filename(frame);
1307  cpl_msg_info(NULL, "Load of this file %s", filename);
1308 
1309  start = clock();
1310  p2vm_data = gravi_data_load(filename);
1311  }
1312  start = clock();
1313  if (gravi_p2vm_normalisation (p2vm_data, valid_trans, valid_CP ) != CPL_ERROR_NONE) {
1314  cpl_frameset_delete(p2vm_frameset);
1315  for (i = 0 ; i < 2; i++){
1316  cpl_free (valid_trans[i]);
1317  cpl_free (valid_CP[i]);
1318  }
1319  cpl_free (valid_trans);
1320  cpl_free (valid_CP);
1321  gravi_data_delete(p2vm_data);
1322  return (int)cpl_error_set_message(cpl_func, CPL_ERROR_ILLEGAL_OUTPUT,
1323  "Error while the normalisation of the p2vm_map");
1324  }
1325  end = clock();
1326  cpl_msg_info (NULL, "Temps gravi_normalisation %s : %f", filename, (end - start) / (double)CLOCKS_PER_SEC);
1327 
1328 
1329 
1330  /* Add the p2vm metrology field */
1331 
1332  if (met_check == 0){
1333  cpl_propertylist_set_string (met_plist, "EXTNAME",
1334  GRAVI_P2VM_MET_EXT);
1335 
1336  gravi_data_add (p2vm_data, met_plist, p2vm_met);
1337 
1338  cpl_table_delete (p2vm_met);
1339  cpl_propertylist_delete (met_plist);
1340  }
1341 
1342  for (i = 0 ; i < 2; i++){
1343  cpl_free (valid_trans[i]);
1344  cpl_free (valid_CP[i]);
1345  }
1346  cpl_free (valid_trans);
1347  cpl_free (valid_CP);
1348 
1349  /* Create product frame, add DataFlow keywords, save the file, log the
1350  * saved file in the input frameset*/
1351 
1352  p2vm_plist = gravi_data_get_propertylist(p2vm_data, GRAVI_PRIMARY_HDR_NAME_EXT);
1353  applist = gravi_propertylist_get_qc (p2vm_plist);
1354 
1355  cpl_propertylist_append_string(applist, CPL_DFS_PRO_CATG, P2VM);
1356 
1357  if (gravi_data_save( p2vm_data, frameset, "gravi_final_p2vm.fits", parlist,
1358  p2vm_frameset, NULL, "gravi_all_p2vm", applist)
1359  != CPL_ERROR_NONE){
1360 
1361  gravi_data_delete(p2vm_data);
1362  cpl_frameset_delete(p2vm_frameset);
1363  cpl_frameset_delete(preproc_frameset);
1364  cpl_propertylist_delete(applist);
1365  return (int) cpl_error_set_message(cpl_func,
1366  CPL_ERROR_ILLEGAL_OUTPUT, "Could not save the p2vm_map"
1367  " on the output file");
1368  }
1369 
1370  /* Deallocation of all variables */
1371 
1372  gravi_data_delete(p2vm_data);
1373  cpl_frameset_delete(p2vm_frameset);
1374  cpl_frameset_delete(preproc_frameset);
1375  cpl_frameset_delete(norma_frameset);
1376  cpl_propertylist_delete(applist);
1377 
1378  return (int)cpl_error_get_code();
1379 }
1380 
1381