41#include <casu_utils.h>
44#include <casu_wcsutils.h>
45#include <casu_stats.h>
49#include "vircam_utils.h"
50#include "vircam_pfits.h"
51#include "vircam_dfs.h"
52#include "vircam_mods.h"
53#include "vircam_paf.h"
54#include "vircam_sky.h"
57 cpl_frameset *contrib;
66 cpl_frameset *current;
69 casu_fits *stack[VIRCAM_NEXTN];
70 casu_fits *stackc[VIRCAM_NEXTN];
71 casu_tfits *cat[VIRCAM_NEXTN];
72 casu_tfits *mstds[VIRCAM_NEXTN];
73 cpl_frame *product_frame_im;
74 cpl_frame *product_frame_conf;
75 cpl_frame *product_frame_cat;
133 cpl_frame *master_dark;
134 cpl_frame *master_twilight_flat;
135 cpl_frame *master_conf;
136 cpl_frame *master_sky;
137 cpl_frame *master_objmask;
142 cpl_frame *readgain_file;
143 cpl_frameset *science_frames;
144 cpl_frameset *offset_skies;
145 cpl_frame **product_frames_simple;
146 cpl_frame **product_frames_simple_off;
147 cpl_propertylist *phupaf;
152 pawprint *science_paws;
154 pawprint *offsky_paws;
166 casu_tfits *fchantab;
169 casu_fits **sci_fits;
171 casu_fits **offsky_fits;
189#define PAWSKY_MASK_PRE 2
191#define TILESKY_MINUS 4
193#define PAWSKY_MINUS 6
195#define VMCPROJ "179.B-2003"
196#define VIDEOPROJ "179.A-2006"
198#define freepaws(_p,_n) if (_p != NULL) {vircam_sci_paws_delete(_n,&(_p)); _p = NULL; _n = 0;}
200char current_cat[VIRCAM_PATHSZ];
201char current_catpath[VIRCAM_PATHSZ];
202char vircam_recipename[VIRCAM_PATHSZ];
203char vircam_recipepaf[VIRCAM_PATHSZ];
204cpl_propertylist *dummyqc = NULL;
209static int vircam_science_process_create(cpl_plugin *plugin);
210static int vircam_science_process_exec(cpl_plugin *plugin);
211static int vircam_science_process_destroy(cpl_plugin *plugin);
212static int vircam_science_process(cpl_parameterlist *parlist,
213 cpl_frameset *framelist);
217static void vircam_sci_paw_init(pawprint *paw, cpl_frameset *frms,
int ispj,
219static void vircam_sci_paw_delete(pawprint *paws);
220static void vircam_sci_paws_delete(
int npaws, pawprint **paws);
221static void vircam_sci_paws_create(cpl_frameset *infrms,
int *npaws,
226static int vircam_sci_sky_stripe_wcs(
int npaw, pawprint *paw,
const char *tag,
227 cpl_frameset *framelist,
228 cpl_parameterlist *parlist,
int destripe);
229static void vircam_sci_cat(pawprint *paw,
int extn);
230static void vircam_sci_stack(pawprint *paw,
int extn);
231static void vircam_sci_wcsfit(casu_fits **in, casu_fits **conf,
232 casu_tfits **incat,
int nf,
int level);
233static void vircam_sci_init(
void);
234static void vircam_sci_tidy(
int level);
235static int vircam_destripe_four(casu_fits **curfits,
int stripefilt,
237static void stripe_profile(casu_fits *in,
int stripefilt,
float *profile,
238 unsigned char *pbpm);
239static void vircam_sci_photcal(pawprint *paw);
243static void vircam_sci_choose_skyalgo(
int *nskys, skystruct **skys);
244static int vircam_sci_makesky(cpl_frameset *framelist,
245 cpl_parameterlist *parlist, skystruct *sky,
247static void vircam_sci_assign_sky_all(pawprint paw,
int whichone);
248static skystruct vircam_sci_crsky(
int algorithm, cpl_frameset *frms,
249 cpl_frame *
template,
int snum);
250static void vircam_sci_skydefine(
void);
251static int vircam_sci_tilesky(cpl_frameset *framelist,
252 cpl_parameterlist *parlist, cpl_frameset *in,
254 char *fname, cpl_frame **product_frame);
255static int vircam_sci_pawsky_mask(cpl_frameset *framelist,
256 cpl_parameterlist *parlist,
int algo,
257 cpl_frameset *contrib, cpl_frame *
template,
258 char *fname, cpl_frame **product_frame);
259static int vircam_sci_tilesky_minus(cpl_frameset *framelist,
260 cpl_parameterlist *parlist,
261 cpl_frameset *in, cpl_frame *
template,
262 const char *tag,
char *fname,
263 cpl_frame **skyframe);
264static int vircam_sci_pawsky_minus(cpl_frameset *framelist,
265 cpl_parameterlist *parlist,
266 cpl_frameset *in, cpl_frame *
template,
267 const char *tag,
char *skyname,
268 cpl_frame **skyframe);
272static cpl_frame *vircam_sci_findtemplate(cpl_frame *in);
273static int vircam_sci_istile(cpl_frame *frm);
274static int vircam_sci_ispj(cpl_frameset *frms);
275static int vircam_sci_cmp_jit(
const cpl_frame *frame1,
276 const cpl_frame *frame2);
277static int vircam_sci_cmp_tstart(
const cpl_frame *frame1,
278 const cpl_frame *frame2);
279static int vircam_sci_cmp_property(
const cpl_property *p1,
280 const cpl_property *p2);
281static cpl_frameset *vircam_sci_merge_framesets(
int n, cpl_frameset **in);
282static cpl_frameset *vircam_sci_update_frameset(cpl_frameset *frms,
int *nfrms_tot);
283static int vircam_sci_testfrms(cpl_frameset *frms,
int nextn_expected,
285static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg);
286static void vircam_sci_get_readnoise_gain(
int jext,
float *readnoise,
288static void vircam_sci_product_name(
char *
template,
int producttype,
289 int nametype,
int fnumber,
char *outfname);
293static int vircam_sci_save_simple(casu_fits *obj, cpl_frameset *framelist,
294 cpl_parameterlist *parlist,
int isprod,
295 cpl_frame *
template,
int isfirst,
296 const char *tag,
char *fname,
297 cpl_frame **product_frame);
298static int vircam_sci_save_sky(casu_fits *outsky, cpl_frameset *framelist,
299 cpl_parameterlist *parlist,
300 char *fname, cpl_frame *
template,
int isfirst,
301 cpl_frame **product_frame);
302static int vircam_sci_save_stack(casu_fits *stack, cpl_frameset *framelist,
303 cpl_parameterlist *parlist,
304 cpl_frame *
template,
int fnametype,
305 int stack_num, cpl_frame **product_frame);
306static int vircam_sci_save_stack_conf(casu_fits *stack, cpl_frameset *framelist,
307 cpl_parameterlist *parlist,
308 cpl_frame *
template,
int fnametype,
309 int stack_num, cpl_frame **product_frame);
310static int vircam_sci_save_stack_cat(casu_tfits *stack, cpl_frameset *framelist,
311 cpl_parameterlist *parlist,
312 cpl_frame *
template,
int fnametype,
313 int stack_num, cpl_frame **product_frame);
316static char vircam_science_process_description[] =
317"vircam_science_process -- VIRCAM science product recipe.\n\n"
318"Process a complete pawprint for VIRCAM data. Remove instrumental\n"
319"signature, background correct, combine jitters, photometrically\n"
320"and astrometrically calibrate the pawprint image\n\n"
321"The program accepts the following files in the SOF:\n\n"
323" -----------------------------------------------------------------------\n"
324" %-22s A list of raw science images or\n"
325" %-22s A list of raw science images (extended)\n"
326" %-22s A list of offset sky exposures (optional)\n"
327" %-22s A master dark frame\n"
328" %-22s A master object mask (optional)\n"
329" %-22s A master twilight flat frame\n"
330" %-22s A master sky frame (optional)\n"
331" %-22s A channel table\n"
332" %-22s A photometric calibration table\n"
333" %-22s A readnoise/gain file\n"
334" %-22s A master confidence map\n"
335" %-22s A master standard star index\n"
336" %-22s Northern Schlegel Map\n"
337" %-22s Southern Schlegel Map\n"
338"All of the above are required unless otherwise specified\n"
534int cpl_plugin_get_info(cpl_pluginlist *list) {
535 cpl_recipe *recipe = cpl_calloc(1,
sizeof(*recipe));
536 cpl_plugin *plugin = &recipe->interface;
537 char alldesc[SZ_ALLDESC];
538 (void)snprintf(alldesc,SZ_ALLDESC,
539 vircam_science_process_description,
540 VIRCAM_SCI_OBJECT_RAW,VIRCAM_SCI_OBJECT_EXT_RAW,
541 VIRCAM_OFFSET_SKY_RAW,VIRCAM_CAL_DARK,VIRCAM_CAL_OBJMASK,
542 VIRCAM_CAL_TWILIGHT_FLAT,VIRCAM_CAL_SKY,VIRCAM_CAL_CHANTAB,
543 VIRCAM_CAL_PHOTTAB,VIRCAM_CAL_READGAINFILE,VIRCAM_CAL_CONF,
544 VIRCAM_CAL_2MASS,VIRCAM_CAL_SCHL_N,VIRCAM_CAL_SCHL_S);
546 cpl_plugin_init(plugin,
548 VIRCAM_BINARY_VERSION,
549 CPL_PLUGIN_TYPE_RECIPE,
550 "vircam_science_process",
551 "VIRCAM science recipe",
556 vircam_science_process_create,
557 vircam_science_process_exec,
558 vircam_science_process_destroy);
560 cpl_pluginlist_append(list,plugin);
576static int vircam_science_process_create(cpl_plugin *plugin) {
582 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
583 recipe = (cpl_recipe *)plugin;
589 recipe->parameters = cpl_parameterlist_new();
593 p = cpl_parameter_new_value(
"vircam.vircam_science_process.destripe",
594 CPL_TYPE_BOOL,
"Destripe images?",
595 "vircam.vircam_science_process",TRUE);
596 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"destripe");
597 cpl_parameterlist_append(recipe->parameters,p);
601 p = cpl_parameter_new_enum(
"vircam.vircam_science_process.skyalgo",
602 CPL_TYPE_STRING,
"Sky subtraction algorithm",
603 "vircam.vircam_science_process",
"auto",8,
604 "master",
"none",
"pawsky_mask",
"pawsky_mask_pre",
605 "tilesky",
"tilesky_minus",
"auto",
"pawsky_minus");
606 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"skyalgo");
607 cpl_parameterlist_append(recipe->parameters,p);
612 p = cpl_parameter_new_value(
"vircam.vircam_science_process.preview_only",
613 CPL_TYPE_BOOL,
"Preview only?",
614 "vircam.vircam_science_process",FALSE);
615 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"preview_only");
616 cpl_parameterlist_append(recipe->parameters,p);
621 p = cpl_parameter_new_range(
"vircam.vircam_science_process.minphotom",
623 "Minimum stars for photometry solution",
624 "vircam.vircam_science_process",1,1,100000);
625 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"minphotom");
626 cpl_parameterlist_append(recipe->parameters,p);
631 p = cpl_parameter_new_value(
"vircam.vircam_science_process.prettynames",
632 CPL_TYPE_BOOL,
"Use pretty product names?",
633 "vircam.vircam_science_process",FALSE);
634 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"prettynames");
635 cpl_parameterlist_append(recipe->parameters,p);
639 p = cpl_parameter_new_value(
"vircam.vircam_science_process.cdssearch",
640 CPL_TYPE_BOOL,
"Use CDS for 2MASS standards?",
641 "vircam.vircam_science_process",FALSE);
642 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cdssearch");
643 cpl_parameterlist_append(recipe->parameters,p);
649 p = cpl_parameter_new_range(
"vircam.vircam_science_process.stk_cat_ipix",
651 "Minimum pixel area for each detected object",
652 "vircam.vircam_science_process",5,1,
654 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_ipix");
655 cpl_parameterlist_append(recipe->parameters,p);
659 p = cpl_parameter_new_range(
"vircam.vircam_science_process.stk_cat_thresh",
661 "Detection threshold in sigma above sky",
662 "vircam.vircam_science_process",2.0,1.0e-6,
664 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_thresh");
665 cpl_parameterlist_append(recipe->parameters,p);
669 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_cat_icrowd",
670 CPL_TYPE_BOOL,
"Use deblending?",
671 "vircam.vircam_science_process",TRUE);
672 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_icrowd");
673 cpl_parameterlist_append(recipe->parameters,p);
677 p = cpl_parameter_new_range(
"vircam.vircam_science_process.stk_cat_rcore",
678 CPL_TYPE_DOUBLE,
"Value of Rcore in pixels",
679 "vircam.vircam_science_process",3.0,1.0e-6,
681 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_rcore");
682 cpl_parameterlist_append(recipe->parameters,p);
686 p = cpl_parameter_new_range(
"vircam.vircam_science_process.stk_cat_nbsize",
687 CPL_TYPE_INT,
"Background smoothing box size",
688 "vircam.vircam_science_process",64,1,2048);
689 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_nbsize");
690 cpl_parameterlist_append(recipe->parameters,p);
696 p = cpl_parameter_new_range(
"vircam.vircam_science_process.stk_lthr",
697 CPL_TYPE_DOUBLE,
"Low rejection threshold",
698 "vircam.vircam_science_process",5.0,1.0e-6,
700 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_lthr");
701 cpl_parameterlist_append(recipe->parameters,p);
705 p = cpl_parameter_new_range(
"vircam.vircam_science_process.stk_hthr",
706 CPL_TYPE_DOUBLE,
"Upper rejection threshold",
707 "vircam.vircam_science_process",5.0,1.0e-6,
709 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_hthr");
710 cpl_parameterlist_append(recipe->parameters,p);
714 p = cpl_parameter_new_enum(
"vircam.vircam_science_process.stk_method",
715 CPL_TYPE_STRING,
"Stacking method",
716 "vircam.vircam_science_process",
"linear",2,
718 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_method");
719 cpl_parameterlist_append(recipe->parameters,p);
723 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_seeing",
724 CPL_TYPE_BOOL,
"Weight by seeing?",
725 "vircam.vircam_science_process",FALSE);
726 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_seeing");
727 cpl_parameterlist_append(recipe->parameters,p);
731 p = cpl_parameter_new_enum(
"vircam.vircam_science_process.stk_fast",
733 "Use fast stacking?",
734 "vircam.vircam_science_process",
735 "auto",3,
"fast",
"slow",
"auto");
736 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_fast");
737 cpl_parameterlist_append(recipe->parameters,p);
742 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_nfst",
744 "Nframes to stack in fast mode",
745 "vircam.vircam_science_process",30);
746 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_nfst");
747 cpl_parameterlist_append(recipe->parameters,p);
753 p = cpl_parameter_new_value(
"vircam.vircam_science_process.str_filt",
754 CPL_TYPE_BOOL,
"Filter stripe pattern?",
755 "vircam.vircam_science_process",TRUE);
756 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"str_filt");
757 cpl_parameterlist_append(recipe->parameters,p);
763 p = cpl_parameter_new_range(
"vircam.vircam_science_process.psm_ipix",
765 "Minimum pixel area for each detected object",
766 "vircam.vircam_science_process",5,1,100000);
767 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_ipix");
768 cpl_parameterlist_append(recipe->parameters,p);
772 p = cpl_parameter_new_range(
"vircam.vircam_science_process.psm_niter",
774 "Number of iterations in pawsky mask",
775 "vircam.vircam_science_process",5,1,100);
776 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_niter");
777 cpl_parameterlist_append(recipe->parameters,p);
781 p = cpl_parameter_new_range(
"vircam.vircam_science_process.psm_thresh",
783 "Detection threshold in sigma above sky",
784 "vircam.vircam_science_process",2.0,1.0e-6,
786 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_thresh");
787 cpl_parameterlist_append(recipe->parameters,p);
791 p = cpl_parameter_new_range(
"vircam.vircam_science_process.psm_nbsize",
792 CPL_TYPE_INT,
"Background smoothing box size",
793 "vircam.vircam_science_process",50,1,2048);
794 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_nbsize");
795 cpl_parameterlist_append(recipe->parameters,p);
799 p = cpl_parameter_new_range(
"vircam.vircam_science_process.psm_smkern",
801 "Smoothing kernel size (pixels)",
802 "vircam.vircam_science_process",2.0,1.0e-6,5.0);
803 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_smkern");
804 cpl_parameterlist_append(recipe->parameters,p);
808 p = cpl_parameter_new_value(
"vircam.vircam_science_process.cacheloc",
810 "Location of standard star cache?",
811 "vircam.vircam_science_process",
".");
812 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"cacheloc");
813 cpl_parameterlist_append(recipe->parameters,p);
817 p = cpl_parameter_new_value(
"vircam.vircam_science_process.magerrcut",
819 "Magnitude error cut",
820 "vircam.vircam_science_process",100.0);
821 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"magerrcut");
822 cpl_parameterlist_append(recipe->parameters,p);
837static int vircam_science_process_exec(cpl_plugin *plugin) {
842 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
843 recipe = (cpl_recipe *)plugin;
847 return(vircam_science_process(recipe->parameters,recipe->frames));
858static int vircam_science_process_destroy(cpl_plugin *plugin) {
863 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
864 recipe = (cpl_recipe *)plugin;
868 cpl_parameterlist_delete(recipe->parameters);
881static int vircam_science_process(cpl_parameterlist *parlist,
882 cpl_frameset *framelist) {
883 const char *fctid=
"vircam_science_process";
885 int nfail,status,i,ndit,j,live,isfirst,nsci,njsteps,n;
887 float gaincor_fac,readnoise,gain,dit;
888 cpl_frame *catindex,*
template,*frm;
889 cpl_propertylist *pp;
890 cpl_table *stdscat,*tab;
892 char filt[16],projid[16],*tname,fname[BUFSIZ];
896 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
897 cpl_msg_error(fctid,
"Input framelist NULL or has no input data");
904 (void)strncpy(vircam_recipename,fctid,VIRCAM_PATHSZ);
905 (void)snprintf(vircam_recipepaf,VIRCAM_PATHSZ,
"VIRCAM/%s",fctid);
909 p = cpl_parameterlist_find(parlist,
910 "vircam.vircam_science_process.destripe");
911 vircam_sci_config.destripe = cpl_parameter_get_bool(p);
912 p = cpl_parameterlist_find(parlist,
913 "vircam.vircam_science_process.str_filt");
914 vircam_sci_config.str_filt = cpl_parameter_get_bool(p);
915 p = cpl_parameterlist_find(parlist,
916 "vircam.vircam_science_process.skyalgo");
917 if (! strcmp(cpl_parameter_get_string(p),
"none"))
918 vircam_sci_config.skyalgo = SKYNONE;
919 else if (! strcmp(cpl_parameter_get_string(p),
"master"))
920 vircam_sci_config.skyalgo = SKYMASTER;
921 else if (! strcmp(cpl_parameter_get_string(p),
"pawsky_mask"))
922 vircam_sci_config.skyalgo = PAWSKY_MASK;
923 else if (! strcmp(cpl_parameter_get_string(p),
"pawsky_mask_pre"))
924 vircam_sci_config.skyalgo = PAWSKY_MASK_PRE;
925 else if (! strcmp(cpl_parameter_get_string(p),
"tilesky"))
926 vircam_sci_config.skyalgo = TILESKY;
927 else if (! strcmp(cpl_parameter_get_string(p),
"tilesky_minus"))
928 vircam_sci_config.skyalgo = TILESKY_MINUS;
929 else if (! strcmp(cpl_parameter_get_string(p),
"auto"))
930 vircam_sci_config.skyalgo = AUTO;
931 else if (! strcmp(cpl_parameter_get_string(p),
"pawsky_minus"))
932 vircam_sci_config.skyalgo = PAWSKY_MINUS;
933 p = cpl_parameterlist_find(parlist,
934 "vircam.vircam_science_process.preview_only");
935 vircam_sci_config.preview_only = cpl_parameter_get_bool(p);
936 p = cpl_parameterlist_find(parlist,
937 "vircam.vircam_science_process.minphotom");
938 vircam_sci_config.minphotom = cpl_parameter_get_int(p);
939 p = cpl_parameterlist_find(parlist,
940 "vircam.vircam_science_process.prettynames");
941 vircam_sci_config.prettynames = cpl_parameter_get_bool(p);
942 p = cpl_parameterlist_find(parlist,
943 "vircam.vircam_science_process.cdssearch");
944 vircam_sci_config.cdssearch = (cpl_parameter_get_bool(p) ? 1 : 0);
948 p = cpl_parameterlist_find(parlist,
949 "vircam.vircam_science_process.stk_lthr");
950 stk.lthr = cpl_parameter_get_double(p);
951 p = cpl_parameterlist_find(parlist,
952 "vircam.vircam_science_process.stk_hthr");
953 stk.hthr = cpl_parameter_get_double(p);
954 p = cpl_parameterlist_find(parlist,
955 "vircam.vircam_science_process.stk_method");
956 stk.method = (! strcmp(cpl_parameter_get_string(p),
"nearest") ? 0 : 1);
957 p = cpl_parameterlist_find(parlist,
958 "vircam.vircam_science_process.stk_seeing");
959 stk.seeing = cpl_parameter_get_bool(p);
960 p = cpl_parameterlist_find(parlist,
961 "vircam.vircam_science_process.stk_fast");
962 if (! strcmp(cpl_parameter_get_string(p),
"auto"))
964 else if (! strcmp(cpl_parameter_get_string(p),
"slow"))
966 else if (! strcmp(cpl_parameter_get_string(p),
"fast"))
968 p = cpl_parameterlist_find(parlist,
969 "vircam.vircam_science_process.stk_nfst");
970 stk.nfst = cpl_parameter_get_int(p);
974 p = cpl_parameterlist_find(parlist,
975 "vircam.vircam_science_process.stk_cat_ipix");
976 stk_cat.ipix = cpl_parameter_get_int(p);
977 p = cpl_parameterlist_find(parlist,
978 "vircam.vircam_science_process.stk_cat_thresh");
979 stk_cat.thresh = (float)cpl_parameter_get_double(p);
980 p = cpl_parameterlist_find(parlist,
981 "vircam.vircam_science_process.stk_cat_icrowd");
982 stk_cat.icrowd = cpl_parameter_get_bool(p);
983 p = cpl_parameterlist_find(parlist,
984 "vircam.vircam_science_process.stk_cat_rcore");
985 stk_cat.rcore = (float)cpl_parameter_get_double(p);
986 p = cpl_parameterlist_find(parlist,
987 "vircam.vircam_science_process.stk_cat_nbsize");
988 stk_cat.nbsize = cpl_parameter_get_int(p);
992 p = cpl_parameterlist_find(parlist,
993 "vircam.vircam_science_process.psm_ipix");
994 psm.ipix = cpl_parameter_get_int(p);
995 p = cpl_parameterlist_find(parlist,
996 "vircam.vircam_science_process.psm_niter");
997 psm.niter = cpl_parameter_get_int(p);
998 p = cpl_parameterlist_find(parlist,
999 "vircam.vircam_science_process.psm_thresh");
1000 psm.thresh = cpl_parameter_get_double(p);
1001 p = cpl_parameterlist_find(parlist,
1002 "vircam.vircam_science_process.psm_nbsize");
1003 psm.nbsize = cpl_parameter_get_int(p);
1004 p = cpl_parameterlist_find(parlist,
1005 "vircam.vircam_science_process.psm_smkern");
1006 psm.smkern = cpl_parameter_get_double(p);
1010 p = cpl_parameterlist_find(parlist,
1011 "vircam.vircam_science_process.cacheloc");
1012 vircam_sci_config.cacheloc = (
char *)cpl_parameter_get_string(p);
1016 p = cpl_parameterlist_find(parlist,
1017 "vircam.vircam_science_process.magerrcut");
1018 vircam_sci_config.magerrcut = (float)cpl_parameter_get_double(p);
1023 cpl_msg_error(fctid,
"Cannot identify RAW and CALIB frames");
1032 cpl_msg_error(fctid,
"Cannot labelise the input frames");
1040 if ((ps.science_frames =
1042 VIRCAM_SCI_OBJECT_RAW)) == NULL) {
1043 if ((ps.science_frames =
1045 VIRCAM_SCI_OBJECT_EXT_RAW)) == NULL) {
1046 cpl_msg_error(fctid,
"No science images to process!");
1056 VIRCAM_CAL_SKY)) == NULL) {
1057 if ((ps.offset_skies =
1059 VIRCAM_OFFSET_SKY_RAW)) == NULL) {
1063 nfail += vircam_sci_testfrms(ps.offset_skies,VIRCAM_NEXTN,1);
1067 vircam_sci_config.skyalgo = -1;
1068 nfail += vircam_sci_testfrm_1(ps.master_sky,VIRCAM_NEXTN,1);
1073 if ((ps.master_dark =
1075 VIRCAM_CAL_DARK)) == NULL) {
1076 cpl_msg_error(fctid,
"No master dark found");
1080 nfail += vircam_sci_testfrm_1(ps.master_dark,VIRCAM_NEXTN,1);
1084 if ((ps.master_twilight_flat =
1086 VIRCAM_CAL_TWILIGHT_FLAT)) == NULL) {
1087 cpl_msg_error(fctid,
"No master twilight flat found");
1091 nfail += vircam_sci_testfrm_1(ps.master_twilight_flat,VIRCAM_NEXTN,1);
1097 nlab,VIRCAM_CAL_OBJMASK);
1098 if ((ps.master_objmask == NULL) &&
1099 (vircam_sci_config.skyalgo == PAWSKY_MASK_PRE)) {
1100 cpl_msg_error(fctid,
1101 "No object mask found. Unable to use requested sky algorithm");
1104 }
else if (ps.master_objmask != NULL &&
1105 (vircam_sci_config.skyalgo == PAWSKY_MASK ||
1106 vircam_sci_config.skyalgo == TILESKY)) {
1108 "Requested sky subt algorithm requires no object mask");
1110 nfail += vircam_sci_testfrm_1(ps.master_objmask,0,1);
1116 &status) != CASU_OK) {
1117 cpl_msg_error(fctid,
"Error calculating gain corrections");
1124 if ((ps.readgain_file =
1126 VIRCAM_CAL_READGAINFILE)) == NULL) {
1127 cpl_msg_error(fctid,
"No master readnoise/gain file found");
1131 nfail += vircam_sci_testfrm_1(ps.readgain_file,VIRCAM_NEXTN,0);
1135 if ((ps.master_conf =
1137 VIRCAM_CAL_CONF)) == NULL) {
1138 cpl_msg_error(fctid,
"No master confidence map file found");
1142 nfail += vircam_sci_testfrm_1(ps.master_conf,VIRCAM_NEXTN,1);
1149 VIRCAM_CAL_CHANTAB)) == NULL) {
1150 cpl_msg_error(fctid,
"No channel table found");
1154 nfail += vircam_sci_testfrm_1(ps.chantab,VIRCAM_NEXTN,0);
1159 VIRCAM_CAL_PHOTTAB)) == NULL) {
1160 cpl_msg_error(fctid,
"No photometric table found");
1164 n = cpl_frame_get_nextensions(ps.phottab);
1165 nfail += vircam_sci_testfrm_1(ps.phottab,n,0);
1170 if (vircam_sci_config.cdssearch == 0) {
1172 VIRCAM_CAL_2MASS)) == NULL) {
1173 cpl_msg_error(fctid,
"No 2MASS index found -- cannot continue");
1177 nfail += vircam_sci_testfrm_1(catindex,1,0);
1183 VIRCAM_CAL_SCHL_N)) == NULL) {
1184 cpl_msg_error(fctid,
"Schlegel North map not found -- cannot continue");
1188 nfail += vircam_sci_testfrm_1(ps.schlf_n,0,1);
1194 VIRCAM_CAL_SCHL_S)) == NULL) {
1195 cpl_msg_error(fctid,
"Schlegel South map not found -- cannot continue");
1199 nfail += vircam_sci_testfrm_1(ps.schlf_s,0,1);
1203 if (access(vircam_sci_config.cacheloc,R_OK+W_OK+X_OK) != 0) {
1204 cpl_msg_error(fctid,
"Cache location %s inacessible",
1205 vircam_sci_config.cacheloc);
1214 cpl_msg_error(fctid,
1215 "There are %" CPL_SIZE_FORMAT
" input file errors -- cannot continue",
1223 if (catindex != NULL) {
1224 if (
casu_catpars(catindex,&(ps.catpath),&(ps.catname)) == CASU_FATAL) {
1226 cpl_frame_delete(catindex);
1229 cpl_frame_delete(catindex);
1233 (void)strcpy(current_catpath,ps.catpath);
1234 (void)strcpy(current_cat,ps.catname);
1243 pp = cpl_propertylist_load(cpl_frame_get_filename(cpl_frameset_get_position(ps.science_frames,0)),0);
1245 cpl_msg_error(fctid,
"No value for NDIT available");
1246 freepropertylist(pp);
1250 cpl_propertylist_delete(pp);
1254 ps.tphottab = cpl_table_load(cpl_frame_get_filename(ps.phottab),1,0);
1258 vircam_sci_paws_create(ps.science_frames,&(ps.nscipaws),&(ps.science_paws));
1259 vircam_sci_paws_create(ps.offset_skies,&(ps.noffpaws),&(ps.offsky_paws));
1264 if (ps.science_paws[0].tilenum == -1 && ps.nscipaws > 1) {
1265 cpl_msg_error(fctid,
1266 "List has %" CPL_SIZE_FORMAT
" pawprints. Only 1 is allowed for non tiles",
1267 (cpl_size)ps.nscipaws);
1274 vircam_sci_skydefine();
1278 if (vircam_sci_config.preview_only) {
1279 if (ps.science_paws[0].tilenum == -1)
1280 fprintf(stdout,
"This is a paw group with %" CPL_SIZE_FORMAT
" files\n",
1281 cpl_frameset_get_size(ps.science_frames));
1283 fprintf(stdout,
"This is a tile group with %" CPL_SIZE_FORMAT
" files\n",
1284 cpl_frameset_get_size(ps.science_frames));
1285 frm = cpl_frameset_get_position(ps.science_frames,0);
1286 pp = cpl_propertylist_load(cpl_frame_get_filename(frm),0);
1292 cpl_propertylist_delete(pp);
1294 fprintf(stdout,
"Filter %8s, DIT: %8.1f, NDIT: %" CPL_SIZE_FORMAT
", Project: %s\n",filt,
1295 dit,(cpl_size)ndit,projid);
1296 fprintf(stdout,
"Dark: %s\n",cpl_frame_get_filename(ps.master_dark));
1297 fprintf(stdout,
"Flat: %s\n",
1298 cpl_frame_get_filename(ps.master_twilight_flat));
1299 fprintf(stdout,
"CPM: %s\n",cpl_frame_get_filename(ps.master_conf));
1300 fprintf(stdout,
"Channel table: %s\n",
1301 cpl_frame_get_filename(ps.chantab));
1302 fprintf(stdout,
"A %" CPL_SIZE_FORMAT
" point dither will be done\n",
1304 if (ps.science_paws[0].tilenum != -1)
1305 fprintf(stdout,
"The tile has %" CPL_SIZE_FORMAT
" pawprints\n",
1306 (cpl_size)ps.nscipaws);
1307 for (i = 0; i < ps.nscipaws; i++) {
1308 n = cpl_frameset_get_size(ps.science_paws[i].orig);
1309 for (j = 0; j < n; j++) {
1310 frm = cpl_frameset_get_position(ps.science_paws[i].orig,j);
1311 fprintf(stdout,
"%s sky%" CPL_SIZE_FORMAT
"\n",
1312 cpl_frame_get_filename(frm),
1313 (cpl_size)(ps.science_paws[i].whichsky[j]+1));
1316 if (ps.noffpaws != 0) {
1317 fprintf(stdout,
"There are %" CPL_SIZE_FORMAT
" offset sky frames\n",
1318 cpl_frameset_get_size(ps.offset_skies));
1319 for (i = 0; i < ps.noffpaws; i++) {
1320 n = cpl_frameset_get_size(ps.offsky_paws[i].orig);
1321 for (j = 0; j < n; j++) {
1322 frm = cpl_frameset_get_position(ps.offsky_paws[i].orig,j);
1323 fprintf(stdout,
"%s sky%" CPL_SIZE_FORMAT
"\n",cpl_frame_get_filename(frm),
1324 (cpl_size)(ps.offsky_paws[i].whichsky[j]+1));
1328 fprintf(stdout,
"\nRequested sky algorithm: %" CPL_SIZE_FORMAT
"\n",
1329 (cpl_size)vircam_sci_config.skyalgo);
1330 for (i = 0; i < ps.nskys; i++) {
1331 fprintf(stdout,
"Sky%" CPL_SIZE_FORMAT
": %" CPL_SIZE_FORMAT
" ",
1332 (cpl_size)(i+1),(cpl_size)ps.skys[i].skyalgo);
1333 if (ps.skys[i].objmask != NULL)
1334 fprintf(stdout,
"mask: %s\nFormed from:\n",
1335 cpl_frame_get_filename(ps.skys[i].objmask));
1337 fprintf(stdout,
"\nFormed from:\n");
1338 for (j = 0; j < cpl_frameset_get_size(ps.skys[i].contrib); j++) {
1339 frm = cpl_frameset_get_position(ps.skys[i].contrib,j);
1340 fprintf(stdout,
" %s\n",cpl_frame_get_filename(frm));
1349 ps.nscience = cpl_frameset_get_size(ps.science_frames);
1351 ps.product_frames_simple = cpl_malloc(ps.nscience*
sizeof(cpl_frame *));
1352 for (i = 0; i < ps.nscience; i++)
1353 ps.product_frames_simple[i] = NULL;
1354 if (ps.offset_skies != NULL) {
1355 ps.noffsets = cpl_frameset_get_size(ps.offset_skies);
1356 ps.product_frames_simple_off =
1357 cpl_malloc(ps.noffsets*
sizeof(cpl_frame *));
1358 for (i = 0; i < ps.noffsets; i++)
1359 ps.product_frames_simple_off[i] = NULL;
1366 cpl_msg_info(fctid,
"Beginning stage1 reduction");
1367 cpl_msg_indent_more();
1368 for (j = 1; j <= VIRCAM_NEXTN; j++) {
1370 gaincor_fac = (ps.gaincors)[j-1];
1371 cpl_msg_info(fctid,
"Extension [%" CPL_SIZE_FORMAT
"]",(cpl_size)j);
1377 ps.fflat =
casu_fits_load(ps.master_twilight_flat,CPL_TYPE_FLOAT,j);
1388 ps.nscience = cpl_frameset_get_size(ps.science_frames);
1393 ps.noffsets = cpl_frameset_get_size(ps.offset_skies);
1398 ps.offsky_fits = NULL;
1405 for (i = 0; i < ps.nscience; i++) {
1406 ff = ps.sci_fits[i];
1412 cpl_msg_error(fctid,
"Unable to correct CRVAL in %s",
1418 for (i = 0; i < ps.noffsets; i++) {
1419 ff = ps.offsky_fits[i];
1428 vircam_sci_get_readnoise_gain(j,&readnoise,&gain);
1429 for (i = 0; i < ps.nscience; i++) {
1430 ff = ps.sci_fits[i];
1434 "[e-] Readnoise used in processing");
1437 "[e-/adu] Gain used in processing");
1439 cpl_msg_info(fctid,
"Detector is flagged dead in %s",
1450 frm = cpl_frameset_get_position(ps.science_frames,i);
1451 tname = (
char *)cpl_frame_get_filename(frm);
1452 vircam_sci_product_name(tname,SIMPLE_FILE,
1453 vircam_sci_config.prettynames,i+1,fname);
1454 vircam_sci_save_simple(ff,framelist,parlist,0,
1455 cpl_frameset_get_position(ps.science_frames,i),
1456 isfirst,VIRCAM_PRO_SIMPLE_SCI,fname,
1457 ps.product_frames_simple+i);
1459 for (i = 0; i < ps.noffsets; i++) {
1460 ff = ps.offsky_fits[i];
1462 cpl_msg_info(fctid,
"Detector is flagged dead in %s",
1473 frm = cpl_frameset_get_position(ps.offset_skies,i);
1474 tname = (
char *)cpl_frame_get_filename(frm);
1475 vircam_sci_product_name(tname,SIMPLE_FILE,
1476 vircam_sci_config.prettynames,
1477 ps.nscience+i+1,fname);
1478 vircam_sci_save_simple(ff,framelist,parlist,0,
1479 cpl_frameset_get_position(ps.offset_skies,i),
1480 isfirst,VIRCAM_PRO_SIMPLE_SKY,fname,
1481 ps.product_frames_simple_off+i);
1488 for (i = 0; i < nsci; i++)
1489 freeframe(ps.product_frames_simple[i]);
1490 for (i = 0; i < ps.noffsets; i++)
1491 freeframe(ps.product_frames_simple_off[i]);
1493 cpl_msg_indent_less();
1497 cpl_msg_info(fctid,
"Making skies");
1498 for (i = 0; i < ps.nskys; i++) {
1499 if (vircam_sci_makesky(framelist,parlist,&(ps.skys[i]),
1500 VIRCAM_PRO_SIMPLE_SCI) != CASU_OK) {
1501 cpl_msg_error(fctid,
"Error making sky %" CPL_SIZE_FORMAT
"",
1510 cpl_msg_info(fctid,
"Beginning stage2 reduction");
1511 (void)vircam_sci_sky_stripe_wcs(ps.nscipaws,ps.science_paws,
1512 VIRCAM_PRO_SIMPLE_SCI,framelist,parlist,
1513 vircam_sci_config.destripe);
1514 (void)vircam_sci_sky_stripe_wcs(ps.noffpaws,ps.offsky_paws,
1515 VIRCAM_PRO_SIMPLE_SKY,framelist,parlist,
1516 vircam_sci_config.destripe);
1520 cpl_msg_info(fctid,
"Beginning group processing");
1521 cpl_msg_indent_more();
1522 for (i = 0; i < ps.nscipaws; i++) {
1523 cpl_msg_info(fctid,
"Working on paw%" CPL_SIZE_FORMAT
"",
1525 cpl_msg_indent_more();
1526 for (j = 1; j <= VIRCAM_NEXTN; j++) {
1528 "Stacking paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1529 (cpl_size)(i+1),(cpl_size)j);
1530 vircam_sci_stack(&(ps.science_paws[i]),j);
1532 "Source extraction paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1533 (cpl_size)(i+1),(cpl_size)j);
1534 vircam_sci_cat(&(ps.science_paws[i]),j);
1536 "WCS fit paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1537 (cpl_size)(i+1),(cpl_size)j);
1538 vircam_sci_wcsfit(&(ps.science_paws[i].stack[j-1]),
1539 &(ps.science_paws[i].stackc[j-1]),
1540 &(ps.science_paws[i].cat[j-1]),1,2);
1544 1,current_catpath,current_cat,
1545 vircam_sci_config.cdssearch,
1546 vircam_sci_config.cacheloc,&stdscat,
1552 ps.science_paws[i].cat[j-1],NULL,NULL);
1555 cpl_msg_indent_less();
1557 "Doing photometric calibriation on paw%" CPL_SIZE_FORMAT
"",
1559 vircam_sci_photcal(&(ps.science_paws[i]));
1560 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[i].orig,0));
1561 cpl_msg_info(fctid,
"Saving paw%" CPL_SIZE_FORMAT
"",(cpl_size)(i+1));
1562 cpl_msg_indent_more();
1563 for (j = 1; j <= VIRCAM_NEXTN; j++) {
1565 "Saving image paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1566 (cpl_size)(i+1),(cpl_size)j);
1567 vircam_sci_save_stack(ps.science_paws[i].stack[j-1],framelist,
1569 vircam_sci_config.prettynames,i+1,
1570 &(ps.science_paws[i].product_frame_im));
1571 cpl_msg_info(fctid,
"Saving confidence map paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1572 (cpl_size)(i+1),(cpl_size)j);
1573 vircam_sci_save_stack_conf(ps.science_paws[i].stackc[j-1],framelist,
1575 vircam_sci_config.prettynames,i+1,
1576 &(ps.science_paws[i].product_frame_conf));
1578 "Saving catalogue paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1579 (cpl_size)(i+1),(cpl_size)j);
1580 vircam_sci_save_stack_cat(ps.science_paws[i].cat[j-1],
1581 framelist,parlist,
template,
1582 vircam_sci_config.prettynames,i+1,
1583 &(ps.science_paws[i].product_frame_cat));
1585 freeframe(
template);
1586 cpl_msg_indent_less();
1587 vircam_sci_paw_delete(ps.science_paws+i);
1589 cpl_msg_indent_less();
1614static void vircam_sci_photcal(pawprint *paw) {
1626 filt,ps.tphottab,vircam_sci_config.minphotom,
1627 ps.schlf_n,ps.schlf_s,
"EXPTIME",
"ESO TEL AIRM START",
1628 vircam_sci_config.magerrcut,&status);
1647static void vircam_sci_skydefine(
void) {
1649 cpl_frameset *newfrmset,**in;
1650 cpl_frame *
template;
1656 switch (vircam_sci_config.skyalgo) {
1665 vircam_sci_choose_skyalgo(&(ps.nskys),&(ps.skys));
1673 ps.skys = cpl_malloc(
sizeof(skystruct));
1674 ps.skys[0].skyframe = cpl_frame_duplicate(ps.master_sky);
1675 ps.skys[0].skyalgo = SKYMASTER;
1676 ps.skys[0].contrib = NULL;
1677 ps.skys[0].objmask = NULL;
1678 ps.skys[0].template = NULL;
1679 for (i = 0; i < ps.nscipaws; i++)
1680 vircam_sci_assign_sky_all(ps.science_paws[i],0);
1688 if (ps.noffpaws == 0) {
1689 ps.nskys = ps.nscipaws;
1690 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1691 for (i = 0; i < ps.nscipaws; i++) {
1692 newfrmset = cpl_frameset_duplicate(ps.science_paws[i].current);
1693 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[i].orig,0));
1694 ps.skys[i] = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,
1696 vircam_sci_assign_sky_all(ps.science_paws[i],i);
1699 ps.nskys = ps.noffpaws;
1700 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1701 for (i = 0; i < ps.noffpaws; i++) {
1702 newfrmset = cpl_frameset_duplicate(ps.offsky_paws[i].current);
1703 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.offsky_paws[i].orig,0));
1704 ps.skys[i] = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,
1706 vircam_sci_assign_sky_all(ps.offsky_paws[i],i);
1708 for (i = 0; i < ps.nscipaws; i++) {
1713 vircam_sci_assign_sky_all(ps.science_paws[i],j);
1722 case PAWSKY_MASK_PRE:
1723 ps.nskys = ps.nscipaws;
1724 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1725 for (i = 0; i < ps.nscipaws; i++) {
1726 newfrmset = cpl_frameset_duplicate(ps.science_paws[i].current);
1727 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[i].orig,0));
1728 ps.skys[i] = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,i+1);
1729 vircam_sci_assign_sky_all(ps.science_paws[i],i);
1737 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1738 if (ps.noffpaws == 0) {
1739 in = cpl_malloc(ps.nscipaws*
sizeof(cpl_frameset *));
1740 for (i = 0; i < ps.nscipaws; i++)
1741 in[i] = ps.science_paws[i].current;
1742 newfrmset = vircam_sci_merge_framesets(ps.nscipaws,in);
1744 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[0].orig,0));
1745 ps.skys[0] = vircam_sci_crsky(TILESKY,newfrmset,
template,1);
1746 for (i = 0; i < ps.nscipaws; i++)
1747 vircam_sci_assign_sky_all(ps.science_paws[i],0);
1749 in = cpl_malloc(ps.noffpaws*
sizeof(cpl_frameset *));
1750 for (i = 0; i < ps.noffpaws; i++)
1751 in[i] = ps.offsky_paws[i].current;
1752 newfrmset = vircam_sci_merge_framesets(ps.noffpaws,in);
1754 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.offsky_paws[0].orig,0));
1755 ps.skys[0] = vircam_sci_crsky(TILESKY,newfrmset,
template,1);
1756 for (i = 0; i < ps.noffpaws; i++)
1757 vircam_sci_assign_sky_all(ps.offsky_paws[i],0);
1758 for (i = 0; i < ps.nscipaws; i++)
1759 vircam_sci_assign_sky_all(ps.science_paws[i],0);
1769 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1770 in = cpl_malloc(ps.nscipaws*
sizeof(cpl_frameset *));
1771 for (i = 0; i < ps.nscipaws; i++)
1772 in[i] = ps.science_paws[i].current;
1773 newfrmset = vircam_sci_merge_framesets(ps.nscipaws,in);
1775 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[0].orig,0));
1776 ps.skys[0] = vircam_sci_crsky(TILESKY_MINUS,newfrmset,
template,1);
1777 for (i = 0; i < ps.nscipaws; i++)
1778 vircam_sci_assign_sky_all(ps.science_paws[i],0);
1787 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1788 newfrmset = cpl_frameset_duplicate(ps.science_paws[0].current);
1789 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[0].orig,0));
1790 ps.skys[0] = vircam_sci_crsky(PAWSKY_MINUS,newfrmset,
template,1);
1791 vircam_sci_assign_sky_all(ps.science_paws[0],0);
1816static void vircam_sci_cat(pawprint *paw,
int extn) {
1825 (void)
casu_imcore(paw->stack[extn-1],paw->stackc[extn-1],stk_cat.ipix,
1826 stk_cat.thresh,stk_cat.icrowd,stk_cat.rcore,
1827 stk_cat.nbsize,6,2.0,&tab,gain,&status);
1828 paw->cat[extn-1] = tab;
1851static void vircam_sci_stack(pawprint *paw,
int extn) {
1852 casu_fits **inf,*inconf,*out,*outc,*outv;
1853 int ninf,status,i,fastslow;
1860 ninf = (int)cpl_frameset_get_size(paw->current);
1863 fastslow = (ninf <= stk.nfst);
1865 fastslow = stk.fast;
1866 casu_imstack(inf,&inconf,NULL,NULL,ninf,1,stk.lthr,stk.hthr,stk.method,
1867 stk.seeing,fastslow,1,
"EXPTIME",&out,&outc,&outv,&status);
1873 for (i = 0; i < ninf; i++) {
1877 sum /= (double)ninf;
1880 "Mean MJD of the input images");
1881 freefitslist(inf,ninf);
1883 paw->stack[extn-1] = out;
1884 paw->stackc[extn-1] = outc;
1921static int vircam_sci_sky_stripe_wcs(
int npaw, pawprint *paw,
const char *tag,
1922 cpl_frameset *framelist,
1923 cpl_parameterlist *parlist,
int destripe) {
1924 int i,j,jj,k,nf,n,isfirst,ii,status,whichsky,skyminus;
1926 cpl_frame *curframe,*
template,*product_frame = NULL;
1927 cpl_frameset *objframes;
1928 cpl_image *img,*simg;
1929 float med,sig,*sdata;
1930 casu_fits **sky_extns,*curfits[4],*tmpfits,*fconf;
1931 unsigned char *bpm[VIRCAM_NEXTN];
1932 cpl_mask *cplmasks[VIRCAM_NEXTN];
1933 const char *fctid =
"vircam_sci_sky_stripe_wcs";
1934 char tmpname[BUFSIZ];
1938 if (npaw == 0 || paw == NULL)
1943 for (i = 1; i <= VIRCAM_NEXTN; i++) {
1947 bpm[i-1] = cpl_calloc(nx*ny,
sizeof(
unsigned char));
1949 nx*ny*
sizeof(
unsigned char));
1950 cplmasks[i-1] = cpl_mask_wrap((cpl_size)nx,(cpl_size)ny,
1951 (cpl_binary *)bpm[i-1]);
1956 cpl_msg_indent_more();
1957 sky_extns = cpl_calloc(VIRCAM_NEXTN,
sizeof(casu_fits *));
1958 for (j = 0; j < VIRCAM_NEXTN; j++)
1959 sky_extns[j] = NULL;
1960 for (j = 0; j < npaw; j++) {
1964 objframes = paw[j].current;
1965 nf = cpl_frameset_get_size(objframes);
1967 skyminus = (ps.skys[paw[j].whichsky[0]].skyalgo == TILESKY_MINUS ||
1968 ps.skys[paw[j].whichsky[0]].skyalgo == PAWSKY_MINUS);
1969 for (jj = 0; jj < nf; jj++) {
1970 curframe = cpl_frameset_get_position(objframes,jj);
1971 cpl_msg_info(fctid,
"Beginning work on %s",
1972 cpl_frame_get_filename(curframe));
1973 template = cpl_frameset_get_position(paw[j].orig,jj);
1975 (void)snprintf(tmpname,BUFSIZ,
"tmp_%s",
1976 cpl_frame_get_filename(curframe));
1983 (whichsky == -1 || paw[j].whichsky[jj] != whichsky)) {
1984 whichsky = paw[j].whichsky[jj];
1985 for (i = 1; i <= VIRCAM_NEXTN; i++) {
1986 freefits(sky_extns[i-1]);
1990 sdata = cpl_image_get_data_float(img);
1991 nx = (long)cpl_image_get_size_x(img);
1992 ny = (long)cpl_image_get_size_y(img);
1994 casu_qmedsig(sdata,bpm[i-1],npts,5.0,3,-1000.0,65535.0,
1996 for (k = 0; k < npts; k++)
2005 for (i = 1; i <= VIRCAM_NEXTN; i++) {
2008 if (sky_extns[i-1] != NULL) {
2010 cpl_image_subtract(img,(
const cpl_image *)simg);
2018 cpl_image_reject_from_mask(img,cplmasks[i-1]);
2028 vircam_destripe_four(curfits,vircam_sci_config.str_filt,
2030 for (ii = 0; ii < 4; ii++) {
2035 vircam_sci_wcsfit(&tmpfits,&fconf,NULL,1,1);
2036 vircam_sci_save_simple(tmpfits,framelist,parlist,
2037 1,
template,isfirst,tag,
2038 tmpname,&product_frame);
2040 freefits(curfits[ii]);
2050 remove(cpl_frame_get_filename(curframe));
2051 cpl_frame_set_filename(product_frame,
2052 cpl_frame_get_filename(curframe));
2053 rename(tmpname,cpl_frame_get_filename(curframe));
2058 for (i = 0; i < VIRCAM_NEXTN; i++)
2059 freefits(sky_extns[i]);
2061 for (i = 0; i < VIRCAM_NEXTN; i++) {
2062 cpl_mask_unwrap(cplmasks[i]);
2065 freespace(sky_extns);
2066 cpl_msg_indent_less();
2092static cpl_frame *vircam_sci_findtemplate(cpl_frame *in) {
2093 int i,j,imatch,jmatch,n;
2098 for (i = 0; i < ps.nscipaws; i++) {
2099 n = cpl_frameset_get_size(ps.science_paws[i].current);
2100 for (j = 0; j < n; j++) {
2101 frm = cpl_frameset_get_position(ps.science_paws[i].current,j);
2102 if (! strcmp(cpl_frame_get_filename(in),
2103 cpl_frame_get_filename(frm))) {
2115 return(cpl_frameset_get_position(ps.science_paws[imatch].orig,jmatch));
2147static void vircam_sci_wcsfit(casu_fits **in, casu_fits **conf,
2148 casu_tfits **incat,
int nf,
int level) {
2149 int status,nstd,ncat,slevel,n,i,j;
2150 float *x,*y,*ra,*dec,gain;
2153 cpl_table *stdscat,*newstds,*cat,*tmp,*tmp2,*matchstds;
2154 cpl_propertylist *p;
2156 const char *fctid =
"vircam_sci_wcsfit";
2160 for (j = 0; j < nf; j++) {
2168 (void)
casu_imcore(in[j],conf[j],10,1.5,0,3.0,64,3,2.0,&tcat,
2176 current_catpath,current_cat,
2177 vircam_sci_config.cdssearch,
2178 vircam_sci_config.cacheloc,&stdscat,&status);
2179 if (status != CASU_OK) {
2181 cpl_msg_error(fctid,
2182 "Failed to find any standards for %s[%" CPL_SIZE_FORMAT
"]",
2194 newstds = cpl_table_extract_selected(stdscat);
2195 nstd = (int)cpl_table_get_nrow(newstds);
2203 ncat = (int)cpl_table_get_nrow(cat);
2204 if (ncat > 500 && ncat > 2.0*nstd) {
2205 tmp = cpl_table_duplicate(cat);
2206 (void)cpl_table_or_selected_float(tmp,
"Ellipticity",CPL_LESS_THAN,0.5);
2207 tmp2 = cpl_table_extract_selected(tmp);
2208 ncat = (int)cpl_table_get_nrow(tmp2);
2210 p = cpl_propertylist_new();
2211 cpl_propertylist_append_bool(p,
"Isophotal_flux",TRUE);
2212 cpl_table_sort(tmp2,(
const cpl_propertylist *)p);
2213 cpl_propertylist_delete(p);
2214 slevel = min(ncat,max(1,min(5000,max(500,2*nstd))));
2215 tmp = cpl_table_extract(tmp2,1,(cpl_size)slevel);
2217 ncat = (int)cpl_table_get_nrow(tmp);
2229 if (status != CASU_OK) {
2230 freetable(matchstds);
2231 cpl_msg_error(fctid,
"Failed to match standards to catalogue");
2241 freetable(matchstds);
2242 if (status != CASU_OK) {
2243 cpl_msg_error(fctid,
"Failed to fit WCS");
2253 n = (int)cpl_table_get_nrow(cat);
2256 cpl_msg_error(fctid,
"Failed to fill RA and Dec in catalogue");
2259 x = cpl_table_get_data_float(cat,
"X_coordinate");
2260 y = cpl_table_get_data_float(cat,
"Y_coordinate");
2261 ra = cpl_table_get_data_float(cat,
"RA");
2262 dec = cpl_table_get_data_float(cat,
"DEC");
2263 for (i = 0; i < n; i++) {
2268 cpl_wcs_delete(wcs);
2303static int vircam_destripe_four(casu_fits **curfits,
int stripefilt,
2305 int i,nx,ny,n,k,m,ipstart,ipfin,ip;
2306 float *profiles[4],*meanprof,buf[4],*data,val,mad,rms;
2307 unsigned char *bpms[4],*bp;
2308 cpl_propertylist *plist;
2312 if (*status != CASU_OK)
2320 meanprof = cpl_malloc(ny*
sizeof(
float));
2321 bp = cpl_calloc(ny,
sizeof(
unsigned char));
2327 for (i = 0; i < 4; i++) {
2330 profiles[n] = cpl_malloc(ny*
sizeof(
float));
2331 bpms[n] = cpl_calloc(ny,
sizeof(
unsigned char));
2332 stripe_profile(curfits[i],stripefilt,profiles[n],bpms[n]);
2343 for (k = 0; k < ny; k++) {
2345 for (i = 0; i < n; i++) {
2348 buf[m++] = profiles[i][k];
2351 meanprof[k] =
casu_med(buf,NULL,(
long)m);
2358 ipfin = ipstart + nx;
2359 for (i = 0; i < 4; i++) {
2363 for (ip = ipstart; ip < ipfin; ip++)
2364 data[ip] -= meanprof[k];
2372 for (i = 0; i < n; i++) {
2373 freespace(profiles[i]);
2383 for (i = 0; i < 4; i++) {
2392 cpl_propertylist_update_bool(plist,
"ESO DRS STRIPECOR",k);
2393 cpl_propertylist_set_comment(plist,
"ESO DRS STRIPECOR",
2394 "Stripe correction done");
2395 cpl_propertylist_update_float(plist,
"ESO DRS STRIPERMS",val);
2396 cpl_propertylist_set_comment(plist,
"ESO DRS STRIPERMS",
2397 "RMS of removed stripe profile");
2402 freespace(meanprof);
2438static void stripe_profile(casu_fits *in,
int stripefilt,
float *profile,
2439 unsigned char *pbpm) {
2440 float *data,*copy,*d,lcut,hcut,skymed,skynoise,rmsold,rms,val;
2441 unsigned char *bpm,*ob,*b;
2449 nx = cpl_image_get_size_x(img);
2450 ny = cpl_image_get_size_y(img);
2451 data = cpl_image_get_data(img);
2452 bpm = (
unsigned char *)cpl_mask_get_data(cpl_image_get_bpm(img));
2457 casu_qmedsig(data,bpm,npts,3.0,3,-65535.0,65535.0,&skymed,&skynoise);
2461 ob = cpl_calloc(ny,
sizeof(
unsigned char));
2462 copy = cpl_malloc(ny*
sizeof(
float));
2468 for (i = 0; i < ny; i++) {
2476 for (j = 0; j < 3; j++) {
2478 if (val == CX_MAXFLOAT) {
2480 }
else if (rms == rmsold) {
2483 lcut = val - 3.0*skynoise;
2484 hcut = val + 3.0*skynoise;
2488 pbpm[i] = (val == CX_MAXFLOAT);
2489 profile[i] = (pbpm[i] ? 0.0 : val);
2490 copy[i] = profile[i];
2499 if (stripefilt && rms > 15.0) {
2500 casu_dostat(copy,pbpm,ob,ny,25,MEDIANCALC);
2501 casu_dostat(copy,pbpm,ob,ny,5,MEANCALC);
2502 for (i = 0; i < ny; i++) {
2504 profile[i] -= copy[i];
2509 for (i = 0; i < ny; i++)
2540static void vircam_sci_paws_delete(
int npaws, pawprint **paws) {
2543 for (i = 0; i < npaws; i++)
2544 vircam_sci_paw_delete(*paws+i);
2566static void vircam_sci_paw_delete(pawprint *paw) {
2569 if (paw->current == NULL)
2571 freespace(paw->whichsky);
2572 freeframeset(paw->orig);
2573 freeframeset(paw->current);
2574 for (i = 0; i < VIRCAM_NEXTN; i++) {
2575 freefits(paw->stack[i]);
2576 freefits(paw->stackc[i]);
2577 freetfits(paw->cat[i]);
2578 freetfits(paw->mstds[i]);
2604static void vircam_sci_paws_create(cpl_frameset *infrms,
int *npaws,
2606 cpl_size nlab,*labels,*labels2,nlab2;
2607 cpl_frameset *copy,*testme,*tf;
2608 int i,j,nalloc,pj,nfrms_tot;
2619 copy = cpl_frameset_duplicate(infrms);
2620 labels = cpl_frameset_labelise(copy,vircam_sci_cmp_tstart,&nlab);
2627 *paws = cpl_malloc(nalloc*
sizeof(pawprint));
2632 for (i = 0; i < nlab; i++) {
2637 testme = cpl_frameset_extract(copy,labels,(cpl_size)i);
2638 if (vircam_sci_istile(cpl_frameset_get_position(testme,0))) {
2639 pj = vircam_sci_ispj(testme);
2640 labels2 = cpl_frameset_labelise(testme,vircam_sci_cmp_jit,&nlab2);
2641 for (j = 0; j < nlab2; j++) {
2642 if (*npaws+1 > nalloc) {
2644 *paws = cpl_realloc(*paws,nalloc*
sizeof(pawprint));
2646 tf = cpl_frameset_extract(testme,labels2,(cpl_size)j);
2647 vircam_sci_paw_init(*paws+*npaws,tf,pj,&nfrms_tot);
2653 vircam_sci_paw_init(*paws+*npaws,testme,0,&nfrms_tot);
2656 freeframeset(testme);
2661 *paws = cpl_realloc(*paws,*npaws*
sizeof(pawprint));
2665 cpl_frameset_delete(copy);
2689static int vircam_sci_istile(cpl_frame *frm) {
2690 cpl_propertylist *plist;
2691 int hasoffs,noffsets;
2696 plist = cpl_propertylist_load(cpl_frame_get_filename(frm),0);
2697 hasoffs = cpl_propertylist_has(plist,
"OFFSTNUM");
2699 noffsets = cpl_propertylist_get_int(plist,
"NOFFSETS");
2702 cpl_propertylist_delete(plist);
2703 return(hasoffs && noffsets != 1);
2729static void vircam_sci_paw_init(pawprint *paw, cpl_frameset *frms,
int ispj,
2731 cpl_propertylist *plist;
2738 paw->orig = cpl_frameset_duplicate(frms);
2739 paw->current = vircam_sci_update_frameset(paw->orig,nfrms_tot);
2740 n = cpl_frameset_get_size(frms);
2741 paw->whichsky = cpl_malloc(n*
sizeof(
int));
2742 for (i = 0; i < n; i++)
2743 paw->whichsky[i] = -1;
2745 for (i = 0; i < VIRCAM_NEXTN; i++) {
2746 paw->stack[i] = NULL;
2747 paw->stackc[i] = NULL;
2749 paw->mstds[i] = NULL;
2751 paw->product_frame_im = NULL;
2752 paw->product_frame_conf = NULL;
2753 paw->product_frame_cat = NULL;
2758 fr = cpl_frameset_get_position(frms,0);
2759 plist = cpl_propertylist_load(cpl_frame_get_filename(fr),0);
2761 if (vircam_sci_istile(fr)) {
2775 cpl_propertylist_delete(plist);
2776 n = (int)cpl_frameset_get_size(frms);
2777 fr = cpl_frameset_get_position(frms,n-1);
2778 plist = cpl_propertylist_load(cpl_frame_get_filename(fr),0);
2781 paw->mjd_end += exptime/(24.0*3600.0);
2785 cpl_propertylist_delete(plist);
2815static int vircam_sci_makesky(cpl_frameset *framelist,
2816 cpl_parameterlist *parlist, skystruct *sky,
2824 switch (sky->skyalgo) {
2830 retval = vircam_sci_pawsky_minus(framelist,parlist,sky->contrib,
2831 sky->template,tag,sky->fname,
2835 retval = vircam_sci_tilesky_minus(framelist,parlist,sky->contrib,
2836 sky->template,tag,sky->fname,
2840 retval = vircam_sci_pawsky_mask(framelist,parlist,sky->skyalgo,
2841 sky->contrib,sky->template,
2842 sky->fname,&(sky->skyframe));
2844 case PAWSKY_MASK_PRE:
2845 retval = vircam_sci_pawsky_mask(framelist,parlist,sky->skyalgo,
2846 sky->contrib,sky->template,
2847 sky->fname,&(sky->skyframe));
2850 retval = vircam_sci_tilesky(framelist,parlist,sky->contrib,
2851 sky->template,sky->fname,&(sky->skyframe));
2894static int vircam_sci_tilesky_minus(cpl_frameset *framelist,
2895 cpl_parameterlist *parlist,
2896 cpl_frameset *in, cpl_frame *
template,
2897 const char *tag,
char *skyname,
2898 cpl_frame **skyframe) {
2899 int n,i,status,isfirst,j;
2900 casu_fits *objmaskfits,**infits,*inconf,*tmpfits,*skyout;
2901 cpl_frame **product_frames,*curframe;
2902 char tmpname[BUFSIZ], *skyname2 = NULL;
2903 const char *fctid =
"vircam_sci_tilesky_minus";
2905 n = cpl_frameset_get_size(in);
2907 product_frames = cpl_malloc(n*
sizeof(cpl_frame *));
2908 cpl_msg_info(fctid,
"Creating sky %s",skyname);
2909 cpl_msg_indent_more();
2910 for (i = 1; i <= VIRCAM_NEXTN; i++) {
2911 cpl_msg_info(fctid,
"Beginning on extn %" CPL_SIZE_FORMAT
"",
2916 if (vircam_tilesky_minus(infits,inconf,objmaskfits,n,&skyout,
2917 &status) != CASU_OK) {
2918 freefitslist(infits,n);
2920 freespace(product_frames);
2924 vircam_sci_save_sky(skyout,framelist,parlist,skyname,
template,
2927 skyname2 = cpl_sprintf(
"%s[%d]",skyname, i);
2928 for (j = 0; j < n; j++) {
2930 (void)snprintf(tmpname,BUFSIZ,
"tmp_%s",
2933 curframe = cpl_frameset_get_position(in,j);
2934 template = vircam_sci_findtemplate(curframe);
2936 "ESO DRS SKYCOR",skyname2);
2937 vircam_sci_save_simple(tmpfits,framelist,parlist,0,
template,
2938 isfirst,tag,tmpname,(product_frames+j));
2942 freefitslist(infits,n);
2946 cpl_msg_indent_less();
2947 for (i = 0; i < n; i++) {
2948 curframe = cpl_frameset_get_position(in,i);
2949 template = product_frames[i];
2950 remove(cpl_frame_get_filename(curframe));
2951 rename(cpl_frame_get_filename(
template),
2952 cpl_frame_get_filename(curframe));
2953 freeframe(product_frames[i]);
2955 freespace(product_frames);
2956 freefits(objmaskfits);
2997static int vircam_sci_pawsky_minus(cpl_frameset *framelist,
2998 cpl_parameterlist *parlist,
2999 cpl_frameset *in, cpl_frame *
template,
3000 const char *tag,
char *skyname,
3001 cpl_frame **skyframe) {
3002 int n,i,status,isfirst,j,k;
3003 casu_fits *objmaskfits,**infits,*inconf,*tmpfits,*skyout,*skyvar;
3004 cpl_frame **product_frames,*curframe;
3005 char tmpname[BUFSIZ], *skyname2 = NULL;
3006 const char *fctid =
"vircam_sci_pawsky_minus";
3008 n = cpl_frameset_get_size(in);
3009 if (ps.master_objmask != NULL)
3013 product_frames = cpl_malloc(n*
sizeof(cpl_frame *));
3014 cpl_msg_info(fctid,
"Creating sky %s",skyname);
3015 cpl_msg_indent_more();
3016 for (i = 1; i <= VIRCAM_NEXTN; i++) {
3017 cpl_msg_info(fctid,
"Beginning on extn %" CPL_SIZE_FORMAT
"",
3022 if (ps.master_objmask != NULL) {
3023 for (k = 0; k < n; k++)
3024 vircam_sci_wcsfit(infits+k,&inconf,NULL,1,1);
3027 &skyvar,&status) != CASU_OK) {
3028 freefitslist(infits,n);
3030 freespace(product_frames);
3034 vircam_sci_save_sky(skyout,framelist,parlist,skyname,
template,
3037 skyname2 = cpl_sprintf(
"%s[%d]",skyname, i);
3038 for (j = 0; j < n; j++) {
3040 (void)snprintf(tmpname,BUFSIZ,
"tmp_%s",
3043 curframe = cpl_frameset_get_position(in,j);
3044 template = vircam_sci_findtemplate(curframe);
3046 "ESO DRS SKYCOR",skyname2);
3047 vircam_sci_save_simple(tmpfits,framelist,parlist,0,
template,
3048 isfirst,tag,tmpname,(product_frames+j));
3052 freefitslist(infits,n);
3056 cpl_msg_indent_less();
3057 for (i = 0; i < n; i++) {
3058 curframe = cpl_frameset_get_position(in,i);
3059 template = product_frames[i];
3060 remove(cpl_frame_get_filename(curframe));
3061 rename(cpl_frame_get_filename(
template),
3062 cpl_frame_get_filename(curframe));
3063 freeframe(product_frames[i]);
3065 freespace(product_frames);
3066 freefits(objmaskfits);
3090static void vircam_sci_choose_skyalgo(
int *nskys, skystruct **skys) {
3093 int nalloc,i,n,n2,jst,jfn,j,j_1,j_2;
3095 cpl_frameset **in,*newfrmset;
3096 cpl_frame *frm,*
template;
3100 halfhour = 1.0/48.0;
3107 *skys = cpl_malloc(nalloc*
sizeof(skystruct));
3113 if (ps.noffpaws > 0) {
3114 if (vircam_sci_istile(cpl_frameset_get_position(ps.offsky_paws[0].orig,0))) {
3118 in = cpl_malloc(ps.noffpaws*
sizeof(cpl_frameset *));
3119 for (i = 0; i < ps.noffpaws; i++)
3120 in[i] = ps.offsky_paws[i].current;
3121 newfrmset = vircam_sci_merge_framesets(ps.noffpaws,in);
3126 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.offsky_paws[0].orig,0));
3127 newsky = vircam_sci_crsky(TILESKY,newfrmset,
template,1);
3129 (*skys)[*nskys-1] = newsky;
3134 for (i = 0; i < ps.noffpaws; i++)
3135 vircam_sci_assign_sky_all(ps.offsky_paws[i],*nskys-1);
3136 for (i = 0; i < ps.nscipaws; i++)
3137 vircam_sci_assign_sky_all(ps.science_paws[i],*nskys-1);
3139 newfrmset = cpl_frameset_duplicate(ps.offsky_paws[0].current);
3140 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.offsky_paws[0].orig,0));
3141 newsky = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,*nskys+1);
3143 (*skys)[*nskys-1] = newsky;
3144 vircam_sci_assign_sky_all(ps.offsky_paws[0],*nskys-1);
3145 vircam_sci_assign_sky_all(ps.science_paws[0],*nskys-1);
3158 if (ps.science_paws[0].tilenum == -1) {
3159 dt = ps.science_paws[0].mjd_end - ps.science_paws[0].mjd_start;
3160 n = cpl_frameset_get_size(ps.science_paws[0].current);
3165 if (dt < halfhour || n < 16) {
3166 newfrmset = cpl_frameset_duplicate(ps.science_paws[0].current);
3167 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[0].orig,0));
3168 newsky = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,
3171 (*skys)[*nskys-1] = newsky;
3172 vircam_sci_assign_sky_all(ps.science_paws[0],*nskys-1);
3179 for (i = 0; i < 2; i++) {
3187 newfrmset = cpl_frameset_new();
3188 for (j = jst; j < jfn; j++) {
3189 frm = cpl_frameset_get_position(ps.science_paws[0].current,j);
3190 cpl_frameset_insert(newfrmset,cpl_frame_duplicate(frm));
3192 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[0].orig,jst));
3193 newsky = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,
3196 if (*nskys > nalloc) {
3198 *skys = cpl_realloc(*skys,nalloc*
sizeof(skystruct));
3200 (*skys)[*nskys-1] = newsky;
3201 for (j = jst; j < jfn; j++)
3202 ps.science_paws[0].whichsky[j] = *nskys-1;
3211 dt = ps.science_paws[n-1].mjd_end - ps.science_paws[0].mjd_start;
3212 if (! strncmp(ps.science_paws[0].projname,VIDEOPROJ,10)) {
3214 for (j = 0; j < 2; j++) {
3222 in = cpl_malloc((j_2-j_1)*
sizeof(cpl_frameset *));
3223 for (i = j_1; i < j_2; i++)
3224 in[i-j_1] = ps.science_paws[i].current;
3225 newfrmset = vircam_sci_merge_framesets((j_2-j_1),in);
3227 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[j_1].orig,0));
3228 newsky = vircam_sci_crsky(TILESKY_MINUS,newfrmset,
template,
3231 if (*nskys > nalloc) {
3233 *skys = cpl_realloc(*skys,nalloc*
sizeof(skystruct));
3235 (*skys)[*nskys-1] = newsky;
3236 for (i = j_1; i < j_2; i++)
3237 vircam_sci_assign_sky_all(ps.science_paws[i],*nskys-1);
3244 }
else if (dt < halfhour ||
3245 ! strncmp(ps.science_paws[0].projname,VMCPROJ,10)) {
3246 in = cpl_malloc(ps.nscipaws*
sizeof(cpl_frameset *));
3247 for (i = 0; i < ps.nscipaws; i++)
3248 in[i] = ps.science_paws[i].current;
3249 newfrmset = vircam_sci_merge_framesets(ps.nscipaws,in);
3254 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[0].orig,0));
3255 newsky = vircam_sci_crsky(TILESKY,newfrmset,
template,1);
3257 (*skys)[*nskys-1] = newsky;
3261 for (i = 0; i < ps.nscipaws; i++)
3262 vircam_sci_assign_sky_all(ps.science_paws[i],*nskys-1);
3269 if (ps.science_paws[0].ispj) {
3271 for (j = 0; j < 2; j++) {
3279 in = cpl_malloc((j_2-j_1)*
sizeof(cpl_frameset *));
3280 for (i = j_1; i < j_2; i++)
3281 in[i-j_1] = ps.science_paws[i].current;
3282 newfrmset = vircam_sci_merge_framesets((j_2-j_1),in);
3284 template = cpl_frame_duplicate(cpl_frameset_get_position(ps.science_paws[j_1].orig,0));
3285 newsky = vircam_sci_crsky(TILESKY,newfrmset,
template,
3288 if (*nskys > nalloc) {
3290 *skys = cpl_realloc(*skys,nalloc*
sizeof(skystruct));
3292 (*skys)[*nskys-1] = newsky;
3293 for (i = j_1; i < j_2; i++)
3294 vircam_sci_assign_sky_all(ps.science_paws[i],
3330static int vircam_sci_ispj(cpl_frameset *frms) {
3331 int n,offnum,i,offnum1,offnum2;
3332 cpl_propertylist *plist,*tmp;
3338 plist = cpl_propertylist_new();
3343 n = cpl_frameset_get_size(frms);
3344 for (i = 0; i < n; i++) {
3345 frm = cpl_frameset_get_position(frms,i);
3346 tmp = cpl_propertylist_load(cpl_frame_get_filename(frm),0);
3347 strcpy(dateobs,cpl_propertylist_get_string(tmp,
"DATE-OBS"));
3348 offnum = cpl_propertylist_get_int(tmp,
"OFFSET_I");
3349 cpl_propertylist_append_int(plist,dateobs,offnum);
3350 cpl_propertylist_delete(tmp);
3356 cpl_propertylist_sort(plist,vircam_sci_cmp_property);
3361 offnum1 = cpl_property_get_int(cpl_propertylist_get(plist,0));
3362 offnum2 = cpl_property_get_int(cpl_propertylist_get(plist,1));
3363 cpl_propertylist_delete(plist);
3364 return(offnum1 == offnum2);
3388static int vircam_sci_cmp_property(
const cpl_property *p1,
3389 const cpl_property *p2) {
3390 return(strcmp(cpl_property_get_name(p1),cpl_property_get_name(p2)));
3413static void vircam_sci_assign_sky_all(pawprint paw,
int whichone) {
3416 n = cpl_frameset_get_size(paw.current);
3417 for (i = 0; i < n; i++)
3418 paw.whichsky[i] = whichone;
3444static skystruct vircam_sci_crsky(
int algorithm, cpl_frameset *frms,
3445 cpl_frame *
template,
int snum) {
3449 if (ps.master_objmask != NULL)
3450 s.objmask = cpl_frame_duplicate(ps.master_objmask);
3453 s.skyalgo = algorithm;
3455 s.template =
template;
3456 vircam_sci_product_name((
char *)cpl_frame_get_filename(cpl_frameset_get_position(frms,0)),
3457 SKY_FILE,vircam_sci_config.prettynames,snum,
3485static cpl_frameset *vircam_sci_merge_framesets(
int n, cpl_frameset **in) {
3492 new = cpl_frameset_new();
3496 for (i = 0; i < n; i++) {
3497 nf = cpl_frameset_get_size(in[i]);
3498 for (j = 0; j < nf; j++) {
3499 frm = cpl_frame_duplicate(cpl_frameset_get_position(in[i],j));
3500 cpl_frameset_insert(
new,frm);
3539static int vircam_sci_tilesky(cpl_frameset *framelist,
3540 cpl_parameterlist *parlist, cpl_frameset *in,
3541 cpl_frame *
template,
char *fname,
3542 cpl_frame **product_frame) {
3543 int j,nfiles,isfirst,status;
3544 const char *fctid=
"vircam_sci_tilesky";
3545 casu_fits **infits,*skyout;
3549 *product_frame = NULL;
3553 nfiles = cpl_frameset_get_size(in);
3554 cpl_msg_info(fctid,
"Creating sky %s",fname);
3555 cpl_msg_indent_more();
3556 for (j = 1; j <= VIRCAM_NEXTN; j++) {
3557 cpl_msg_info(fctid,
"Extension [%" CPL_SIZE_FORMAT
"]",(cpl_size)j);
3575 if (vircam_sci_save_sky(skyout,framelist,parlist,fname,
template,
3576 isfirst,product_frame) != CASU_OK) {
3577 freefitslist(infits,nfiles);
3584 freefitslist(infits,nfiles);
3587 cpl_msg_indent_less();
3624static int vircam_sci_pawsky_mask(cpl_frameset *framelist,
3625 cpl_parameterlist *parlist,
int algo,
3626 cpl_frameset *contrib, cpl_frame *
template,
3627 char *fname, cpl_frame **product_frame) {
3628 int j,nfiles,status,isfirst;
3629 const char *fctid=
"vircam_sci_pawsky_mask";
3630 casu_fits **infits,*conf,*skyout,*opmfits,*skyvar;
3634 *product_frame = NULL;
3638 nfiles = cpl_frameset_get_size(contrib);
3639 cpl_msg_info(fctid,
"Creating sky %s",fname);
3640 cpl_msg_indent_more();
3641 for (j = 1; j <= VIRCAM_NEXTN; j++) {
3642 cpl_msg_info(fctid,
"Extension [%" CPL_SIZE_FORMAT
"]",(cpl_size)j);
3658 if (algo == PAWSKY_MASK) {
3660 &skyvar,psm.niter,psm.ipix,psm.thresh,
3661 psm.nbsize,psm.smkern,&status);
3665 psm.nbsize,&skyout,&skyvar,&status);
3671 if (vircam_sci_save_sky(skyout,framelist,parlist,fname,
template,
3672 isfirst,product_frame) != CASU_OK) {
3673 freefitslist(infits,nfiles);
3681 freefitslist(infits,nfiles);
3685 cpl_msg_indent_less();
3710static int vircam_sci_save_sky(casu_fits *outsky, cpl_frameset *framelist,
3711 cpl_parameterlist *parlist,
3712 char *fname, cpl_frame *
template,
int isfirst,
3713 cpl_frame **product_frame) {
3714 cpl_propertylist *p;
3717 const char *fctid =
"vircam_sci_save_sky";
3732 *product_frame = cpl_frame_new();
3733 cpl_frame_set_filename(*product_frame,fname);
3734 cpl_frame_set_tag(*product_frame,VIRCAM_PRO_OFFSET_SKY);
3735 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_IMAGE);
3736 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
3737 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
3743 parlist,vircam_recipename,
3744 "PRO-1.15",
template,0);
3748 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,p,
3749 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
3750 cpl_msg_error(fctid,
"Cannot save product PHU");
3751 cpl_frame_delete(*product_frame);
3754 cpl_frameset_insert(framelist,*product_frame);
3766 vircam_recipename,
"PRO-1.15",
template);
3767 if (cpl_image_save(fim,fname,CPL_TYPE_FLOAT,p,CPL_IO_EXTEND) !=
3769 cpl_msg_error(fctid,
"Cannot save product image extension");
3775 cpl_propertylist_delete(p);
3803static int vircam_sci_cmp_jit(
const cpl_frame *frame1,
3804 const cpl_frame *frame2) {
3806 cpl_propertylist *pp;
3810 if (frame1 == NULL || frame2 == NULL)
3812 pp = cpl_propertylist_load(cpl_frame_get_filename(frame1),0);
3814 cpl_propertylist_delete(pp);
3815 pp = cpl_propertylist_load(cpl_frame_get_filename(frame2),0);
3817 cpl_propertylist_delete(pp);
3843static int vircam_sci_cmp_tstart(
const cpl_frame *frame1,
3844 const cpl_frame *frame2) {
3845 char ts1[80],ts2[80];
3846 cpl_propertylist *pp;
3850 if (frame1 == NULL || frame2 == NULL)
3856 pp = cpl_propertylist_load(cpl_frame_get_filename(frame1),0);
3858 cpl_propertylist_delete(pp);
3859 pp = cpl_propertylist_load(cpl_frame_get_filename(frame2),0);
3861 cpl_propertylist_delete(pp);
3865 if (strcmp(ts1,ts2))
3894static cpl_frameset *vircam_sci_update_frameset(cpl_frameset *frms,
int *nfrms_tot) {
3898 char *fname,bname[BUFSIZ];
3907 copy = cpl_frameset_duplicate(frms);
3911 n = cpl_frameset_get_size(frms);
3912 for (i = 0; i < n; i++) {
3913 fr = cpl_frameset_get_position(copy,i);
3914 fname = cpl_strdup(cpl_frame_get_filename(fr));
3916 vircam_sci_product_name(fname,SIMPLE_FILE,vircam_sci_config.prettynames,
3918 cpl_frame_set_filename(fr,basename(bname));
3951static int vircam_sci_testfrms(cpl_frameset *frms,
int nextn_expected,
3963 nf = cpl_frameset_get_size(frms);
3965 for (i = 0; i < nf; i++) {
3966 fr = cpl_frameset_get_position(frms,i);
3967 nerr += vircam_sci_testfrm_1(fr,nextn_expected,isimg);
4001static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg) {
4005 const char *fctid=
"vircam_sci_testfrm";
4015 nextn = cpl_frame_get_nextensions(fr);
4016 if (nextn != nextn_expected) {
4017 cpl_msg_error(fctid,
"Frame %s has %" CPL_SIZE_FORMAT
" extensions, expected %" CPL_SIZE_FORMAT
"\n",
4018 cpl_frame_get_filename(fr),(cpl_size)nextn,
4019 (cpl_size)nextn_expected);
4026 for (j = 1; j <= nextn; j++) {
4030 cpl_msg_error(fctid,
4031 "Frame image %s[%" CPL_SIZE_FORMAT
"] won't load\n",
4032 cpl_frame_get_filename(fr),(cpl_size)j);
4039 if (testt == NULL) {
4040 cpl_msg_error(fctid,
4041 "Frame table %s[%" CPL_SIZE_FORMAT
"] won't load\n",
4042 cpl_frame_get_filename(fr),(cpl_size)j);
4070static void vircam_sci_get_readnoise_gain(
int jext,
float *readnoise,
4072 cpl_propertylist *p_rg;
4073 const char *fctid =
"vircam_sci_get_readnoise_gain";
4077 p_rg = cpl_propertylist_load(cpl_frame_get_filename(ps.readgain_file),
4082 switch (cpl_propertylist_get_type(p_rg,
"ESO QC READNOISE")) {
4083 case CPL_TYPE_FLOAT:
4084 *readnoise = cpl_propertylist_get_float(p_rg,
"ESO QC READNOISE");
4086 case CPL_TYPE_DOUBLE:
4087 *readnoise = (float)cpl_propertylist_get_double(p_rg,
4088 "ESO QC READNOISE");
4093 cpl_msg_error(fctid,
"Unable to get READNOISE estimate, guessing %g\n",
4099 switch (cpl_propertylist_get_type(p_rg,
"ESO QC CONAD")) {
4100 case CPL_TYPE_FLOAT:
4101 *gain = cpl_propertylist_get_float(p_rg,
"ESO QC CONAD");
4103 case CPL_TYPE_DOUBLE:
4104 *gain = (float)cpl_propertylist_get_double(p_rg,
"ESO QC CONAD");
4109 cpl_msg_error(fctid,
"Unable to get GAIN estimate, guessing %g\n",
4112 cpl_propertylist_delete(p_rg);
4136static int vircam_sci_save_simple(casu_fits *obj, cpl_frameset *framelist,
4137 cpl_parameterlist *parlist,
int isprod,
4138 cpl_frame *
template,
int isfirst,
4139 const char *tag,
char *fname,
4140 cpl_frame **product_frame) {
4141 cpl_propertylist *plist;
4143 const char *fctid =
"vircam_sci_save_simple";
4145 cpl_ensure(product_frame != NULL, CPL_ERROR_NULL_INPUT, -1);
4155 if (access(fname,F_OK))
4160 *product_frame = cpl_frame_new();
4161 cpl_frame_set_filename(*product_frame,fname);
4165 cpl_frame_set_tag(*product_frame,tag);
4166 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_IMAGE);
4167 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
4168 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
4174 parlist,vircam_recipename,
4175 "PRO-1.15",
template,1);
4179 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,CPL_IO_DEFAULT) !=
4181 cpl_msg_error(fctid,
"Cannot save product PHU");
4182 cpl_frame_delete(*product_frame);
4186 cpl_frameset_insert(framelist,*product_frame);
4198 vircam_recipename,
"PRO-1.15",
template);
4200 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
4201 cpl_msg_error(fctid,
"Cannot save product image extension -- %s",
4202 cpl_error_get_message());
4232static int vircam_sci_save_stack(casu_fits *stack, cpl_frameset *framelist,
4233 cpl_parameterlist *parlist,
4234 cpl_frame *
template,
int fnametype,
4235 int stack_num, cpl_frame **product_frame) {
4236 cpl_propertylist *plist;
4237 int isfirst,isdummy;
4238 char fname[BUFSIZ],*base,*tname;
4239 const char *fctid =
"vircam_sci_save_stack";
4244 isfirst = (*product_frame == NULL);
4245 tname = cpl_strdup(cpl_frame_get_filename(
template));
4246 base = basename(tname);
4247 vircam_sci_product_name(base,STACK_FILE,fnametype,stack_num,fname);
4254 if (access(fname,F_OK))
4259 *product_frame = cpl_frame_new();
4260 cpl_frame_set_filename(*product_frame,fname);
4264 cpl_frame_set_tag(*product_frame,VIRCAM_PRO_JITTERED_SCI);
4265 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_IMAGE);
4266 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
4267 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
4275 "PRO-1.15",
template,1);
4279 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
4280 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
4281 cpl_msg_error(fctid,
"Cannot save product PHU");
4282 cpl_frame_delete(*product_frame);
4285 cpl_frameset_insert(framelist,*product_frame);
4297 parlist,vircam_recipename,
4298 "PRO-1.15",
template);
4300 plist,CPL_IO_EXTEND) != CPL_ERROR_NONE) {
4301 cpl_msg_error(fctid,
"Cannot save product image extension -- %s",
4302 cpl_error_get_message());
4332static int vircam_sci_save_stack_conf(casu_fits *stack, cpl_frameset *framelist,
4333 cpl_parameterlist *parlist,
4334 cpl_frame *
template,
int fnametype,
4336 cpl_frame **product_frame) {
4337 cpl_propertylist *plist;
4338 int isfirst,isdummy;
4339 char fname[BUFSIZ],*tname,*base;
4340 const char *fctid =
"vircam_sci_save_stack_conf";
4345 isfirst = (*product_frame == NULL);
4346 tname = cpl_strdup(cpl_frame_get_filename(
template));
4347 base = basename(tname);
4348 vircam_sci_product_name(base,STACK_CONF,fnametype,stack_num,fname);
4355 if (access(fname,F_OK))
4360 *product_frame = cpl_frame_new();
4361 cpl_frame_set_filename(*product_frame,fname);
4365 cpl_frame_set_tag(*product_frame,VIRCAM_PRO_CONF_SCI);
4366 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_IMAGE);
4367 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
4368 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
4374 parlist,vircam_recipename,
4375 "PRO-1.15",
template,1);
4379 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
4380 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
4381 cpl_msg_error(fctid,
"Cannot save product PHU");
4382 cpl_frame_delete(*product_frame);
4385 cpl_frameset_insert(framelist,*product_frame);
4397 parlist,vircam_recipename,
4398 "PRO-1.15",
template);
4400 plist,CPL_IO_EXTEND) != CPL_ERROR_NONE) {
4401 cpl_msg_error(fctid,
"Cannot save product image extension -- %s",
4402 cpl_error_get_message());
4432static int vircam_sci_save_stack_cat(casu_tfits *stack, cpl_frameset *framelist,
4433 cpl_parameterlist *parlist,
4434 cpl_frame *
template,
int fnametype,
4435 int stack_num, cpl_frame **product_frame) {
4436 cpl_propertylist *plist;
4437 int isfirst,isdummy;
4438 char fname[BUFSIZ],*tname,*base;
4439 const char *fctid =
"vircam_sci_save_stack_cat";
4444 isfirst = (*product_frame == NULL);
4445 tname = cpl_strdup(cpl_frame_get_filename(
template));
4446 base = basename(tname);
4447 vircam_sci_product_name(base,STACK_CAT,fnametype,stack_num,fname);
4454 if (access(fname,F_OK))
4459 *product_frame = cpl_frame_new();
4460 cpl_frame_set_filename(*product_frame,fname);
4464 cpl_frame_set_tag(*product_frame,VIRCAM_PRO_OBJCAT_SCI);
4465 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_TABLE);
4466 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
4467 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
4473 parlist,vircam_recipename,
4478 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
4479 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
4480 cpl_msg_error(fctid,
"Cannot save product PHU");
4481 cpl_frame_delete(*product_frame);
4484 cpl_frameset_insert(framelist,*product_frame);
4496 parlist,vircam_recipename,
4499 plist,fname,CPL_IO_EXTEND) != CPL_ERROR_NONE) {
4500 cpl_msg_error(fctid,
"Cannot save product table extension -- %s",
4501 cpl_error_get_message());
4541static void vircam_sci_product_name(
char *
template,
int producttype,
4542 int nametype,
int fnumber,
char *outfname) {
4543 const char *esonames[] = {
"exp_",
"exp_conf_",
"exp_cat_",
"stack_",
4544 "stack_conf_",
"stack_cat_",
"sky_"};
4545 const char *suffix[] = {
"_ex",
"_ex_conf",
"_ex_cat",
"_st",
"_st_conf",
4547 char *fname,*bname,*dot;
4554 (void)sprintf(outfname,
"%s%d.fits",esonames[producttype],fnumber);
4561 fname = cpl_strdup(
template);
4562 bname = basename(fname);
4563 (void)sprintf(outfname,
"tmp_%s",bname);
4570 fname = cpl_strdup(
template);
4571 bname = basename(fname);
4572 if (producttype != SKY_FILE) {
4573 (void)sprintf(outfname,
"%s",bname);
4574 dot = strrchr(outfname,
'.');
4575 (void)sprintf(dot,
"%s.fits",suffix[producttype]);
4577 sprintf(outfname,
"%s%s",suffix[producttype],bname);
4585 (void)strcpy(outfname,
"");
4610static void vircam_sci_init(
void) {
4615 ps.master_dark = NULL;
4616 ps.master_twilight_flat = NULL;
4617 ps.master_conf = NULL;
4618 ps.master_sky = NULL;
4619 ps.master_objmask = NULL;
4624 ps.readgain_file = NULL;
4625 ps.science_frames = NULL;
4626 ps.offset_skies = NULL;
4627 ps.product_frames_simple = NULL;
4628 ps.product_frames_simple_off = NULL;
4634 ps.science_paws = NULL;
4636 ps.offsky_paws = NULL;
4650 ps.offsky_fits = NULL;
4676static void vircam_sci_tidy(
int level) {
4685 freetfits(ps.fchantab);
4686 freefitslist(ps.sci_fits,ps.nscience);
4687 freefitslist(ps.offsky_fits,ps.noffsets);
4695 freespace(ps.labels);
4696 freeframe(ps.master_dark);
4697 freeframe(ps.master_twilight_flat);
4698 freeframe(ps.master_conf);
4699 freeframe(ps.master_sky);
4700 freeframe(ps.master_objmask);
4702 freeframe(ps.chantab);
4703 freeframe(ps.phottab);
4704 freeframe(ps.readgain_file);
4705 freetable(ps.tphottab);
4706 freeframeset(ps.science_frames);
4707 freeframeset(ps.offset_skies);
4708 freepropertylist(ps.phupaf);
4709 freespace(ps.product_frames_simple);
4712 freespace(ps.product_frames_simple_off);
4713 freespace(ps.gaincors);
4714 freespace(ps.catpath);
4715 freespace(ps.catname);
4716 for (i = 0; i < ps.nskys; i++) {
4717 freeframeset(ps.skys[i].contrib);
4718 freeframe(ps.skys[i].objmask);
4719 freeframe(ps.skys[i].template);
4722 freepaws(ps.science_paws,ps.nscipaws);
4723 freepaws(ps.offsky_paws,ps.noffpaws);
4724 freeframe(ps.schlf_n);
4725 freeframe(ps.schlf_s);
int casu_fits_get_status(casu_fits *p)
void casu_fits_set_filename(casu_fits *p, char *fname)
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)
int casu_fits_set_error(casu_fits *p, int status)
char * casu_fits_get_fullname(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)
int casu_fits_get_nexten(casu_fits *p)
casu_fits * casu_fits_load(cpl_frame *frame, cpl_type type, int nexten)
unsigned char * casu_mask_get_data(casu_mask *m)
int casu_mask_get_size_y(casu_mask *m)
int casu_mask_load(casu_mask *m, int nexten, int nx, int ny)
casu_mask * casu_mask_define(cpl_frameset *framelist, cpl_size *labels, cpl_size nlab, const char *conftag, const char *bpmtag)
int casu_mask_get_size_x(casu_mask *m)
int casu_imcore(casu_fits *infile, casu_fits *conf, int ipix, float threshold, int icrowd, float rcore, int nbsize, int cattype, float filtfwhm, casu_tfits **outtab, float gainloc, int *status)
Generate object catalogues from input images.
int casu_flatcor(casu_fits *infile, casu_fits *flatsrc, int *status)
Correct input data for flat field response.
int casu_nditcor(casu_fits *infile, int ndit, const char *expkey, int *status)
Correct input data for number of dits.
int casu_darkcor(casu_fits *infile, casu_fits *darksrc, float darkscl, int *status)
Correct input data for dark current.
int casu_imstack(casu_fits **inf, casu_fits **inconf, casu_fits **invar, casu_tfits **cats, int nimages, int nconfs, float lthr, float hthr, int method, int seeing, int fast, int unmap, const char *expkey, casu_fits **out, casu_fits **outc, casu_fits **outv, int *status)
Stack images into a mean image using WCS info.
int casu_pawsky_mask_pre(casu_fits **inlist, casu_fits **invar, int nfiles, casu_mask *mask, casu_fits *objmask, int nbsize, casu_fits **skyout, casu_fits **skyvar, int *status)
Work out a sky estimate from an input jitter series and a pre-existing object mask.
int casu_matchstds(cpl_table *objtab, cpl_table *stdstab, float srad, cpl_table **outtab, int *status)
Match object and standard star tables by their xy coordinates.
int casu_gaincor(casu_fits *infile, float gainscl, int *status)
Gain correct input data frame.
int casu_photcal_extinct(casu_fits **images, casu_tfits **mstds, casu_tfits **cats, int nimages, char *filt, cpl_table *phottab, int minstars, cpl_frame *schlf_n, cpl_frame *schlf_s, const char *expkey, const char *amkey, float magerrcut, int *status)
Do photometric calibration.
int casu_platesol(cpl_propertylist *plist, cpl_propertylist *tlist, cpl_table *matchedstds, int nconst, int shiftan, int *status)
Work out a WCS for an image.
int casu_pawsky_mask(casu_fits **inlist, casu_fits **invar, int nfiles, casu_fits *conf, casu_mask *mask, casu_fits **skyout, casu_fits **skyvar, int niter, int ipix, float thresh, int nbsize, float smkern, int *status)
Work out a masked sky estimate from an input jitter series.
int casu_pawsky_minus(casu_fits **infiles, casu_fits **invar, casu_fits *conf, casu_fits *objmaskfits, int nfiles, casu_fits **skyout, casu_fits **skyvar, int *status)
Background correct images using pawsky_minus algorithm.
int casu_getstds(cpl_propertylist *plist, int cache, char *path, char *catname, int cdssearch, char *cacheloc, cpl_table **stds, int *status)
Get a table of standard stars that appear on an image from a catalogue.
void casu_medmad(float *data, unsigned char *bpm, long np, float *med, float *mad)
float casu_med(float *data, unsigned char *bpm, long npts)
void casu_qmedsig(float *data, unsigned char *bpm, long npts, float thresh, int niter, float lowv, float highv, float *median, float *sigma)
void casu_medmadcut(float *data, unsigned char *bpm, long np, float lcut, float hcut, float *med, float *mad)
cpl_propertylist * casu_tfits_get_ehu(casu_tfits *p)
casu_tfits * casu_tfits_wrap(cpl_table *tab, casu_tfits *model, cpl_propertylist *phu, cpl_propertylist *ehu)
int casu_tfits_get_status(casu_tfits *p)
casu_tfits * casu_tfits_load(cpl_frame *table, int nexten)
cpl_propertylist * casu_tfits_get_phu(casu_tfits *p)
cpl_table * casu_tfits_get_table(casu_tfits *p)
int casu_compare_tags(const cpl_frame *frame1, const cpl_frame *frame2)
Compare input tags.
int casu_catpars(cpl_frame *indx, char **catpath, char **catname)
Find the name of the standard catalogue and its location.
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.
int casu_gaincor_calc(cpl_frame *frame, int *n, float **cors, int *status)
Work out gain corrections.
cpl_frameset * casu_frameset_subgroup(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
Extract a frameset from another frameset.
void casu_xytoradec(cpl_wcs *wcs, double x, double y, double *ra, double *dec)
int vircam_tilesky(casu_fits **inlist, int nfiles, casu_mask *mask, casu_fits **skyout, int *status)
Work sky estimate from an input tile series.
int vircam_lincor(casu_fits *infile, casu_tfits *lchantab, int kconst, int ndit, int *status)
Apply linearity curves to data.
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_gain(const cpl_propertylist *plist, float *gain)
Get the value of the detector gain.
int vircam_pfits_get_jitternum(const cpl_propertylist *plist, int *jitternum)
Get the value of the first run number in the current jitter sequence.
int vircam_pfits_get_mjd(const cpl_propertylist *plist, double *mjd)
Get the value of the modified Julian date.
int vircam_pfits_get_projid(const cpl_propertylist *plist, char *projid)
Get the project id.
int vircam_pfits_get_dit(const cpl_propertylist *plist, float *dit)
Get the value of DIT.
int vircam_pfits_get_detlive(const cpl_propertylist *plist, int *detlive)
Get the value of DET_LIVE.
int vircam_pfits_get_njsteps(const cpl_propertylist *plist, int *njsteps)
Get the value of the number of observations in a jitter sequence.
int vircam_pfits_get_tplstart(cpl_propertylist *plist, char *tplstart)
Get the value of template start time.
int vircam_pfits_get_exptime(const cpl_propertylist *plist, float *exptime)
Get the value of exposure time.
int vircam_pfits_get_filter(const cpl_propertylist *plist, char *filt)
Get the name of the current filter.
int vircam_pfits_get_offsetnum(const cpl_propertylist *plist, int *offsetnum)
Get the value of the first run number in the current tile sequence.
const char * vircam_get_license(void)
int vircam_check_crval(cpl_propertylist *phu, cpl_propertylist *ehu)
void vircam_copywcs(cpl_propertylist *p1, cpl_propertylist *p2)