38#include <casu_utils.h>
40#include <casu_stats.h>
42#include "vircam_utils.h"
43#include "vircam_pfits.h"
44#include "vircam_dfs.h"
45#include "vircam_mods.h"
46#include "vircam_channel.h"
47#include "vircam_paf.h"
51static int vircam_linearity_analyse_create(cpl_plugin *) ;
52static int vircam_linearity_analyse_exec(cpl_plugin *) ;
53static int vircam_linearity_analyse_destroy(cpl_plugin *) ;
54static int vircam_linearity_analyse(cpl_parameterlist *, cpl_frameset *) ;
55static int vircam_linearity_analyse_lastbit(
int jext, cpl_frameset *framelist,
56 cpl_parameterlist *parlist);
57static int vircam_linearity_analyse_save(cpl_frameset *framelist,
58 cpl_parameterlist *parlist);
59static int vircam_linearity_analyse_domedark_groups(
void);
60static double *vircam_linearity_analyse_genstat(casu_fits *fframe,
int *bpm,
62static double *vircam_linearity_tweakfac(
double **fdata,
double *mjd,
int nim,
63 int nchan,
double *facrng,
65static void vircam_mjdsort(
double **fdata,
double *mjd,
int n);
66static cpl_table *vircam_linearity_analyse_diagtab_init(
int np,
int nrows);
67static void vircam_linearity_analyse_init(
void);
68static void vircam_linearity_analyse_tidy(
int level);
93} vircam_linearity_analyse_config;
106#define SATURATE_FLAG 1
109#define SUBSET2 (SUBSET/2)
113 cpl_frameset *domelist;
115 cpl_frameset *darklist;
117 cpl_frameset *domecheck;
119 cpl_frameset *darkcheck;
125 cpl_array *bpm_array;
128 casu_fits **flatlist;
130 cpl_propertylist *plist;
131 cpl_propertylist *elist;
134 cpl_propertylist *phupaf;
144static cpl_frame *product_frame_chantab = NULL;
145static cpl_frame *product_frame_bpm = NULL;
146static cpl_frame *product_frame_diag1 = NULL;
147static cpl_frame *product_frame_diag2 = NULL;
149static char vircam_linearity_analyse_description[] =
150"vircam_linearity_analyse -- VIRCAM linearity mapping recipe.\n\n"
151"Form master dark images from the input raw frames and use these to\n"
152"dark correct a series of dome flat exposures Using the dark\n"
153"corrected dome flat series, work out linearity coefficients for\n"
154"each data channel. The program expects the following files in the SOF\n"
156" -----------------------------------------------------------------------\n"
157" %-21s A list of raw dome flat images\n"
158" %-21s A list of raw dark images\n"
159" %-21s The channel table\n"
160" %-21s A list of raw dome flat images at the monitor exposure time\n"
161" %-21s A list of raw dark images at the monitor exposure time\n"
162"The first three of these are required. The last two are only required if"
163"the light source monitoring algorithm is to be used"
299int cpl_plugin_get_info(cpl_pluginlist *list) {
300 cpl_recipe *recipe = cpl_calloc(1,
sizeof(*recipe));
301 cpl_plugin *plugin = &recipe->interface;
302 char alldesc[SZ_ALLDESC];
303 (void)snprintf(alldesc,SZ_ALLDESC,vircam_linearity_analyse_description,
304 VIRCAM_LIN_DOME_RAW,VIRCAM_LIN_DARK_RAW,
305 VIRCAM_CAL_CHANTAB_INIT,VIRCAM_LIN_DOME_CHECK,
306 VIRCAM_LIN_DARK_CHECK);
308 cpl_plugin_init(plugin,
310 VIRCAM_BINARY_VERSION,
311 CPL_PLUGIN_TYPE_RECIPE,
312 "vircam_linearity_analyse",
313 "VIRCAM linearity analysis recipe",
318 vircam_linearity_analyse_create,
319 vircam_linearity_analyse_exec,
320 vircam_linearity_analyse_destroy);
322 cpl_pluginlist_append(list,plugin);
338static int vircam_linearity_analyse_create(cpl_plugin *plugin) {
344 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
345 recipe = (cpl_recipe *)plugin;
351 recipe->parameters = cpl_parameterlist_new();
355 p = cpl_parameter_new_range(
"vircam.vircam_linearity_analyse.norder",
357 "Order of polynomial fit",
358 "vircam.vircam_linearity_analyse",
360 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"nord");
361 cpl_parameterlist_append(recipe->parameters,p);
365 p = cpl_parameter_new_value(
"vircam.vircam_linearity_analyse.lthr",
367 "Lower bad pixel threshold",
368 "vircam.vircam_linearity_analyse",8.0);
369 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"lthr");
370 cpl_parameterlist_append(recipe->parameters,p);
374 p = cpl_parameter_new_value(
"vircam.vircam_linearity_analyse.hthr",
376 "Upper bad pixel threshold",
377 "vircam.vircam_linearity_analyse",8.0);
378 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"hthr");
379 cpl_parameterlist_append(recipe->parameters,p);
383 p = cpl_parameter_new_value(
"vircam.vircam_linearity_analyse.maxbpmfr",
385 "Maximum # frames used in bpm analysis",
386 "vircam.vircam_linearity_analyse",10);
387 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"maxbpmfr");
388 cpl_parameterlist_append(recipe->parameters,p);
393 p = cpl_parameter_new_value(
"vircam.vircam_linearity_analyse.adjust",
395 "Adjust stats with monitor set",
396 "vircam.vircam_linearity_analyse",1);
397 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"adjust");
398 cpl_parameterlist_append(recipe->parameters,p);
402 p = cpl_parameter_new_value(
"vircam.vircam_linearity_analyse.diagnostic",
404 "Write out diagnostic tables",
405 "vircam.vircam_linearity_analyse",0);
406 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"diagnostic");
407 cpl_parameterlist_append(recipe->parameters,p);
411 p = cpl_parameter_new_range(
"vircam.vircam_linearity_analyse.extenum",
413 "Extension number to be done, 0 == all",
414 "vircam.vircam_linearity_analyse",
416 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"ext");
417 cpl_parameterlist_append(recipe->parameters,p);
432static int vircam_linearity_analyse_exec(cpl_plugin *plugin) {
437 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
438 recipe = (cpl_recipe *)plugin;
442 return(vircam_linearity_analyse(recipe->parameters,recipe->frames));
453static int vircam_linearity_analyse_destroy(cpl_plugin *plugin) {
458 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
459 recipe = (cpl_recipe *)plugin;
463 cpl_parameterlist_delete(recipe->parameters);
476static int vircam_linearity_analyse(cpl_parameterlist *parlist,
477 cpl_frameset *framelist) {
478 const char *fctid=
"vircam_linearity_analyse";
479 int i,jst,jfn,j,status,k,nbad,ngood,krem,n;
480 int ndarks,ndomes,kk,live,ngood_flats,*bpm,nalloc,adjust,ndit;
483 float med,mindit,*exps,badfrac,expt;
484 unsigned char *rejmask,*rejplus;
485 double *dexps,**fdata,*d,*mjds,*mjdcheck,mjd,**cdata,*cf,fac;
486 double facrng,maxdiff,*lindata;
487 casu_fits **darks,**domes,*test,*outdark,*fframe;
490 cpl_propertylist *drs,*plist;
496 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
497 cpl_msg_error(fctid,
"Input framelist NULL or has no input data");
503 vircam_linearity_analyse_init();
507 p = cpl_parameterlist_find(parlist,
508 "vircam.vircam_linearity_analyse.norder");
509 vircam_linearity_analyse_config.norder = cpl_parameter_get_int(p);
510 p = cpl_parameterlist_find(parlist,
511 "vircam.vircam_linearity_analyse.lthr");
512 vircam_linearity_analyse_config.lthr = (float)cpl_parameter_get_double(p);
513 p = cpl_parameterlist_find(parlist,
514 "vircam.vircam_linearity_analyse.hthr");
515 vircam_linearity_analyse_config.hthr = (float)cpl_parameter_get_double(p);
516 p = cpl_parameterlist_find(parlist,
517 "vircam.vircam_linearity_analyse.maxbpmfr");
518 vircam_linearity_analyse_config.maxbpmfr = cpl_parameter_get_int(p);
519 p = cpl_parameterlist_find(parlist,
520 "vircam.vircam_linearity_analyse.adjust");
521 vircam_linearity_analyse_config.adjust = cpl_parameter_get_bool(p);
522 p = cpl_parameterlist_find(parlist,
523 "vircam.vircam_linearity_analyse.diagnostic");
524 vircam_linearity_analyse_config.diagnostic = cpl_parameter_get_bool(p);
525 p = cpl_parameterlist_find(parlist,
526 "vircam.vircam_linearity_analyse.extenum");
527 vircam_linearity_analyse_config.extenum = cpl_parameter_get_int(p);
532 cpl_msg_error(fctid,
"Cannot identify RAW and CALIB frames");
533 vircam_linearity_analyse_tidy(2);
541 cpl_msg_error(fctid,
"Cannot labelise the input frames");
542 vircam_linearity_analyse_tidy(2);
549 VIRCAM_LIN_DOME_RAW)) == NULL) {
550 cpl_msg_error(fctid,
"Cannot find dome flat frames in input frameset");
551 vircam_linearity_analyse_tidy(2);
554 ps.ndomes = cpl_frameset_get_size(ps.domelist);
555 ps.inherit = cpl_frameset_get_position(ps.domelist,0);
559 plist = cpl_propertylist_load(cpl_frame_get_filename(cpl_frameset_get_position(ps.domelist,0)),0);
561 freepropertylist(plist);
564 "NDIT=%" CPL_SIZE_FORMAT
". Recipe requires that ndit == 1",
566 vircam_linearity_analyse_tidy(2);
573 VIRCAM_LIN_DARK_RAW)) == NULL) {
574 cpl_msg_error(fctid,
"Cannot find dark frames in input frameset");
575 vircam_linearity_analyse_tidy(2);
578 ps.ndarks = cpl_frameset_get_size(ps.darklist);
583 if (vircam_linearity_analyse_config.adjust) {
585 VIRCAM_LIN_DOME_CHECK)) == NULL) {
586 cpl_msg_info(fctid,
"No monitor frames found in sof. No adjustments made to stats");
587 vircam_linearity_analyse_config.adjust = 0;
590 ps.ndomecheck = cpl_frameset_get_size(ps.domecheck);
592 nlab,VIRCAM_LIN_DARK_CHECK)) == NULL) {
593 cpl_msg_info(fctid,
"No darks for monitor frames found in sof. No adjustments made to stats");
594 vircam_linearity_analyse_config.adjust = 0;
596 freeframeset(ps.domecheck);
599 ps.ndarkcheck = cpl_frameset_get_size(ps.darkcheck);
607 VIRCAM_CAL_CHANTAB_INIT)) == NULL) {
608 cpl_msg_error(fctid,
"No initial channel table found");
609 vircam_linearity_analyse_tidy(2);
615 if (vircam_linearity_analyse_domedark_groups() != 0) {
616 vircam_linearity_analyse_tidy(2);
623 if (ps.nddg < vircam_linearity_analyse_config.norder+1) {
624 cpl_msg_warning(fctid,
625 "Number of exposure times is too small: %" CPL_SIZE_FORMAT
", order: %" CPL_SIZE_FORMAT
"\nTaking fit down to order %" CPL_SIZE_FORMAT,
627 (cpl_size)(vircam_linearity_analyse_config.norder),
628 (cpl_size)(ps.nddg-1));
629 vircam_linearity_analyse_config.norder = ps.nddg - 1;
637 (
const cpl_frame *)cpl_frameset_get_position(ps.ddg[0].darks,0),
639 if (jst == -1 || jfn == -1) {
640 cpl_msg_error(fctid,
"Unable to continue");
641 vircam_linearity_analyse_tidy(2);
647 for (j = jst; j <= jfn; j++) {
648 cpl_msg_info(fctid,
"Beginning BPM work on extension %" CPL_SIZE_FORMAT,
650 isfirst = (j == jst);
652 vircam_linearity_analyse_config.bad_pixel_stat = 0.0;
653 vircam_linearity_analyse_config.bad_pixel_num = 0;
654 vircam_linearity_analyse_config.linerror = 0.0;
655 vircam_linearity_analyse_config.linearity = 0.0;
656 vircam_linearity_analyse_config.facrng = 0.0;
657 vircam_linearity_analyse_config.maxdiff = 0.0;
661 test =
casu_fits_load(cpl_frameset_get_position(ps.ddg[0].domes,0),
673 if (ps.chantab == NULL) {
675 "Channel table extension %" CPL_SIZE_FORMAT
" failed to load",
678 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
684 "Channel table extension %" CPL_SIZE_FORMAT
" has errors",
687 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
694 "Channel table extension header %" CPL_SIZE_FORMAT
" missing saturation info",
697 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
699 vircam_linearity_analyse_tidy(1);
709 if (vircam_linearity_analyse_config.diagnostic) {
710 ps.diag1 = vircam_linearity_analyse_diagtab_init(np,ps.ndomes);
711 if (vircam_linearity_analyse_config.adjust)
712 ps.diag2 = vircam_linearity_analyse_diagtab_init(np,ps.ndomecheck);
719 cpl_msg_error(fctid,
"No DET LIVE keyword in this extension");
721 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
723 vircam_linearity_analyse_tidy(1);
728 cpl_msg_info(fctid,
"Detector flagged dead");
730 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
732 vircam_linearity_analyse_tidy(1);
741 &mindit) != CASU_OK) {
743 "No value of MINDIT found in extension %" CPL_SIZE_FORMAT,
746 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
757 exps = cpl_malloc(ps.nddg*
sizeof(
float));
759 for (i = 0; i < ps.nddg; i++) {
760 test =
casu_fits_load(cpl_frameset_get_position(ps.ddg[i].domes,0),
763 med *= (1.0 + mindit/ps.ddg[i].exptime);
765 ps.ddg[i].flag = SATURATE_FLAG;
768 exps[ngood-1] = ps.ddg[i].exptime;
769 ngood_flats += ps.ddg[i].ndomes;
770 ps.ddg[i].flag = OK_FLAG;
774 exps = cpl_realloc(exps,ngood*
sizeof(
float));
778 if (ngood < vircam_linearity_analyse_config.norder+1) {
780 "Too few unsaturated flats for linearity fit for extension %" CPL_SIZE_FORMAT,
784 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
797 ps.nuse = min(vircam_linearity_analyse_config.maxbpmfr,ngood_flats);
799 ps.flatlist = cpl_malloc(ps.nuse*
sizeof(casu_fits *));
800 for (i = ngood-1; i >= 0; i--) {
802 for (k = 0; k <= ps.nddg; k++) {
803 if (ps.ddg[k].exptime == exps[i]) {
812 ndarks = ps.ddg[krem].ndarks;
815 "Error loading darks extension %" CPL_SIZE_FORMAT
", exptime %g",
816 (cpl_size)j,ps.ddg[krem].exptime);
828 &outimage,NULL,&rejmask,&rejplus,&drs,
832 freepropertylist(drs);
833 if (status != CASU_OK) {
835 "Dark combine failure extension %" CPL_SIZE_FORMAT
" exposure %g",
836 (cpl_size)j,ps.ddg[krem].exptime);
837 freefitslist(darks,ndarks);
842 freefitslist(darks,ndarks);
847 ndomes = ps.ddg[krem].ndomes;
850 "Error loading domes extension %" CPL_SIZE_FORMAT
", exptime %g",
851 (cpl_size)j,ps.ddg[i].exptime);
859 for (kk = 0; kk < ndomes; kk++) {
863 ps.ddg[krem].proc[kk] = ps.flatlist[ps.nflatlist];
865 if (ps.nflatlist == ps.nuse)
871 freefitslist(domes,ndomes);
876 if (ps.nflatlist == ps.nuse)
880 ps.flatlist = cpl_realloc(ps.flatlist,
881 (ps.nflatlist)*
sizeof(casu_fits *));
887 vircam_linearity_analyse_config.lthr,
888 vircam_linearity_analyse_config.hthr,
"EXPTIME",
889 &(ps.bpm_array),&nbad,&badfrac,&status);
890 bpm = cpl_array_get_data_int(ps.bpm_array);
894 vircam_linearity_analyse_config.bad_pixel_num = nbad;
895 vircam_linearity_analyse_config.bad_pixel_stat = badfrac;
901 freespace(ps.flatlist);
907 fdata = cpl_malloc(nalloc*
sizeof(
double *));
908 dexps = cpl_malloc(nalloc*
sizeof(
double));
909 mjds = cpl_malloc(nalloc*
sizeof(
double));
916 "Beginning linearity work on extension %" CPL_SIZE_FORMAT,
920 for (i = 0; i < ps.nddg; i++) {
921 if (ps.ddg[i].flag == SATURATE_FLAG)
923 for (k = 0; k < ps.ddg[i].ndomes; k++) {
928 if (ps.ddg[i].proc[k] == NULL) {
929 if (outdark == NULL) {
935 ndarks = ps.ddg[i].ndarks;
938 "Error loading darks extension %" CPL_SIZE_FORMAT
", exptime %g",
939 (cpl_size)j,ps.ddg[i].exptime);
947 if (ps.ddg[i].ndarks == 1) {
952 "EXPTIME",&outimage,NULL,
957 freepropertylist(drs);
958 if (status != CASU_OK) {
960 "Dark combine failure extension %" CPL_SIZE_FORMAT
" exposure %g",
961 (cpl_size)j,ps.ddg[i].exptime);
962 freefitslist(darks,ndarks);
968 freefitslist(darks,ndarks);
973 frame = cpl_frameset_get_position(ps.ddg[i].domes,k);
980 fframe = ps.ddg[i].proc[k];
985 d = vircam_linearity_analyse_genstat(fframe,bpm,pp,np);
986 if (ps.nfdata >= nalloc) {
988 fdata = cpl_realloc(fdata,nalloc*
sizeof(
double *));
989 dexps = cpl_realloc(dexps,nalloc*
sizeof(
double));
990 mjds = cpl_realloc(mjds,nalloc*
sizeof(
double));
993 mjds[ps.nfdata] = mjd;
994 dexps[ps.nfdata] = (double)(ps.ddg[i].exptime);
995 fdata[ps.nfdata] = d;
1000 if (ps.diag1 != NULL) {
1001 cpl_table_set_string(ps.diag1,
"filename",
1002 (cpl_size)(ps.nfdata),
1004 cpl_table_set_double(ps.diag1,
"exptime",
1005 (cpl_size)ps.nfdata,
1007 cpl_table_set_double(ps.diag1,
"mjd",(cpl_size)(ps.nfdata),
1009 for (n = 1; n <= np; n++) {
1010 char * colname = cpl_sprintf(
"rawflux_%02d", n);
1012 cpl_table_set_double(ps.diag1,colname,
1013 (cpl_size)(ps.nfdata),d[n-1]);
1017 if (ps.ddg[i].proc[k] != NULL) {
1018 freefits(ps.ddg[i].proc[k]);
1027 if (ps.diag1 != NULL)
1028 cpl_table_set_size(ps.diag1,(cpl_size)(ps.nfdata));
1033 if (vircam_linearity_analyse_config.adjust) {
1037 cdata = cpl_malloc(ps.ndomecheck*
sizeof(
double *));
1046 med *= (1.0 + mindit/expt);
1049 cpl_msg_info(fctid,
"Monitor exposures saturated. No drift adjustment made");
1059 ndarks = ps.ndarkcheck;
1060 if (darks == NULL) {
1061 cpl_msg_error(fctid,
1062 "Error loading check darks extension %" CPL_SIZE_FORMAT,
1076 &outimage,NULL,&rejmask,&rejplus,
1080 freepropertylist(drs);
1081 if (status != CASU_OK) {
1082 cpl_msg_error(fctid,
1083 "Combine failure extension %" CPL_SIZE_FORMAT
" monitor",
1085 freefitslist(darks,ndarks);
1091 freefitslist(darks,ndarks);
1096 mjdcheck = cpl_malloc(ps.ndomecheck*
sizeof(
double));
1097 for (i = 0; i < ps.ndomecheck; i++) {
1098 frame = cpl_frameset_get_position(ps.domecheck,i);
1101 d = vircam_linearity_analyse_genstat(fframe,bpm,pp,np);
1109 if (ps.diag2 != NULL) {
1110 cpl_table_set_string(ps.diag2,
"filename",(cpl_size)i,
1112 cpl_table_set_double(ps.diag2,
"exptime",
1113 (cpl_size)i,(
double)expt);
1114 cpl_table_set_double(ps.diag2,
"mjd",
1116 for (n = 1; n <= np; n++) {
1117 char * colname = cpl_sprintf(
"rawflux_%02d", n);
1119 cpl_table_set_double(ps.diag2,colname,(cpl_size)i,
1122 colname = cpl_sprintf(
"linflux_%02d", n);
1124 cpl_table_set_double(ps.diag2,colname,(cpl_size)i,
1135 cf = vircam_linearity_tweakfac(cdata,mjdcheck,ps.ndomecheck,
1136 np,&facrng,&maxdiff);
1137 vircam_linearity_analyse_config.facrng = 100.0*(float)facrng;
1138 vircam_linearity_analyse_config.maxdiff = 100.0*(float)maxdiff;
1139 if (ps.diag2 != NULL) {
1140 for (i = 0; i < ps.ndomecheck; i++)
1141 cpl_table_set_double(ps.diag2,
"adjust_fac",
1148 for (i = 0; i < ps.nfdata; i++) {
1151 for (k = 0; k < ps.ndomecheck; k++) {
1152 if (mjd < mjdcheck[k]) {
1158 fac = cf[ps.ndomecheck-1];
1159 }
else if (krem == 0) {
1162 fac = 0.5*(cf[krem -1] + cf[krem]);
1164 for (k = 0; k < np; k++)
1166 if (ps.diag1 != NULL)
1167 cpl_table_set_double(ps.diag1,
"adjust_fac",
1173 freespace2(cdata,ps.ndomecheck);
1175 freespace(mjdcheck);
1190 vircam_linearity_analyse_config.norder,
1191 &(ps.lchantab),&lindata,&status);
1192 if (ps.diag1 != NULL) {
1193 for (i = 0; i < ps.nfdata; i++) {
1194 for (n = 0; n < np; n++) {
1195 char * colname = cpl_sprintf(
"linflux_%02d", n+1);
1197 cpl_table_set_double(ps.diag1,colname,
1198 (cpl_size)i,lindata[i*np+n]);
1203 freespace2(fdata,ps.nfdata);
1206 if (status != CASU_OK) {
1207 cpl_msg_error(fctid,
1208 "Linearity curve fit failed extension %" CPL_SIZE_FORMAT,
1211 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
1213 vircam_linearity_analyse_tidy(1);
1220 vircam_linearity_analyse_config.linearity =
1221 (float)cpl_table_get_column_mean(ps.lchantab,
"lin_10000");
1222 vircam_linearity_analyse_config.linerror =
1223 (float)cpl_table_get_column_mean(ps.lchantab,
"lin_10000_err");
1227 if (vircam_linearity_analyse_lastbit(j,framelist,parlist) != 0)
1233 vircam_linearity_analyse_tidy(2);
1247static int vircam_linearity_analyse_save(cpl_frameset *framelist,
1248 cpl_parameterlist *parlist) {
1249 cpl_propertylist *plist,*elist,*pafprop;
1251 const char *outtab =
"lchantab.fits";
1252 const char *outbpm =
"bpm.fits";
1253 const char *outtabpaf =
"lchantab";
1254 const char *outbpmpaf =
"bpm";
1255 const char *outdiag1 =
"ldiag1.fits";
1256 const char *outdiag2 =
"ldiag2.fits";
1257 const char *fctid =
"vircam_linearity_analyse_save";
1258 const char *recipeid =
"vircam_linearity_analyse";
1259 int nx,ny,nord,*bpm,i;
1263 nord = vircam_linearity_analyse_config.norder;
1268 product_frame_chantab = cpl_frame_new();
1269 cpl_frame_set_filename(product_frame_chantab,outtab);
1270 cpl_frame_set_tag(product_frame_chantab,VIRCAM_PRO_CHANTAB);
1271 cpl_frame_set_type(product_frame_chantab,CPL_FRAME_TYPE_TABLE);
1272 cpl_frame_set_group(product_frame_chantab,CPL_FRAME_GROUP_PRODUCT);
1273 cpl_frame_set_level(product_frame_chantab,CPL_FRAME_LEVEL_FINAL);
1277 ps.phupaf = vircam_paf_phu_items(ps.plist);
1278 plist = cpl_propertylist_duplicate(ps.plist);
1282 "PRO-1.15",ps.inherit,0);
1287 elist = cpl_propertylist_duplicate(ps.elist);
1288 cpl_propertylist_update_float(elist,
"ESO DET SATURATION",sat);
1290 framelist,parlist,(
char *)recipeid,
1291 "PRO-1.15",ps.inherit);
1294 if (isfinite(vircam_linearity_analyse_config.linearity)){
1295 cpl_propertylist_update_float(elist,
"ESO QC LINEARITY",
1296 vircam_linearity_analyse_config.linearity);
1298 cpl_propertylist_update_float(elist,
"ESO QC LINEARITY", 100.);
1300 cpl_propertylist_set_comment(elist,
"ESO QC LINEARITY",
1301 "% non-linearity at 10000 ADU");
1302 cpl_propertylist_update_float(elist,
"ESO QC LINERROR",
1303 vircam_linearity_analyse_config.linerror);
1304 cpl_propertylist_set_comment(elist,
"ESO QC LINERROR",
1305 "% error non-linearity at 10000 ADU");
1306 cpl_propertylist_update_float(elist,
"ESO QC SCREEN_TOTAL",
1307 vircam_linearity_analyse_config.facrng);
1308 cpl_propertylist_set_comment(elist,
"ESO QC SCREEN_TOTAL",
1309 "total % range in screen variation");
1310 cpl_propertylist_update_float(elist,
"ESO QC SCREEN_STEP",
1311 vircam_linearity_analyse_config.maxdiff);
1312 cpl_propertylist_set_comment(elist,
"ESO QC SCREEN_STEP",
1313 "maximum % step in screen variation");
1314 cpl_propertylist_update_int(elist,
"ESO PRO DATANCOM",ps.nfdata);
1320 if (ps.lchantab == NULL)
1326 if (cpl_table_save(ps.lchantab,plist,elist,outtab,CPL_IO_DEFAULT)
1327 != CPL_ERROR_NONE) {
1328 cpl_msg_error(fctid,
"Cannot save product table extension");
1329 freepropertylist(plist);
1330 freepropertylist(elist);
1333 cpl_frameset_insert(framelist,product_frame_chantab);
1337 pafprop = vircam_paf_req_items(elist);
1339 vircam_paf_append(pafprop,plist,
"ESO INS FILT1 NAME");
1340 vircam_paf_append(pafprop,elist,
"ESO PRO CATG");
1341 vircam_paf_append(pafprop,elist,
"ESO PRO DATANCOM");
1342 if (vircam_paf_print((
char *)outtabpaf,
"VIRCAM/vircam_linearity_analyse",
1343 "QC file",pafprop) != CASU_OK)
1344 cpl_msg_warning(fctid,
"Unable to save PAF for linearity table");
1345 cpl_propertylist_delete(pafprop);
1349 freepropertylist(plist);
1350 freepropertylist(elist);
1354 product_frame_bpm = cpl_frame_new();
1355 cpl_frame_set_filename(product_frame_bpm,outbpm);
1356 cpl_frame_set_tag(product_frame_bpm,VIRCAM_PRO_BPM);
1357 cpl_frame_set_type(product_frame_bpm,CPL_FRAME_TYPE_IMAGE);
1358 cpl_frame_set_group(product_frame_bpm,CPL_FRAME_GROUP_PRODUCT);
1359 cpl_frame_set_level(product_frame_bpm,CPL_FRAME_LEVEL_FINAL);
1366 (
char *)recipeid,
"PRO-1.15",
1371 if (cpl_image_save(NULL,outbpm,CPL_TYPE_UCHAR,plist,
1372 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
1373 cpl_msg_error(fctid,
"Cannot save product PHU");
1374 cpl_frame_delete(product_frame_bpm);
1377 cpl_frameset_insert(framelist,product_frame_bpm);
1382 if (ps.diag1 != NULL) {
1386 product_frame_diag1 = cpl_frame_new();
1387 cpl_frame_set_filename(product_frame_diag1,outdiag1);
1388 cpl_frame_set_tag(product_frame_diag1,VIRCAM_PRO_LIN_DIAG1);
1389 cpl_frame_set_type(product_frame_diag1,CPL_FRAME_TYPE_TABLE);
1390 cpl_frame_set_group(product_frame_diag1,CPL_FRAME_GROUP_PRODUCT);
1391 cpl_frame_set_level(product_frame_diag1,CPL_FRAME_LEVEL_FINAL);
1395 plist = cpl_propertylist_duplicate(ps.plist);
1399 "PRO-1.15",ps.inherit,0);
1404 elist = cpl_propertylist_duplicate(ps.elist);
1407 (
char *)recipeid,
"PRO-1.15",
1417 if (cpl_table_save(ps.diag1,plist,elist,outdiag1,CPL_IO_DEFAULT)
1418 != CPL_ERROR_NONE) {
1419 cpl_msg_error(fctid,
"Cannot save product table extension");
1420 freepropertylist(plist);
1421 freepropertylist(elist);
1424 cpl_frameset_insert(framelist,product_frame_diag1);
1425 freepropertylist(plist);
1426 freepropertylist(elist);
1431 if (ps.diag2 != NULL) {
1435 product_frame_diag2 = cpl_frame_new();
1436 cpl_frame_set_filename(product_frame_diag2,outdiag2);
1437 cpl_frame_set_tag(product_frame_diag2,VIRCAM_PRO_LIN_DIAG2);
1438 cpl_frame_set_type(product_frame_diag2,CPL_FRAME_TYPE_TABLE);
1439 cpl_frame_set_group(product_frame_diag2,CPL_FRAME_GROUP_PRODUCT);
1440 cpl_frame_set_level(product_frame_diag2,CPL_FRAME_LEVEL_FINAL);
1444 plist = cpl_propertylist_duplicate(ps.plist);
1448 "PRO-1.15",ps.inherit,0);
1453 elist = cpl_propertylist_duplicate(ps.elist);
1456 (
char *)recipeid,
"PRO-1.15",
1466 if (cpl_table_save(ps.diag2,plist,elist,outdiag2,CPL_IO_DEFAULT)
1467 != CPL_ERROR_NONE) {
1468 cpl_msg_error(fctid,
"Cannot save product table extension");
1469 freepropertylist(plist);
1470 freepropertylist(elist);
1473 cpl_frameset_insert(framelist,product_frame_diag2);
1474 freepropertylist(plist);
1475 freepropertylist(elist);
1484 elist = cpl_propertylist_duplicate(ps.elist);
1485 cpl_propertylist_update_float(elist,
"ESO DET SATURATION",sat);
1489 "PRO-1.15",ps.inherit);
1492 if (isnormal(vircam_linearity_analyse_config.linearity)){
1493 cpl_propertylist_update_float(elist,
"ESO QC LINEARITY",
1494 vircam_linearity_analyse_config.linearity);
1496 cpl_propertylist_update_float(elist,
"ESO QC LINEARITY", 100.);
1499 cpl_propertylist_set_comment(elist,
"ESO QC LINEARITY",
1500 "% non-linearity at 10000 ADU");
1501 cpl_propertylist_update_float(elist,
"ESO QC LINERROR",
1502 vircam_linearity_analyse_config.linerror);
1503 cpl_propertylist_set_comment(elist,
"ESO QC LINERROR",
1504 "% error non-linearity at 10000 ADU");
1505 cpl_propertylist_update_float(elist,
"ESO QC SCREEN_TOTAL",
1506 vircam_linearity_analyse_config.facrng);
1507 cpl_propertylist_set_comment(elist,
"ESO QC SCREEN_TOTAL",
1508 "total % range in screen variation");
1509 cpl_propertylist_update_float(elist,
"ESO QC SCREEN_STEP",
1510 vircam_linearity_analyse_config.maxdiff);
1511 cpl_propertylist_set_comment(elist,
"ESO QC SCREEN_STEP",
1512 "maximum % step in screen variation");
1513 cpl_propertylist_update_int(elist,
"ESO PRO DATANCOM",ps.nfdata);
1519 if (ps.lchantab == NULL)
1525 if (cpl_table_save(ps.lchantab,NULL,elist,outtab,CPL_IO_EXTEND)
1526 != CPL_ERROR_NONE) {
1527 cpl_msg_error(fctid,
"Cannot save product table extension");
1528 freepropertylist(elist);
1534 pafprop = vircam_paf_req_items(elist);
1536 vircam_paf_append(pafprop,ps.plist,
"ESO INS FILT1 NAME");
1537 vircam_paf_append(pafprop,elist,
"ESO PRO CATG");
1538 vircam_paf_append(pafprop,elist,
"ESO PRO DATANCOM");
1539 if (vircam_paf_print((
char *)outtabpaf,
"VIRCAM/vircam_linearity_analyse",
1540 "QC file",pafprop) != CASU_OK)
1541 cpl_msg_warning(fctid,
"Unable to save PAF for BPM");
1542 cpl_propertylist_delete(pafprop);
1546 freepropertylist(elist);
1550 if (ps.diag1 != NULL) {
1551 elist = cpl_propertylist_duplicate(ps.elist);
1554 (
char *)recipeid,
"PRO-1.15",
1564 if (cpl_table_save(ps.diag1,NULL,elist,outdiag1,CPL_IO_EXTEND)
1565 != CPL_ERROR_NONE) {
1566 cpl_msg_error(fctid,
"Cannot save product table extension");
1567 freepropertylist(elist);
1570 freepropertylist(elist);
1572 if (ps.diag2 != NULL) {
1573 elist = cpl_propertylist_duplicate(ps.elist);
1576 (
char *)recipeid,
"PRO-1.15",
1586 if (cpl_table_save(ps.diag2,NULL,elist,outdiag2,CPL_IO_EXTEND)
1587 != CPL_ERROR_NONE) {
1588 cpl_msg_error(fctid,
"Cannot save product table extension");
1589 freepropertylist(elist);
1592 freepropertylist(elist);
1602 if (dummy && ps.bpm_array == NULL) {
1603 ps.bpm_array = cpl_array_new((cpl_size)(nx*ny),CPL_TYPE_INT);
1604 bpm = cpl_array_get_data_int(ps.bpm_array);
1605 for (i = 0; i < nx*ny; i++)
1608 bpm = cpl_array_get_data_int(ps.bpm_array);
1610 framelist,parlist,(
char *)recipeid,
1611 "PRO-1.15",ps.inherit);
1612 cpl_propertylist_update_float(plist,
"ESO QC BAD_PIXEL_STAT",
1613 vircam_linearity_analyse_config.bad_pixel_stat);
1614 cpl_propertylist_set_comment(plist,
"ESO QC BAD_PIXEL_STAT",
1615 "Fraction of pixels that are bad");
1616 cpl_propertylist_update_int(plist,
"ESO QC BAD_PIXEL_NUM",
1617 vircam_linearity_analyse_config.bad_pixel_num);
1618 cpl_propertylist_set_comment(plist,
"ESO QC BAD_PIXEL_NUM",
1619 "Number of pixels that are bad");
1620 cpl_propertylist_update_int(plist,
"ESO PRO DATANCOM",ps.nuse);
1623 outimg = cpl_image_wrap_int((cpl_size)nx,(cpl_size)ny,bpm);
1624 if (cpl_image_save(outimg,outbpm,CPL_TYPE_UCHAR,plist,
1625 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
1626 cpl_msg_error(fctid,
"Cannot save product image extension");
1632 pafprop = vircam_paf_req_items(plist);
1634 vircam_paf_append(pafprop,ps.plist,
"ESO INS FILT1 NAME");
1635 vircam_paf_append(pafprop,ps.plist,
"ESO PRO CATG");
1636 vircam_paf_append(pafprop,plist,
"ESO PRO DATANCOM");
1637 if (vircam_paf_print((
char *)outbpmpaf,
"VIRCAM/vircam_linearity_analyse",
1638 "QC file",pafprop) != CASU_OK)
1639 cpl_msg_warning(fctid,
"Unable to save PAF for linearity table");
1640 cpl_propertylist_delete(pafprop);
1644 cpl_image_unwrap(outimg);
1659static int vircam_linearity_analyse_lastbit(
int jext, cpl_frameset *framelist,
1660 cpl_parameterlist *parlist) {
1662 const char *fctid =
"vircam_linearity_analyse_lastbit";
1667 "Saving linearity table and bpm for extension %" CPL_SIZE_FORMAT,
1669 retval = vircam_linearity_analyse_save(framelist,parlist);
1671 vircam_linearity_analyse_tidy(2);
1677 vircam_linearity_analyse_tidy(1);
1687static int vircam_linearity_analyse_domedark_groups(
void) {
1691 cpl_propertylist *plist;
1692 const char *fctid =
"vircam_linearity_analyse_domedark_groups";
1696 ps.ddg = cpl_calloc(ps.ndomes,
sizeof(ddgrp));
1702 for (i = 0; i < ps.ndomes; i++) {
1703 frame = cpl_frameset_get_position(ps.domelist,i);
1704 plist = cpl_propertylist_load(cpl_frame_get_filename(frame),0);
1706 cpl_msg_warning(fctid,
"No exposure time found in %s",
1707 cpl_frame_get_filename(frame));
1708 cpl_propertylist_delete(plist);
1711 cpl_propertylist_delete(plist);
1718 for (j = 0; j < ps.nddg; j++) {
1719 if (ps.ddg[j].exptime == texp) {
1725 cpl_frameset_insert(ps.ddg[j].domes,cpl_frame_duplicate(frame));
1726 ps.ddg[j].ndomes += 1;
1728 ps.ddg[ps.nddg].exptime = texp;
1729 ps.ddg[ps.nddg].darks = cpl_frameset_new();
1730 ps.ddg[ps.nddg].domes = cpl_frameset_new();
1731 ps.ddg[ps.nddg].ndarks = 0;
1732 ps.ddg[ps.nddg].ndomes = 1;
1733 ps.ddg[ps.nddg].flag = OK_FLAG;
1734 cpl_frameset_insert(ps.ddg[ps.nddg].domes,
1735 cpl_frame_duplicate(frame));
1742 for (i = 0; i < ps.ndarks; i++) {
1743 frame = cpl_frameset_get_position(ps.darklist,i);
1744 plist = cpl_propertylist_load(cpl_frame_get_filename(frame),0);
1746 cpl_msg_warning(fctid,
"No exposure time found in %s",
1747 cpl_frame_get_filename(frame));
1748 cpl_propertylist_delete(plist);
1751 cpl_propertylist_delete(plist);
1758 for (j = 0; j < ps.nddg; j++) {
1759 if (ps.ddg[j].exptime == texp) {
1765 cpl_frameset_insert(ps.ddg[j].darks,cpl_frame_duplicate(frame));
1766 ps.ddg[j].ndarks += 1;
1774 while (i < ps.nddg) {
1775 if (ps.ddg[i].ndarks == 0) {
1776 cpl_msg_warning(fctid,
1777 "No dark frames exist for exposure %g\nThrowing these away",
1779 freeframeset(ps.ddg[i].darks);
1780 freeframeset(ps.ddg[i].domes);
1781 for (j = i+1; j < ps.nddg; j++)
1782 ps.ddg[j-1] = ps.ddg[j];
1790 for (i = 0; i < ps.nddg; i++) {
1791 ps.ddg[i].proc = cpl_malloc(ps.ddg[i].ndomes*
sizeof(casu_fits *));
1792 for (j = 0; j < ps.ddg[i].ndomes; j++)
1793 ps.ddg[i].proc[j] = NULL;
1800 ps.ddg = cpl_realloc(ps.ddg,ps.nddg*
sizeof(ddgrp));
1803 cpl_msg_error(fctid,
"There are no darks defined for input domes");
1819static double *vircam_linearity_analyse_genstat(casu_fits *fframe,
int *bpm,
1820 parquet *p,
int np) {
1821 int i,ist,ifn,jst,jfn,n,jind2,iind2,jj,nx,ii;
1828 d = cpl_malloc(np*
sizeof(
double));
1837 tmp = cpl_malloc(SUBSET*SUBSET*
sizeof(
float));
1841 for (i = 0; i < np; i++) {
1846 ist = ((pp->delta_i)/2 - SUBSET2);
1847 ifn = ist + SUBSET - 1;
1848 jst = ((pp->delta_j)/2 - SUBSET2);
1849 jfn = jst + SUBSET - 1;
1854 for (jj = jst; jj <= jfn; jj++) {
1855 jind2 = (jj + pp->iymin - 1)*nx;
1856 for (ii = ist; ii <= ifn; ii++) {
1857 iind2 = jind2 + ii + pp->ixmin - 1;
1858 if (bpm[iind2] == 0)
1859 tmp[n++] = data[iind2];
1862 d[i] = (double)
casu_med(tmp,NULL,(
long)n);
1885static double *vircam_linearity_tweakfac(
double **fdata,
double *mjd,
int nim,
1886 int nchan,
double *facrng,
1889 double *factors,sum,midval,minfac,maxfac;
1893 factors = cpl_malloc(nim*
sizeof(
double));
1897 vircam_mjdsort(fdata,mjd,nim);
1911 for (i = 0; i < nchan; i++) {
1915 midval = 0.5*(fdata[ist][i] + fdata[ifn][i]);
1919 for (j = 0; j < nim; j++)
1920 fdata[j][i] /= midval;
1929 for (j = 0; j < nim; j++) {
1931 for (i = 0; i < nchan; i++)
1933 factors[j] = sum/(double)nchan;
1935 maxfac = factors[j];
1936 minfac = factors[j];
1938 minfac = min(minfac,factors[j]);
1939 maxfac = max(maxfac,factors[j]);
1940 *maxdiff = max(*maxdiff,fabs(factors[j]-factors[j-1]));
1943 *facrng = maxfac - minfac;
1960static void vircam_mjdsort(
double **fdata,
double *mjd,
int n) {
1961 int iii,ii,i,ifin,j;
1962 double tmpmjd,*tmpdata;
1968 iii = min(n,(3*iii)/4 - 1);
1973 for (ii = 0; ii < ifin; ii++) {
1976 if (mjd[i] > mjd[j]) {
1981 fdata[j] = fdata[i];
1984 if (i < 0 || mjd[0] <= tmpmjd)
2003static cpl_table *vircam_linearity_analyse_diagtab_init(
int np,
int nrows) {
2009 t = cpl_table_new(nrows);
2013 cpl_table_new_column(t,
"filename",CPL_TYPE_STRING);
2014 cpl_table_new_column(t,
"exptime",CPL_TYPE_DOUBLE);
2015 cpl_table_set_column_unit(t,
"exptime",
"seconds");
2016 cpl_table_new_column(t,
"mjd",CPL_TYPE_DOUBLE);
2017 cpl_table_set_column_unit(t,
"mjd",
"days");
2022 for (i = 1; i <= np; i++) {
2023 char * colname = cpl_sprintf(
"rawflux_%02d", i);
2025 cpl_table_new_column(t,colname,CPL_TYPE_DOUBLE);
2026 cpl_table_set_column_unit(t,colname,
"ADU");
2028 colname = cpl_sprintf(
"linflux_%02d", i);
2030 cpl_table_new_column(t,colname,CPL_TYPE_DOUBLE);
2031 cpl_table_set_column_unit(t,colname,
"ADU");
2037 cpl_table_new_column(t,
"adjust_fac",CPL_TYPE_DOUBLE);
2050static void vircam_linearity_analyse_init(
void) {
2054 ps.domecheck = NULL;
2055 ps.darkcheck = NULL;
2064 ps.bpm_array = NULL;
2080static void vircam_linearity_analyse_tidy(
int level) {
2083 freetfits(ps.chantab);
2084 freearray(ps.bpm_array);
2085 freefitslist(ps.flatlist,ps.nflatlist);
2086 freetable(ps.lchantab);
2087 freepropertylist(ps.plist);
2088 freepropertylist(ps.elist);
2089 freetable(ps.diag1);
2090 freetable(ps.diag2);
2094 freespace(ps.labels);
2095 freeframeset(ps.domelist);
2096 freeframeset(ps.darklist);
2097 freeframeset(ps.domecheck);
2098 freeframeset(ps.darkcheck);
2099 freeframe(ps.chanfrm);
2100 if (ps.ddg != NULL) {
2101 for (i = 0; i < ps.nddg; i++) {
2102 freeframeset(ps.ddg[i].darks);
2103 freeframeset(ps.ddg[i].domes);
2104 freefitslist(ps.ddg[i].proc,ps.ddg[i].ndomes);
2108 freepropertylist(ps.phupaf);
casu_fits * casu_fits_wrap(cpl_image *im, casu_fits *model, cpl_propertylist *phu, cpl_propertylist *ehu)
cpl_image * casu_fits_get_image(casu_fits *p)
casu_fits ** casu_fits_load_list(cpl_frameset *f, cpl_type type, int exten)
void casu_fits_delete(casu_fits *p)
casu_fits * casu_fits_duplicate(casu_fits *in)
cpl_propertylist * casu_fits_get_phu(casu_fits *p)
char * casu_fits_get_filename(casu_fits *p)
cpl_propertylist * casu_fits_get_ehu(casu_fits *p)
casu_fits * casu_fits_load(cpl_frame *frame, cpl_type type, int nexten)
int casu_imcombine(casu_fits **fset, casu_fits **fsetv, int nfits, int combtype, int scaletype, int xrej, float thresh, const char *expkey, cpl_image **outimage, cpl_image **outvimage, unsigned char **rejmask, unsigned char **rejplus, cpl_propertylist **drs, int *status)
Stack images into a mean or median image with rejection.
int casu_darkcor(casu_fits *infile, casu_fits *darksrc, float darkscl, int *status)
Correct input data for dark current.
int casu_genbpm(casu_fits **flatlist, int nflatlist, cpl_image *master, float lthr, float hthr, const char *expkey, cpl_array **bpm_array, int *nbad, float *badfrac, int *status)
Generate a bad pixel mask from a list of dome flats.
float casu_med(float *data, unsigned char *bpm, long npts)
cpl_propertylist * casu_tfits_get_ehu(casu_tfits *p)
casu_tfits * casu_tfits_load(cpl_frame *table, int nexten)
cpl_table * casu_tfits_get_table(casu_tfits *p)
int casu_compare_tags(const cpl_frame *frame1, const cpl_frame *frame2)
Compare input tags.
void casu_merge_propertylists(cpl_propertylist *p1, cpl_propertylist *p2)
Merge two propertylists.
void casu_dummy_property(cpl_propertylist *p)
Set dummy property keyword.
cpl_frame * casu_frameset_subgroup_1(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
Extract a frame of a given label from a frameset.
void casu_sort(float **a, int n, int m)
Sort a 2d array by the first column and co-sort the rest.
cpl_frameset * casu_frameset_subgroup(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
Extract a frameset from another frameset.
int vircam_genlincur(double **fdata, int nimages, double *exps, double mindit, casu_tfits *chantab, int norder, cpl_table **lchantab, double **lindata, int *status)
Generate a linearity curve for each readout channel in a list of images.
cpl_table * vircam_chantab_new(int nord, cpl_table *template)
int vircam_chantab_verify(cpl_table *intab)
int vircam_chan_fill(cpl_table *tab, parquet **p, long *np)
void vircam_chan_free(int np, parquet **p)
int vircam_dfs_set_groups(cpl_frameset *set)
void vircam_dfs_set_product_primary_header(cpl_propertylist *plist, cpl_frame *frame, cpl_frameset *frameset, cpl_parameterlist *parlist, char *recipeid, const char *dict, cpl_frame *inherit, int synch)
void vircam_dfs_set_product_exten_header(cpl_propertylist *plist, cpl_frame *frame, cpl_frameset *frameset, cpl_parameterlist *parlist, char *recipeid, const char *dict, cpl_frame *inherit)
int vircam_pfits_get_ndit(const cpl_propertylist *plist, int *ndit)
Get the value of NDIT.
int vircam_pfits_get_mjd(const cpl_propertylist *plist, double *mjd)
Get the value of the modified Julian date.
int vircam_pfits_get_detlive(const cpl_propertylist *plist, int *detlive)
Get the value of DET_LIVE.
int vircam_pfits_get_exptime(const cpl_propertylist *plist, float *exptime)
Get the value of exposure time.
int vircam_pfits_get_mindit(const cpl_propertylist *plist, float *mindit)
Get the value of mindit time.
int vircam_pfits_get_saturation(const cpl_propertylist *plist, float *saturation)
Get the saturation level for this detector.
const char * vircam_get_license(void)
void vircam_exten_range(int inexten, const cpl_frame *fr, int *out1, int *out2)