39 #include "irplib_utils.h"
41 #include "hawki_utils.h"
42 #include "hawki_image_stats.h"
43 #include "hawki_pfits.h"
44 #include "hawki_dfs.h"
45 #include "hawki_load.h"
46 #include "hawki_save.h"
47 #include "hawki_variance.h"
53 static int hawki_cal_dark_create(cpl_plugin *) ;
54 static int hawki_cal_dark_exec(cpl_plugin *) ;
55 static int hawki_cal_dark_destroy(cpl_plugin *) ;
56 static int hawki_cal_dark(cpl_parameterlist *, cpl_frameset *) ;
58 void hawki_cal_dark_initialise_qc(
void);
59 static int hawki_cal_dark_retrieve_input_param
60 (cpl_parameterlist * parlist);
61 static double hawki_cal_dark_ron(
const cpl_image *,
const cpl_image *,
int) ;
62 static int hawki_cal_dark_save
63 (
const cpl_imagelist * dark,
64 const cpl_imagelist * master_dark_err,
65 const cpl_imagelist * bpmdark,
66 cpl_table ** raw_dark_stats,
67 const cpl_vector ** rons,
68 const cpl_frameset * used_frames,
69 cpl_parameterlist * parlist,
88 } hawki_cal_dark_config ;
92 int nb_badpix[HAWKI_NB_DETECTORS] ;
93 double master_dark_mean[HAWKI_NB_DETECTORS] ;
94 double master_dark_med[HAWKI_NB_DETECTORS] ;
95 double master_dark_stdev[HAWKI_NB_DETECTORS] ;
96 double master_dark_error_mean[HAWKI_NB_DETECTORS] ;
97 double master_dark_error_med[HAWKI_NB_DETECTORS] ;
98 double master_dark_error_stdev[HAWKI_NB_DETECTORS] ;
99 double vc_mean[HAWKI_NB_DETECTORS][HAWKI_NB_VC] ;
100 double vc_med[HAWKI_NB_DETECTORS][HAWKI_NB_VC] ;
101 double vc_stdev[HAWKI_NB_DETECTORS][HAWKI_NB_VC] ;
105 } hawki_cal_dark_outputs;
107 static char hawki_cal_dark_description[] =
108 "hawki_cal_dark -- Dark recipe\n"
109 "The files listed in the Set Of Frames (sof-file) must be tagged:\n"
110 "raw-file.fits "HAWKI_CAL_DARK_RAW
" or\n"
111 "raw-file.fits "HAWKI_TEC_FLAT_RAW
".\n"
112 "The recipe creates as an output:\n"
113 "hawki_cal_dark.fits ("HAWKI_CALPRO_DARK
"): The master dark\n"
114 "hawki_cal_dark_bpmdark.fits("HAWKI_CALPRO_BPM_HOT
"): The bad pixel mask associated to the dark\n"
115 "hawki_cal_dark_stats.fits("HAWKI_CALPRO_DARK_STATS
"): Statistics of the raw darks\n"
116 "Optionally it also creates:\n"
117 "hawki_cal_dark_err.fits("HAWKI_CALPRO_DARK_ERR
"): The error in the master dark\n"
119 "esorex exits with an error code of 0 if the recipe completes successfully\n"
136 int cpl_plugin_get_info(cpl_pluginlist * list)
138 cpl_recipe * recipe = cpl_calloc(1,
sizeof *recipe ) ;
139 cpl_plugin * plugin = &recipe->interface ;
141 cpl_plugin_init(plugin,
143 HAWKI_BINARY_VERSION,
144 CPL_PLUGIN_TYPE_RECIPE,
147 hawki_cal_dark_description,
148 "Cesar Enrique Garcia Dabo",
151 hawki_cal_dark_create,
153 hawki_cal_dark_destroy) ;
155 cpl_pluginlist_append(list, plugin) ;
169 static int hawki_cal_dark_create(cpl_plugin * plugin)
171 cpl_recipe * recipe ;
175 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
176 recipe = (cpl_recipe *)plugin ;
180 recipe->parameters = cpl_parameterlist_new() ;
184 p = cpl_parameter_new_value(
"hawki.hawki_cal_dark.sigma",
185 CPL_TYPE_DOUBLE,
"sigma for hot bad pixels detection",
186 "hawki.hawki_cal_dark", 10.0) ;
187 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI,
"sigma") ;
188 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
189 cpl_parameterlist_append(recipe->parameters, p) ;
191 p = cpl_parameter_new_value(
"hawki.hawki_cal_dark.nsamples",
192 CPL_TYPE_INT,
"number of samples for RON computation",
193 "hawki.hawki_cal_dark", 100) ;
194 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI,
"nsamples") ;
195 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
196 cpl_parameterlist_append(recipe->parameters, p) ;
198 p = cpl_parameter_new_value(
"hawki.hawki_cal_dark.hsize",
199 CPL_TYPE_INT,
"half size of the window for RON computation",
200 "hawki.hawki_cal_dark", 6) ;
201 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI,
"hsize") ;
202 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
203 cpl_parameterlist_append(recipe->parameters, p) ;
205 p = cpl_parameter_new_value(
"hawki.hawki_cal_dark.zone",
208 "hawki.hawki_cal_dark",
209 "512,512,1536,1536") ;
210 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI,
"zone") ;
211 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
212 cpl_parameterlist_append(recipe->parameters, p) ;
214 p = cpl_parameter_new_value(
"hawki.hawki_cal_dark.gain",
216 "Detector nominal gain (e-/ADU)",
217 "hawki.hawki_cal_dark",
219 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI,
"gain") ;
220 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
221 cpl_parameterlist_append(recipe->parameters, p) ;
223 p = cpl_parameter_new_value(
"hawki.hawki_cal_dark.ron",
225 "Detector nominal RON for a single readout (ADU)",
226 "hawki.hawki_cal_dark",
228 cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI,
"ron") ;
229 cpl_parameter_disable(p, CPL_PARAMETER_MODE_ENV) ;
230 cpl_parameterlist_append(recipe->parameters, p) ;
243 static int hawki_cal_dark_exec(cpl_plugin * plugin)
245 cpl_recipe * recipe ;
248 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
249 recipe = (cpl_recipe *)plugin ;
255 return hawki_cal_dark(recipe->parameters, recipe->frames) ;
265 static int hawki_cal_dark_destroy(cpl_plugin * plugin)
267 cpl_recipe * recipe ;
270 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
271 recipe = (cpl_recipe *)plugin ;
274 cpl_parameterlist_delete(recipe->parameters) ;
286 static int hawki_cal_dark(
287 cpl_parameterlist * parlist,
288 cpl_frameset * frameset)
290 cpl_frameset * rawframes ;
291 cpl_frame * ref_frame ;
292 cpl_propertylist * plist ;
293 cpl_imagelist * darks_raw ;
294 cpl_imagelist * master_dark;
295 cpl_imagelist * master_dark_err;
296 cpl_imagelist * bpmdark;
298 cpl_image * ima_curr ;
299 cpl_image * ima_next ;
300 cpl_image * ima_accu ;
301 cpl_image * ima_accu_err = NULL;
303 cpl_vector * rons[HAWKI_NB_DETECTORS] ;
304 cpl_table ** raw_dark_stats;
306 int vc_urx, vc_ury, vc_llx, vc_lly ;
309 cpl_errorstate error_prevstate;
315 master_dark_err = NULL;
316 hawki_cal_dark_initialise_qc();
319 if(hawki_cal_dark_retrieve_input_param(parlist))
321 cpl_msg_error(__func__,
"Wrong parameters");
327 cpl_msg_error(__func__,
"Cannot identify RAW and CALIB frames") ;
335 if (rawframes == NULL) {
336 cpl_msg_error(__func__,
"No raw frame in input (%s)",HAWKI_CAL_DARK_RAW);
341 if (cpl_frameset_get_size(rawframes) < 3) {
342 cpl_msg_error(__func__,
"Not enough input frames");
343 cpl_frameset_delete(rawframes) ;
348 error_prevstate = cpl_errorstate_get();
349 ref_frame = cpl_frameset_get_frame(rawframes, 0) ;
350 if ((plist=cpl_propertylist_load(cpl_frame_get_filename(ref_frame),
352 cpl_msg_error(__func__,
"Cannot get header from frame");
353 cpl_msg_indent_less() ;
354 cpl_frameset_delete(rawframes) ;
360 cpl_propertylist_delete(plist) ;
361 if(!cpl_errorstate_is_equal(error_prevstate))
363 cpl_msg_error(__func__,
"Cannot get the DIT/NDIT/NDSAMPLES from the header") ;
364 cpl_msg_indent_less() ;
365 cpl_frameset_delete(rawframes) ;
368 cpl_msg_info(__func__,
"DIT value: %g sec.", hawki_cal_dark_outputs.dit);
369 cpl_msg_info(__func__,
"NDIT value: %d", hawki_cal_dark_outputs.ndit);
370 cpl_msg_info(__func__,
"NDSAMPLES value: %d", hawki_cal_dark_outputs.ndsamples);
377 cpl_msg_error(__func__,
"Not all input darks have the same "
378 "DIT/NDIT/NDSAMPLES values");
379 cpl_msg_indent_less() ;
384 nframes = cpl_frameset_get_size(rawframes) ;
387 raw_dark_stats = cpl_malloc(HAWKI_NB_DETECTORS *
sizeof(cpl_table *));
388 for( idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
390 raw_dark_stats[idet] = cpl_table_new(nframes);
395 master_dark = cpl_imagelist_new();
396 if(hawki_cal_dark_config.error_tracking)
397 master_dark_err = cpl_imagelist_new();
398 bpmdark = cpl_imagelist_new();
399 cpl_msg_info(__func__,
"Dark computation");
400 cpl_msg_indent_more() ;
401 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++) {
402 cpl_msg_info(__func__,
"Handle chip number %d", idet+1) ;
405 rons[idet] = cpl_vector_new(nframes) ;
411 for (j=0 ; j<nframes ; j++) {
414 ima_curr = cpl_imagelist_get(darks_raw, j) ;
415 ima_next = cpl_imagelist_get(darks_raw, 0) ;
417 ima_curr = cpl_imagelist_get(darks_raw, j) ;
418 ima_next = cpl_imagelist_get(darks_raw, j+1) ;
425 hawki_cal_dark_config.llx,
426 hawki_cal_dark_config.lly,
427 hawki_cal_dark_config.urx,
428 hawki_cal_dark_config.ury,
432 cpl_msg_error(__func__,
"Cannot compute statistics") ;
433 cpl_msg_indent_less() ;
434 cpl_frameset_delete(rawframes) ;
435 cpl_imagelist_delete(master_dark);
436 if(hawki_cal_dark_config.error_tracking)
437 cpl_imagelist_delete(master_dark_err);
438 cpl_imagelist_delete(darks_raw);
439 cpl_imagelist_delete(bpmdark) ;
440 for (k=0 ; k<=idet ; k++)
441 cpl_vector_delete(rons[k]) ;
442 for( idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
443 cpl_table_delete(raw_dark_stats[idet]);
444 cpl_free(raw_dark_stats);
449 ron = hawki_cal_dark_ron(ima_curr, ima_next, hawki_cal_dark_outputs.ndit) ;
450 cpl_vector_set(rons[idet], j, ron);
456 ima_accu = cpl_imagelist_collapse_minmax_create(darks_raw, 0, 1) ;
457 if(hawki_cal_dark_config.error_tracking)
459 cpl_imagelist * variances;
460 cpl_image * accu_var;
461 cpl_msg_info(__func__,
"Computing the uncertainty in dark");
463 (darks_raw, hawki_cal_dark_config.gain,
464 hawki_cal_dark_config.ron, hawki_cal_dark_outputs.ndit,
465 hawki_cal_dark_outputs.ndsamples);
471 accu_var = cpl_imagelist_collapse_minmax_create(variances,0,1);
472 cpl_image_divide_scalar(accu_var, nframes - 1);
473 ima_accu_err = cpl_image_duplicate(accu_var);
474 cpl_image_power(ima_accu_err, 0.5);
475 cpl_imagelist_delete(variances);
476 cpl_image_delete(accu_var);
480 ima_accu = cpl_imagelist_collapse_create(darks_raw) ;
481 if(hawki_cal_dark_config.error_tracking)
483 cpl_imagelist * variances;
484 cpl_image * accu_var;
485 cpl_msg_info(__func__,
"Computing the uncertainty in dark");
487 (darks_raw, hawki_cal_dark_config.gain,
488 hawki_cal_dark_config.ron, hawki_cal_dark_outputs.ndit,
489 hawki_cal_dark_outputs.ndsamples);
490 accu_var = cpl_imagelist_collapse_create(variances);
491 cpl_image_divide_scalar(accu_var, nframes);
492 ima_accu_err = cpl_image_duplicate(accu_var);
493 cpl_image_power(ima_accu_err, 0.5);
494 cpl_imagelist_delete(variances);
495 cpl_image_delete(accu_var);
498 if (ima_accu == NULL) {
499 cpl_msg_error(__func__,
"Cannot compute the average") ;
500 cpl_frameset_delete(rawframes) ;
501 cpl_imagelist_delete(bpmdark) ;
502 cpl_imagelist_delete(master_dark) ;
503 if(ima_accu_err != NULL)
504 cpl_image_delete(ima_accu_err);
505 cpl_imagelist_delete(darks_raw);
506 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
507 cpl_vector_delete(rons[idet]) ;
508 for( idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
509 cpl_table_delete(raw_dark_stats[idet]);
510 cpl_free(raw_dark_stats);
513 cpl_imagelist_delete(darks_raw) ;
516 cpl_imagelist_set(master_dark, ima_accu, idet) ;
517 if(hawki_cal_dark_config.error_tracking)
518 cpl_imagelist_set(master_dark_err, ima_accu_err, idet) ;
521 hawki_cal_dark_outputs.master_dark_med[idet]=
522 cpl_image_get_median(ima_accu) / hawki_cal_dark_outputs.dit;
523 hawki_cal_dark_outputs.master_dark_mean[idet] =
524 cpl_image_get_mean(ima_accu) / hawki_cal_dark_outputs.dit;
525 hawki_cal_dark_outputs.master_dark_stdev[idet] =
526 cpl_image_get_stdev(ima_accu) / hawki_cal_dark_outputs.dit;
527 if(hawki_cal_dark_config.error_tracking)
529 hawki_cal_dark_outputs.master_dark_error_med[idet]=
530 cpl_image_get_median(ima_accu_err) / hawki_cal_dark_outputs.dit;
531 hawki_cal_dark_outputs.master_dark_error_mean[idet] =
532 cpl_image_get_mean(ima_accu_err) / hawki_cal_dark_outputs.dit;
533 hawki_cal_dark_outputs.master_dark_error_stdev[idet] =
534 cpl_image_get_stdev(ima_accu_err) / hawki_cal_dark_outputs.dit;
540 for (j=0 ; j<HAWKI_NB_VC ; j++) {
541 vc_llx = j*(2048/HAWKI_NB_VC) + 1 ;
542 vc_urx = (j+1)*(2048/HAWKI_NB_VC) ;
544 hawki_cal_dark_outputs.vc_mean[idet][j] =
545 cpl_image_get_mean_window(ima_accu, vc_llx, vc_lly,
548 hawki_cal_dark_outputs.vc_med[idet][j] =
549 cpl_image_get_median_window(ima_accu, vc_llx, vc_lly,
552 hawki_cal_dark_outputs.vc_stdev[idet][j] =
553 cpl_image_get_stdev_window(ima_accu, vc_llx, vc_lly,
558 cpl_msg_info(__func__,
"Compute the BPM from the dark") ;
559 cpl_msg_indent_more() ;
561 hawki_cal_dark_config.sigma)) == NULL) {
562 cpl_msg_error(__func__,
"Cannot compute the hot pixels") ;
563 cpl_msg_indent_less() ;
564 cpl_frameset_delete(rawframes) ;
565 cpl_imagelist_delete(bpmdark) ;
566 cpl_imagelist_delete(master_dark);
567 if(hawki_cal_dark_config.error_tracking)
568 cpl_imagelist_delete(master_dark_err);
569 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
570 cpl_vector_delete(rons[idet]) ;
571 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
572 cpl_table_delete(raw_dark_stats[idet]);
573 cpl_free(raw_dark_stats);
576 cpl_imagelist_set(bpmdark, bpm, idet) ;
577 hawki_cal_dark_outputs.nb_badpix[idet]=(int)cpl_image_get_flux(bpm);
578 cpl_msg_indent_less() ;
580 cpl_msg_indent_less() ;
583 cpl_msg_info(__func__,
"Division by DIT") ;
584 cpl_imagelist_divide_scalar(master_dark, hawki_cal_dark_outputs.dit);
585 if(hawki_cal_dark_config.error_tracking)
586 cpl_imagelist_divide_scalar(master_dark_err, hawki_cal_dark_outputs.dit);
589 cpl_msg_info(__func__,
"Save the products") ;
590 cpl_msg_indent_more() ;
591 if (hawki_cal_dark_save(master_dark, master_dark_err,
592 bpmdark, raw_dark_stats,
593 (
const cpl_vector **)rons,
596 cpl_msg_warning(__func__,
"Some data could not be saved. "
597 "Check permisions or disk space");
600 cpl_frameset_delete(rawframes) ;
601 for (idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
602 cpl_vector_delete(rons[idet]) ;
603 cpl_imagelist_delete(master_dark) ;
604 if(hawki_cal_dark_config.error_tracking)
605 cpl_imagelist_delete(master_dark_err);
606 cpl_imagelist_delete(bpmdark) ;
607 cpl_msg_indent_less() ;
608 for( idet=0 ; idet<HAWKI_NB_DETECTORS ; idet++)
609 cpl_table_delete(raw_dark_stats[idet]);
610 cpl_free(raw_dark_stats);
613 if (cpl_error_get_code())
615 cpl_msg_error(__func__,
616 "HAWK-I pipeline could not recover from previous errors");
631 static double hawki_cal_dark_ron(
632 const cpl_image * ima1,
633 const cpl_image * ima2,
641 if (ima1 == NULL)
return -1.0 ;
642 if (ima2 == NULL)
return -1.0 ;
643 if (ndit < 1)
return -1.0 ;
650 if ((ima = cpl_image_subtract_create(ima2, ima1)) == NULL)
return -1.0 ;
653 cpl_flux_get_noise_window(ima, NULL, hawki_cal_dark_config.hsize,
654 hawki_cal_dark_config.nsamples, &ron, NULL) ;
655 cpl_image_delete(ima) ;
670 static int hawki_cal_dark_save
671 (
const cpl_imagelist * master_dark,
672 const cpl_imagelist * master_dark_err,
673 const cpl_imagelist * bpmdark,
674 cpl_table ** raw_dark_stats,
675 const cpl_vector ** rons,
676 const cpl_frameset * used_frames,
677 cpl_parameterlist * parlist,
680 cpl_propertylist ** qclists ;
681 const cpl_frame * ref_frame ;
683 cpl_propertylist * inputlist ;
685 const char * recipe_name =
"hawki_cal_dark" ;
687 cpl_errorstate error_prevstate = cpl_errorstate_get();
691 ref_frame = irplib_frameset_get_first_from_group(
set, CPL_FRAME_GROUP_RAW) ;
694 qclists = cpl_malloc(HAWKI_NB_DETECTORS *
sizeof(cpl_propertylist*)) ;
695 for (i=0 ; i<HAWKI_NB_DETECTORS ; i++) {
696 qclists[i] = cpl_propertylist_new();
697 cpl_propertylist_append_int(qclists[i],
"ESO QC DARK NBADPIX",
698 hawki_cal_dark_outputs.nb_badpix[i]);
699 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK MEAN",
700 hawki_cal_dark_outputs.master_dark_mean[i]);
701 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK MED",
702 hawki_cal_dark_outputs.master_dark_med[i]);
703 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK STDEV",
704 hawki_cal_dark_outputs.master_dark_stdev[i]);
705 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK NONORM MEAN",
706 hawki_cal_dark_outputs.master_dark_mean[i] * hawki_cal_dark_outputs.dit);
707 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK NONORM MED",
708 hawki_cal_dark_outputs.master_dark_med[i] * hawki_cal_dark_outputs.dit);
709 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK NONORM STDEV",
710 hawki_cal_dark_outputs.master_dark_stdev[i] * hawki_cal_dark_outputs.dit);
711 if(hawki_cal_dark_config.error_tracking)
713 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK ERR MEAN",
714 hawki_cal_dark_outputs.master_dark_error_mean[i]);
715 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK ERR MED",
716 hawki_cal_dark_outputs.master_dark_error_med[i]);
717 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK ERR STDEV",
718 hawki_cal_dark_outputs.master_dark_error_stdev[i]);
719 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK ERR NONORM MEAN",
720 hawki_cal_dark_outputs.master_dark_error_mean[i] * hawki_cal_dark_outputs.dit);
721 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK ERR NONORM MED",
722 hawki_cal_dark_outputs.master_dark_error_med[i] * hawki_cal_dark_outputs.dit);
723 cpl_propertylist_append_double(qclists[i],
"ESO QC DARK ERR NONORM STDEV",
724 hawki_cal_dark_outputs.master_dark_error_stdev[i] * hawki_cal_dark_outputs.dit);
726 for (j=0 ; j<HAWKI_NB_VC ; j++) {
727 sprintf(sval,
"ESO QC DARK VC%d MEAN", j+1) ;
728 cpl_propertylist_append_double(qclists[i], sval,
729 hawki_cal_dark_outputs.vc_mean[i][j]) ;
730 sprintf(sval,
"ESO QC DARK VC%d MED", j+1) ;
731 cpl_propertylist_append_double(qclists[i], sval,
732 hawki_cal_dark_outputs.vc_med[i][j]) ;
733 sprintf(sval,
"ESO QC DARK VC%d STDEV", j+1) ;
734 cpl_propertylist_append_double(qclists[i], sval,
735 hawki_cal_dark_outputs.vc_stdev[i][j]) ;
737 for (j=0 ; j<cpl_vector_get_size(rons[i]) ; j++) {
738 sprintf(sval,
"ESO QC RON%d", j+1) ;
739 cpl_propertylist_append_double(qclists[i], sval,
740 cpl_vector_get(rons[i], j)) ;
742 cpl_propertylist_append_double(qclists[i],
"ESO QC RON MEAN",
743 cpl_vector_get_mean(rons[i])) ;
744 cpl_propertylist_append_double(qclists[i],
"ESO QC RON MED",
745 cpl_vector_get_median_const(rons[i])) ;
746 cpl_propertylist_append_double(qclists[i],
"ESO QC RON STDEV",
747 cpl_vector_get_stdev(rons[i])) ;
748 cpl_propertylist_append_double(qclists[i],
"ESO QC DATANCOM",
749 cpl_frameset_get_size(
set)) ;
753 inputlist = cpl_propertylist_load_regexp(
754 cpl_frame_get_filename(ref_frame), ext_nb,
755 HAWKI_HEADER_EXT_FORWARD, 0) ;
756 cpl_propertylist_append(qclists[i], inputlist) ;
757 cpl_propertylist_delete(inputlist) ;
771 (
const cpl_propertylist**)qclists,
772 "hawki_cal_dark.fits") ;
775 if(master_dark_err != NULL)
782 HAWKI_CALPRO_DARK_ERR,
783 HAWKI_PROTYPE_DARK_ERR,
786 "hawki_cal_dark_err.fits") ;
795 HAWKI_CALPRO_BPM_HOT,
799 "hawki_cal_dark_bpmdark.fits") ;
806 (
const cpl_table **)raw_dark_stats,
808 HAWKI_CALPRO_DARK_STATS,
809 HAWKI_PROTYPE_DARK_STATS,
812 "hawki_cal_dark_stats.fits") ;
815 for (i=0 ; i<HAWKI_NB_DETECTORS ; i++) {
816 cpl_propertylist_delete(qclists[i]) ;
819 if(!cpl_errorstate_is_equal(error_prevstate))
821 cpl_errorstate_set(CPL_ERROR_NONE);
827 static int hawki_cal_dark_retrieve_input_param
828 (cpl_parameterlist * parlist)
830 cpl_parameter * par ;
832 cpl_errorstate error_prevstate = cpl_errorstate_get();
835 par = cpl_parameterlist_find(parlist,
"hawki.hawki_cal_dark.sigma") ;
836 hawki_cal_dark_config.sigma = cpl_parameter_get_double(par) ;
837 par = cpl_parameterlist_find(parlist,
"hawki.hawki_cal_dark.hsize") ;
838 hawki_cal_dark_config.hsize = cpl_parameter_get_int(par) ;
839 par = cpl_parameterlist_find(parlist,
"hawki.hawki_cal_dark.nsamples") ;
840 hawki_cal_dark_config.nsamples = cpl_parameter_get_int(par) ;
841 par = cpl_parameterlist_find(parlist,
"hawki.hawki_cal_dark.zone") ;
842 sval = cpl_parameter_get_string(par) ;
843 if (sscanf(sval,
"%d,%d,%d,%d",
844 &hawki_cal_dark_config.llx,
845 &hawki_cal_dark_config.lly,
846 &hawki_cal_dark_config.urx,
847 &hawki_cal_dark_config.ury)!=4) {
850 par = cpl_parameterlist_find(parlist,
"hawki.hawki_cal_dark.gain") ;
851 hawki_cal_dark_config.gain = cpl_parameter_get_double(par);
852 par = cpl_parameterlist_find(parlist,
"hawki.hawki_cal_dark.ron") ;
853 hawki_cal_dark_config.ron = cpl_parameter_get_double(par);
854 hawki_cal_dark_config.error_tracking = 0;
855 if(hawki_cal_dark_config.gain > 0 && hawki_cal_dark_config.ron > 0)
856 hawki_cal_dark_config.error_tracking = 1;
858 if(!cpl_errorstate_is_equal(error_prevstate))
864 void hawki_cal_dark_initialise_qc(
void)
869 for(idet=0; idet<HAWKI_NB_DETECTORS; idet++)
871 hawki_cal_dark_outputs.nb_badpix[idet] = -1 ;
872 hawki_cal_dark_outputs.master_dark_mean[idet] = -1.0 ;
873 hawki_cal_dark_outputs.master_dark_med[idet] = -1.0 ;
874 hawki_cal_dark_outputs.master_dark_stdev[idet] = -1.0 ;
875 hawki_cal_dark_outputs.master_dark_error_mean[idet] = -1.0 ;
876 hawki_cal_dark_outputs.master_dark_error_med[idet] = -1.0 ;
877 hawki_cal_dark_outputs.master_dark_error_stdev[idet] = -1.0 ;
878 for (j=0 ; j<HAWKI_NB_VC ; j++)
880 hawki_cal_dark_outputs.vc_mean[idet][j] = -1.0 ;
881 hawki_cal_dark_outputs.vc_med[idet][j] = -1.0 ;
882 hawki_cal_dark_outputs.vc_stdev[idet][j] = -1.0 ;