41 #include <casu_utils.h>
42 #include <casu_mask.h>
43 #include <casu_mods.h>
44 #include <casu_wcsutils.h>
45 #include <casu_stats.h>
46 #include <casu_filt.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;
188 #define PAWSKY_MASK 1
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;}
200 char current_cat[VIRCAM_PATHSZ];
201 char current_catpath[VIRCAM_PATHSZ];
202 char vircam_recipename[VIRCAM_PATHSZ];
203 char vircam_recipepaf[VIRCAM_PATHSZ];
204 cpl_propertylist *dummyqc = NULL;
209 static int vircam_science_process_create(cpl_plugin *plugin);
210 static int vircam_science_process_exec(cpl_plugin *plugin);
211 static int vircam_science_process_destroy(cpl_plugin *plugin);
212 static int vircam_science_process(cpl_parameterlist *parlist,
213 cpl_frameset *framelist);
217 static void vircam_sci_paw_init(pawprint *paw, cpl_frameset *frms,
int ispj,
219 static void vircam_sci_paw_delete(pawprint *paws);
220 static void vircam_sci_paws_delete(
int npaws, pawprint **paws);
221 static void vircam_sci_paws_create(cpl_frameset *infrms,
int *npaws,
226 static int vircam_sci_sky_stripe_wcs(
int npaw, pawprint *paw,
const char *tag,
227 cpl_frameset *framelist,
228 cpl_parameterlist *parlist,
int destripe);
229 static void vircam_sci_cat(pawprint *paw,
int extn);
230 static void vircam_sci_stack(pawprint *paw,
int extn);
231 static void vircam_sci_wcsfit(casu_fits **in, casu_fits **conf,
232 casu_tfits **incat,
int nf,
int level);
233 static void vircam_sci_init(
void);
234 static void vircam_sci_tidy(
int level);
235 static int vircam_destripe_four(casu_fits **curfits,
int stripefilt,
237 static void stripe_profile(casu_fits *in,
int stripefilt,
float *profile,
238 unsigned char *pbpm);
239 static void vircam_sci_photcal(pawprint *paw);
243 static void vircam_sci_choose_skyalgo(
int *nskys, skystruct **skys);
244 static int vircam_sci_makesky(cpl_frameset *framelist,
245 cpl_parameterlist *parlist, skystruct *sky,
247 static void vircam_sci_assign_sky_all(pawprint paw,
int whichone);
248 static skystruct vircam_sci_crsky(
int algorithm, cpl_frameset *frms,
249 cpl_frame *
template,
int snum);
250 static void vircam_sci_skydefine(
void);
251 static int vircam_sci_tilesky(cpl_frameset *framelist,
252 cpl_parameterlist *parlist, cpl_frameset *in,
254 char *fname, cpl_frame **product_frame);
255 static 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);
259 static 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);
264 static 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);
272 static cpl_frame *vircam_sci_findtemplate(cpl_frame *in);
273 static int vircam_sci_istile(cpl_frame *frm);
274 static int vircam_sci_ispj(cpl_frameset *frms);
275 static int vircam_sci_cmp_jit(
const cpl_frame *frame1,
276 const cpl_frame *frame2);
277 static int vircam_sci_cmp_tstart(
const cpl_frame *frame1,
278 const cpl_frame *frame2);
279 static int vircam_sci_cmp_property(
const cpl_property *p1,
280 const cpl_property *p2);
281 static cpl_frameset *vircam_sci_merge_framesets(
int n, cpl_frameset **in);
282 static cpl_frameset *vircam_sci_update_frameset(cpl_frameset *frms,
int *nfrms_tot);
283 static int vircam_sci_testfrms(cpl_frameset *frms,
int nextn_expected,
285 static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg);
286 static void vircam_sci_get_readnoise_gain(
int jext,
float *readnoise,
288 static void vircam_sci_product_name(
char *
template,
int producttype,
289 int nametype,
int fnumber,
char *outfname);
293 static 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);
298 static 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);
302 static 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);
306 static 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);
310 static 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);
316 static 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"
534 int 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);
576 static 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);
837 static 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));
858 static 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);
881 static 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();
1614 static 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);
1647 static 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);
1816 static 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;
1851 static 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;
1921 static 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();
2092 static 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));
2147 static 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);
2303 static 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);
2438 static 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++)
2540 static void vircam_sci_paws_delete(
int npaws, pawprint **paws) {
2543 for (i = 0; i < npaws; i++)
2544 vircam_sci_paw_delete(*paws+i);
2566 static 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]);
2604 static 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);
2689 static 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);
2729 static 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);
2815 static 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));
2894 static 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);
2997 static 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);
3090 static 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],
3330 static 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);
3388 static 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)));
3413 static 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;
3444 static 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,
3485 static 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);
3539 static 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();
3624 static 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();
3710 static 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);
3803 static 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);
3843 static 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))
3894 static 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));
3951 static 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);
4001 static 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);
4070 static 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);
4136 static 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());
4232 static 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());
4332 static 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());
4432 static 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());
4541 static 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,
"");
4610 static 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;
4676 static 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)
cpl_image * casu_fits_get_image(casu_fits *p)
void casu_fits_set_filename(casu_fits *p, char *fname)
casu_fits * casu_fits_load(cpl_frame *frame, cpl_type type, int nexten)
casu_fits ** casu_fits_load_list(cpl_frameset *f, cpl_type type, int exten)
char * casu_fits_get_filename(casu_fits *p)
char * casu_fits_get_fullname(casu_fits *p)
void casu_fits_delete(casu_fits *p)
casu_fits * casu_fits_duplicate(casu_fits *in)
int casu_fits_set_error(casu_fits *p, int status)
cpl_propertylist * casu_fits_get_phu(casu_fits *p)
int casu_fits_get_nexten(casu_fits *p)
cpl_propertylist * casu_fits_get_ehu(casu_fits *p)
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)
int casu_tfits_get_status(casu_tfits *p)
cpl_table * casu_tfits_get_table(casu_tfits *p)
cpl_propertylist * casu_tfits_get_phu(casu_tfits *p)
cpl_propertylist * casu_tfits_get_ehu(casu_tfits *p)
casu_tfits * casu_tfits_load(cpl_frame *table, int nexten)
casu_tfits * casu_tfits_wrap(cpl_table *tab, casu_tfits *model, cpl_propertylist *phu, cpl_propertylist *ehu)
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_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_frameset * casu_frameset_subgroup(cpl_frameset *frameset, cpl_size *labels, cpl_size nlab, const char *tag)
Extract a frameset from another frameset.
int casu_gaincor_calc(cpl_frame *frame, int *n, float **cors, int *status)
Work out gain corrections.
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.
int vircam_check_crval(cpl_propertylist *phu, cpl_propertylist *ehu)
void vircam_copywcs(cpl_propertylist *p1, cpl_propertylist *p2)
const char * vircam_get_license(void)