41 #include "vircam_utils.h"
42 #include "vircam_mask.h"
43 #include "vircam_pfits.h"
44 #include "vircam_dfs.h"
45 #include "vircam_mods.h"
46 #include "vircam_fits.h"
47 #include "vircam_tfits.h"
48 #include "vircam_paf.h"
49 #include "vircam_sky.h"
50 #include "vircam_filt.h"
51 #include "vircam_stats.h"
52 #include "vircam_wcsutils.h"
54 #define VIRCAM_PATHSZ 128
55 #define VIRCAM_NEXTN 16
58 cpl_frameset *contrib;
67 cpl_frameset *current;
70 vir_fits *stack[VIRCAM_NEXTN];
71 vir_fits *stackc[VIRCAM_NEXTN];
72 vir_tfits *cat[VIRCAM_NEXTN];
73 cpl_table *mstds[VIRCAM_NEXTN];
74 cpl_frame *product_frame_im;
75 cpl_frame *product_frame_conf;
76 cpl_frame *product_frame_cat;
130 cpl_frame *master_dark;
131 cpl_frame *master_twilight_flat;
132 cpl_frame *master_conf;
133 cpl_frame *master_sky;
134 cpl_frame *master_objmask;
139 cpl_frame *readgain_file;
140 cpl_frameset *science_frames;
141 cpl_frameset *offset_skies;
142 cpl_frame **product_frames_simple;
143 cpl_frame **product_frames_simple_off;
144 cpl_propertylist *phupaf;
149 pawprint *science_paws;
151 pawprint *offsky_paws;
168 vir_fits **offsky_fits;
185 #define PAWSKY_MASK 1
186 #define PAWSKY_MASK_PRE 2
188 #define TILESKY_MINUS 4
190 #define PAWSKY_MINUS 6
192 #define VMCPROJ "179.B-2003"
193 #define VIDEOPROJ "179.A-2006"
195 #define freepaws(_p,_n) if (_p != NULL) {vircam_sci_paws_delete(_n,&(_p)); _p = NULL; _n = 0;}
197 char current_cat[VIRCAM_PATHSZ];
198 char current_catpath[VIRCAM_PATHSZ];
199 char vircam_recipename[VIRCAM_PATHSZ];
200 char vircam_recipepaf[VIRCAM_PATHSZ];
201 cpl_propertylist *dummyqc = NULL;
206 static int vircam_science_process_create(cpl_plugin *plugin);
207 static int vircam_science_process_exec(cpl_plugin *plugin);
208 static int vircam_science_process_destroy(cpl_plugin *plugin);
209 static int vircam_science_process(cpl_parameterlist *parlist,
210 cpl_frameset *framelist);
214 static void vircam_sci_paw_init(pawprint *paw, cpl_frameset *frms,
int ispj);
215 static void vircam_sci_paw_delete(pawprint *paws);
216 static void vircam_sci_paws_delete(
int npaws, pawprint **paws);
217 static void vircam_sci_paws_create(cpl_frameset *infrms,
int *npaws,
222 static int vircam_sci_sky_stripe_wcs(
int npaw, pawprint *paw,
const char *tag,
223 cpl_frameset *framelist,
224 cpl_parameterlist *parlist);
225 static void vircam_sci_cat(pawprint *paw,
int extn);
226 static void vircam_sci_stack(pawprint *paw,
int extn);
227 static void vircam_sci_wcsfit(vir_fits **in, vir_fits **conf,
228 vir_tfits **incat,
int nf,
int level);
229 extern void vircam_sci_init(
void);
230 extern void vircam_sci_tidy(
int level);
231 static int vircam_destripe_four(vir_fits **curfits,
int stripefilt,
233 static void stripe_profile(vir_fits *in,
int stripefilt,
float *profile,
234 unsigned char *pbpm);
235 static void vircam_sci_photcal(pawprint *paw);
239 static void vircam_sci_choose_skyalgo(
int *nskys, skystruct **skys);
240 static int vircam_sci_makesky(cpl_frameset *framelist,
241 cpl_parameterlist *parlist, skystruct *sky,
243 static void vircam_sci_assign_sky_all(pawprint paw,
int whichone);
244 static skystruct vircam_sci_crsky(
int algorithm, cpl_frameset *frms,
245 cpl_frame *
template,
int snum);
246 static void vircam_sci_skydefine(
void);
247 static int vircam_sci_tilesky(cpl_frameset *framelist,
248 cpl_parameterlist *parlist, cpl_frameset *in,
250 char *fname, cpl_frame **product_frame);
251 static int vircam_sci_pawsky_mask(cpl_frameset *framelist,
252 cpl_parameterlist *parlist,
int algo,
253 cpl_frameset *contrib, cpl_frame *
template,
254 char *fname, cpl_frame **product_frame);
255 static int vircam_sci_tilesky_minus(cpl_frameset *framelist,
256 cpl_parameterlist *parlist,
257 cpl_frameset *in, cpl_frame *
template,
258 const char *tag,
char *fname,
259 cpl_frame **skyframe);
260 static int vircam_sci_pawsky_minus(cpl_frameset *framelist,
261 cpl_parameterlist *parlist,
262 cpl_frameset *in, cpl_frame *
template,
263 const char *tag,
char *skyname,
264 cpl_frame **skyframe);
268 static cpl_frame *vircam_sci_findtemplate(cpl_frame *in);
269 static int vircam_sci_istile(cpl_frame *frm);
270 static int vircam_pfits_get_tplstart(cpl_propertylist *plist,
char *tplstart);
271 static int vircam_sci_ispj(cpl_frameset *frms);
272 static int vircam_sci_cmp_jit(
const cpl_frame *frame1,
273 const cpl_frame *frame2);
274 static int vircam_sci_cmp_tstart(
const cpl_frame *frame1,
275 const cpl_frame *frame2);
276 static int vircam_sci_cmp_property(
const cpl_property *p1,
277 const cpl_property *p2);
278 static cpl_frameset *vircam_sci_merge_framesets(
int n, cpl_frameset **in);
279 static cpl_frameset *vircam_sci_update_frameset(cpl_frameset *frms);
280 static int vircam_sci_testfrms(cpl_frameset *frms,
int nextn_expected,
282 static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg);
283 extern void vircam_sci_get_readnoise_gain(
int jext,
float *readnoise,
285 static void vircam_sci_product_name(
char *
template,
int producttype,
286 int nametype,
int fnumber,
char *outfname);
290 extern int vircam_sci_save_simple(vir_fits *obj, cpl_frameset *framelist,
291 cpl_parameterlist *parlist,
int isprod,
292 cpl_frame *
template,
int isfirst,
293 const char *tag,
char *fname,
294 cpl_frame **product_frame);
295 extern int vircam_sci_save_sky(vir_fits *outsky, cpl_frameset *framelist,
296 cpl_parameterlist *parlist,
297 char *fname, cpl_frame *
template,
int isfirst,
298 cpl_frame **product_frame);
299 extern int vircam_sci_save_stack(vir_fits *stack, cpl_frameset *framelist,
300 cpl_parameterlist *parlist,
301 cpl_frame *
template,
int fnametype,
302 int stack_num, cpl_frame **product_frame);
303 extern int vircam_sci_save_stack_conf(vir_fits *stack, cpl_frameset *framelist,
304 cpl_parameterlist *parlist,
305 cpl_frame *
template,
int fnametype,
306 int stack_num, cpl_frame **product_frame);
307 extern int vircam_sci_save_stack_cat(vir_tfits *stack, cpl_frameset *framelist,
308 cpl_parameterlist *parlist,
309 cpl_frame *
template,
int fnametype,
310 int stack_num, cpl_frame **product_frame);
313 static char vircam_science_process_description[] =
314 "vircam_science_process -- VIRCAM science product recipe.\n\n"
315 "Process a complete pawprint for VIRCAM data. Remove instrumental\n"
316 "signature, background correct, combine jitters, photometrically\n"
317 "and astrometrically calibrate the pawprint image\n\n"
318 "The program accepts the following files in the SOF:\n\n"
320 " -----------------------------------------------------------------------\n"
321 " %-22s A list of raw science images or\n"
322 " %-22s A list of raw science images (extended)\n"
323 " %-22s A list of offset sky exposures (optional)\n"
324 " %-22s A master dark frame\n"
325 " %-22s A master twilight flat frame\n"
326 " %-22s A master sky frame (optional)\n"
327 " %-22s A channel table\n"
328 " %-22s A photometric calibration table\n"
329 " %-22s A readnoise/gain file\n"
330 " %-22s A master confidence map\n"
331 " %-22s A master standard star index\n"
332 " %-22s Northern Schlegel Map\n"
333 " %-22s Southern Schlegel Map\n"
334 "All of the above are required unless otherwise specified\n"
347 int cpl_plugin_get_info(cpl_pluginlist *list) {
348 cpl_recipe *recipe = cpl_calloc(1,
sizeof(*recipe));
349 cpl_plugin *plugin = &recipe->interface;
350 char alldesc[SZ_ALLDESC];
351 (void)snprintf(alldesc,SZ_ALLDESC,
352 vircam_science_process_description,
353 VIRCAM_SCI_OBJECT_RAW,VIRCAM_SCI_OBJECT_EXT_RAW,
354 VIRCAM_OFFSET_SKY_RAW,VIRCAM_CAL_DARK,
355 VIRCAM_CAL_TWILIGHT_FLAT,VIRCAM_CAL_SKY,VIRCAM_CAL_CHANTAB,
356 VIRCAM_CAL_PHOTTAB,VIRCAM_CAL_READGAINFILE,VIRCAM_CAL_CONF,
357 VIRCAM_CAL_2MASS,VIRCAM_CAL_SCHL_N,VIRCAM_CAL_SCHL_S);
359 cpl_plugin_init(plugin,
361 VIRCAM_BINARY_VERSION,
362 CPL_PLUGIN_TYPE_RECIPE,
363 "vircam_science_process",
364 "VIRCAM science recipe",
369 vircam_science_process_create,
370 vircam_science_process_exec,
371 vircam_science_process_destroy);
373 cpl_pluginlist_append(list,plugin);
389 static int vircam_science_process_create(cpl_plugin *plugin) {
395 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
396 recipe = (cpl_recipe *)plugin;
402 recipe->parameters = cpl_parameterlist_new();
406 p = cpl_parameter_new_value(
"vircam.vircam_science_process.savecat",
407 CPL_TYPE_BOOL,
"Save catalogue?",
408 "vircam.vircam_science_process",1);
409 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"savecat");
410 cpl_parameterlist_append(recipe->parameters,p);
414 p = cpl_parameter_new_value(
"vircam.vircam_science_process.destripe",
415 CPL_TYPE_BOOL,
"Destripe images?",
416 "vircam.vircam_science_process",1);
417 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"destripe");
418 cpl_parameterlist_append(recipe->parameters,p);
422 p = cpl_parameter_new_enum(
"vircam.vircam_science_process.skyalgo",
423 CPL_TYPE_INT,
"Sky subtraction algorithm",
424 "vircam.vircam_science_process",1,8,-1,0,1,2,3,4,5,6);
425 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"skyalgo");
426 cpl_parameterlist_append(recipe->parameters,p);
431 p = cpl_parameter_new_value(
"vircam.vircam_science_process.preview_only",
432 CPL_TYPE_BOOL,
"Preview only?",
433 "vircam.vircam_science_process",0);
434 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"preview_only");
435 cpl_parameterlist_append(recipe->parameters,p);
440 p = cpl_parameter_new_value(
"vircam.vircam_science_process.minphotom",
442 "Minimum stars for photometry solution",
443 "vircam.vircam_science_process",0);
444 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"minphotom");
445 cpl_parameterlist_append(recipe->parameters,p);
450 p = cpl_parameter_new_value(
"vircam.vircam_science_process.prettynames",
451 CPL_TYPE_BOOL,
"Use pretty product names?",
452 "vircam.vircam_science_process",0);
453 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"prettynames");
454 cpl_parameterlist_append(recipe->parameters,p);
460 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_cat_ipix",
462 "Minimum pixel area for each detected object",
463 "vircam.vircam_science_process",5);
464 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_ipix");
465 cpl_parameterlist_append(recipe->parameters,p);
469 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_cat_thresh",
471 "Detection threshold in sigma above sky",
472 "vircam.vircam_science_process",2.0);
473 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_thresh");
474 cpl_parameterlist_append(recipe->parameters,p);
478 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_cat_icrowd",
479 CPL_TYPE_BOOL,
"Use deblending?",
480 "vircam.vircam_science_process",1);
481 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_icrowd");
482 cpl_parameterlist_append(recipe->parameters,p);
486 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_cat_rcore",
487 CPL_TYPE_DOUBLE,
"Value of Rcore in pixels",
488 "vircam.vircam_science_process",3.0);
489 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_rcore");
490 cpl_parameterlist_append(recipe->parameters,p);
494 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_cat_nbsize",
495 CPL_TYPE_INT,
"Background smoothing box size",
496 "vircam.vircam_science_process",64);
497 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_cat_nbsize");
498 cpl_parameterlist_append(recipe->parameters,p);
504 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_lthr",
505 CPL_TYPE_DOUBLE,
"Low rejection threshold",
506 "vircam.vircam_science_process",3.0);
507 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_lthr");
508 cpl_parameterlist_append(recipe->parameters,p);
512 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_hthr",
513 CPL_TYPE_DOUBLE,
"Upper rejection threshold",
514 "vircam.vircam_science_process",3.0);
515 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_hthr");
516 cpl_parameterlist_append(recipe->parameters,p);
520 p = cpl_parameter_new_enum(
"vircam.vircam_science_process.stk_method",
521 CPL_TYPE_INT,
"Stacking method",
522 "vircam.vircam_science_process",1,2,0,1);
523 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_method");
524 cpl_parameterlist_append(recipe->parameters,p);
528 p = cpl_parameter_new_value(
"vircam.vircam_science_process.stk_seeing",
529 CPL_TYPE_BOOL,
"Weight by seeing?",
530 "vircam.vircam_science_process",0);
531 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"stk_seeing");
532 cpl_parameterlist_append(recipe->parameters,p);
538 p = cpl_parameter_new_value(
"vircam.vircam_science_process.str_filt",
539 CPL_TYPE_BOOL,
"Filter stripe pattern?",
540 "vircam.vircam_science_process",1);
541 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"str_filt");
542 cpl_parameterlist_append(recipe->parameters,p);
548 p = cpl_parameter_new_value(
"vircam.vircam_science_process.psm_ipix",
550 "Minimum pixel area for each detected object",
551 "vircam.vircam_science_process",5);
552 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_ipix");
553 cpl_parameterlist_append(recipe->parameters,p);
557 p = cpl_parameter_new_value(
"vircam.vircam_science_process.psm_niter",
559 "Number of iterations in pawsky mask",
560 "vircam.vircam_science_process",5);
561 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_niter");
562 cpl_parameterlist_append(recipe->parameters,p);
566 p = cpl_parameter_new_value(
"vircam.vircam_science_process.psm_thresh",
568 "Detection threshold in sigma above sky",
569 "vircam.vircam_science_process",2.0);
570 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_thresh");
571 cpl_parameterlist_append(recipe->parameters,p);
575 p = cpl_parameter_new_value(
"vircam.vircam_science_process.psm_nbsize",
576 CPL_TYPE_INT,
"Background smoothing box size",
577 "vircam.vircam_science_process",50);
578 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_nbsize");
579 cpl_parameterlist_append(recipe->parameters,p);
583 p = cpl_parameter_new_value(
"vircam.vircam_science_process.psm_smkern",
585 "Smoothing kernel size (pixels)",
586 "vircam.vircam_science_process",2.0);
587 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,
"psm_smkern");
588 cpl_parameterlist_append(recipe->parameters,p);
603 static int vircam_science_process_exec(cpl_plugin *plugin) {
608 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
609 recipe = (cpl_recipe *)plugin;
613 return(vircam_science_process(recipe->parameters,recipe->frames));
624 static int vircam_science_process_destroy(cpl_plugin *plugin) {
629 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
630 recipe = (cpl_recipe *)plugin;
634 cpl_parameterlist_delete(recipe->parameters);
638 static int vircam_science_process(cpl_parameterlist *parlist,
639 cpl_frameset *framelist) {
640 const char *fctid=
"vircam_science_process";
642 int nfail,status,i,ndit,j,live,isfirst,nsci,njsteps,n;
644 float gaincor_fac,readnoise,gain,dit;
645 cpl_frame *catindex,*
template,*frm;
646 cpl_propertylist *pp;
649 char filt[16],projid[16],*tname,fname[BUFSIZ];
653 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
654 cpl_msg_error(fctid,
"Input framelist NULL or has no input data");
661 (void)strncpy(vircam_recipename,fctid,VIRCAM_PATHSZ);
662 (void)snprintf(vircam_recipepaf,VIRCAM_PATHSZ,
"VIRCAM/%s",fctid);
666 p = cpl_parameterlist_find(parlist,
667 "vircam.vircam_science_process.savecat");
668 vircam_sci_config.savecat = cpl_parameter_get_bool(p);
669 p = cpl_parameterlist_find(parlist,
670 "vircam.vircam_science_process.destripe");
671 vircam_sci_config.destripe = cpl_parameter_get_bool(p);
672 p = cpl_parameterlist_find(parlist,
673 "vircam.vircam_science_process.str_filt");
674 vircam_sci_config.str_filt = cpl_parameter_get_bool(p);
675 p = cpl_parameterlist_find(parlist,
676 "vircam.vircam_science_process.skyalgo");
677 vircam_sci_config.skyalgo = cpl_parameter_get_int(p);
678 p = cpl_parameterlist_find(parlist,
679 "vircam.vircam_science_process.preview_only");
680 vircam_sci_config.preview_only = cpl_parameter_get_bool(p);
681 p = cpl_parameterlist_find(parlist,
682 "vircam.vircam_science_process.minphotom");
683 vircam_sci_config.minphotom = cpl_parameter_get_int(p);
684 p = cpl_parameterlist_find(parlist,
685 "vircam.vircam_science_process.prettynames");
686 vircam_sci_config.prettynames = cpl_parameter_get_bool(p);
690 p = cpl_parameterlist_find(parlist,
691 "vircam.vircam_science_process.stk_lthr");
692 stk.lthr = cpl_parameter_get_double(p);
693 p = cpl_parameterlist_find(parlist,
694 "vircam.vircam_science_process.stk_hthr");
695 stk.hthr = cpl_parameter_get_double(p);
696 p = cpl_parameterlist_find(parlist,
697 "vircam.vircam_science_process.stk_method");
698 stk.method = cpl_parameter_get_int(p);
699 p = cpl_parameterlist_find(parlist,
700 "vircam.vircam_science_process.stk_seeing");
701 stk.seeing = cpl_parameter_get_bool(p);
705 p = cpl_parameterlist_find(parlist,
706 "vircam.vircam_science_process.stk_cat_ipix");
707 stk_cat.ipix = cpl_parameter_get_int(p);
708 p = cpl_parameterlist_find(parlist,
709 "vircam.vircam_science_process.stk_cat_thresh");
710 stk_cat.thresh = (float)cpl_parameter_get_double(p);
711 p = cpl_parameterlist_find(parlist,
712 "vircam.vircam_science_process.stk_cat_icrowd");
713 stk_cat.icrowd = cpl_parameter_get_bool(p);
714 p = cpl_parameterlist_find(parlist,
715 "vircam.vircam_science_process.stk_cat_rcore");
716 stk_cat.rcore = (float)cpl_parameter_get_double(p);
717 p = cpl_parameterlist_find(parlist,
718 "vircam.vircam_science_process.stk_cat_nbsize");
719 stk_cat.nbsize = cpl_parameter_get_int(p);
723 p = cpl_parameterlist_find(parlist,
724 "vircam.vircam_science_process.psm_ipix");
725 psm.ipix = cpl_parameter_get_int(p);
726 p = cpl_parameterlist_find(parlist,
727 "vircam.vircam_science_process.psm_niter");
728 psm.niter = cpl_parameter_get_int(p);
729 p = cpl_parameterlist_find(parlist,
730 "vircam.vircam_science_process.psm_thresh");
731 psm.thresh = cpl_parameter_get_double(p);
732 p = cpl_parameterlist_find(parlist,
733 "vircam.vircam_science_process.psm_nbsize");
734 psm.nbsize = cpl_parameter_get_int(p);
735 p = cpl_parameterlist_find(parlist,
736 "vircam.vircam_science_process.psm_smkern");
737 psm.smkern = cpl_parameter_get_double(p);
742 cpl_msg_error(fctid,
"Cannot identify RAW and CALIB frames");
751 cpl_msg_error(fctid,
"Cannot labelise the input frames");
759 if ((ps.science_frames =
761 VIRCAM_SCI_OBJECT_RAW)) == NULL) {
762 if ((ps.science_frames =
764 VIRCAM_SCI_OBJECT_EXT_RAW)) == NULL) {
765 cpl_msg_error(fctid,
"No science images to process!");
775 VIRCAM_CAL_SKY)) == NULL) {
776 if ((ps.offset_skies =
778 VIRCAM_OFFSET_SKY_RAW)) == NULL) {
782 nfail += vircam_sci_testfrms(ps.offset_skies,VIRCAM_NEXTN,1);
786 vircam_sci_config.skyalgo = -1;
787 nfail += vircam_sci_testfrm_1(ps.master_sky,VIRCAM_NEXTN,1);
792 if ((ps.master_dark =
794 VIRCAM_CAL_DARK)) == NULL) {
795 cpl_msg_error(fctid,
"No master dark found");
799 nfail += vircam_sci_testfrm_1(ps.master_dark,VIRCAM_NEXTN,1);
803 if ((ps.master_twilight_flat =
805 VIRCAM_CAL_TWILIGHT_FLAT)) == NULL) {
806 cpl_msg_error(fctid,
"No master twilight flat found");
810 nfail += vircam_sci_testfrm_1(ps.master_twilight_flat,VIRCAM_NEXTN,1);
816 nlab,VIRCAM_CAL_OBJMASK);
817 if ((ps.master_objmask == NULL) &&
818 (vircam_sci_config.skyalgo == PAWSKY_MASK_PRE)) {
820 "No object mask found. Unable to use requested sky algorithm");
823 }
else if (ps.master_objmask != NULL &&
824 (vircam_sci_config.skyalgo == PAWSKY_MASK ||
825 vircam_sci_config.skyalgo == TILESKY)) {
827 "Requested sky subt algorithm requires no object mask");
829 nfail += vircam_sci_testfrm_1(ps.master_objmask,0,1);
835 &status) != VIR_OK) {
836 cpl_msg_error(fctid,
"Error calculating gain corrections");
843 if ((ps.readgain_file =
845 VIRCAM_CAL_READGAINFILE)) == NULL) {
846 cpl_msg_error(fctid,
"No master readnoise/gain file found");
850 nfail += vircam_sci_testfrm_1(ps.readgain_file,VIRCAM_NEXTN,0);
854 if ((ps.master_conf =
856 VIRCAM_CAL_CONF)) == NULL) {
857 cpl_msg_error(fctid,
"No master confidence map file found");
861 nfail += vircam_sci_testfrm_1(ps.master_conf,VIRCAM_NEXTN,1);
867 VIRCAM_CAL_CHANTAB)) == NULL) {
868 cpl_msg_error(fctid,
"No channel table found");
872 nfail += vircam_sci_testfrm_1(ps.chantab,VIRCAM_NEXTN,0);
877 VIRCAM_CAL_PHOTTAB)) == NULL) {
878 cpl_msg_error(fctid,
"No photometric table found");
882 nfail += vircam_sci_testfrm_1(ps.phottab,1,0);
887 VIRCAM_CAL_2MASS)) == NULL) {
888 cpl_msg_error(fctid,
"No 2MASS index found -- cannot continue");
892 nfail += vircam_sci_testfrm_1(catindex,1,0);
897 VIRCAM_CAL_SCHL_N)) == NULL) {
898 cpl_msg_error(fctid,
"Schlegel North map not found -- cannot continue");
902 nfail += vircam_sci_testfrm_1(ps.schlf_n,0,1);
908 VIRCAM_CAL_SCHL_S)) == NULL) {
909 cpl_msg_error(fctid,
"Schlegel South map not found -- cannot continue");
913 nfail += vircam_sci_testfrm_1(ps.schlf_s,0,1);
921 "There are %" CPL_SIZE_FORMAT
" input file errors -- cannot continue",
929 if (
vircam_catpars(catindex,&(ps.catpath),&(ps.catname)) == VIR_FATAL) {
931 cpl_frame_delete(catindex);
934 cpl_frame_delete(catindex);
938 (void)strcpy(current_catpath,ps.catpath);
939 (void)strcpy(current_cat,ps.catname);
944 pp = cpl_propertylist_load(cpl_frame_get_filename(cpl_frameset_get_frame(ps.science_frames,0)),0);
946 cpl_msg_error(fctid,
"No value for NDIT available");
947 freepropertylist(pp);
951 cpl_propertylist_delete(pp);
955 ps.tphottab = cpl_table_load(cpl_frame_get_filename(ps.phottab),1,0);
959 vircam_sci_paws_create(ps.science_frames,&(ps.nscipaws),&(ps.science_paws));
960 vircam_sci_paws_create(ps.offset_skies,&(ps.noffpaws),&(ps.offsky_paws));
965 if (ps.science_paws[0].tilenum == -1 && ps.nscipaws > 1) {
967 "List has %" CPL_SIZE_FORMAT
" pawprints. Only 1 is allowed for non tiles",
968 (cpl_size)ps.nscipaws);
975 vircam_sci_skydefine();
979 if (vircam_sci_config.preview_only) {
980 if (ps.science_paws[0].tilenum == -1)
981 fprintf(stdout,
"This is a paw group with %" CPL_SIZE_FORMAT
" files\n",
982 cpl_frameset_get_size(ps.science_frames));
984 fprintf(stdout,
"This is a tile group with %" CPL_SIZE_FORMAT
" files\n",
985 cpl_frameset_get_size(ps.science_frames));
986 frm = cpl_frameset_get_frame(ps.science_frames,0);
987 pp = cpl_propertylist_load(cpl_frame_get_filename(frm),0);
993 cpl_propertylist_delete(pp);
995 fprintf(stdout,
"Filter %8s, DIT: %8.1f, NDIT: %" CPL_SIZE_FORMAT
", Project: %s\n",filt,
996 dit,(cpl_size)ndit,projid);
997 fprintf(stdout,
"Dark: %s\n",cpl_frame_get_filename(ps.master_dark));
998 fprintf(stdout,
"Flat: %s\n",
999 cpl_frame_get_filename(ps.master_twilight_flat));
1000 fprintf(stdout,
"CPM: %s\n",cpl_frame_get_filename(ps.master_conf));
1001 fprintf(stdout,
"Channel table: %s\n",
1002 cpl_frame_get_filename(ps.chantab));
1003 fprintf(stdout,
"A %" CPL_SIZE_FORMAT
" point dither will be done\n",
1005 if (ps.science_paws[0].tilenum != -1)
1006 fprintf(stdout,
"The tile has %" CPL_SIZE_FORMAT
" pawprints\n",
1007 (cpl_size)ps.nscipaws);
1008 for (i = 0; i < ps.nscipaws; i++) {
1009 n = cpl_frameset_get_size(ps.science_paws[i].orig);
1010 for (j = 0; j < n; j++) {
1011 frm = cpl_frameset_get_frame(ps.science_paws[i].orig,j);
1012 fprintf(stdout,
"%s sky%" CPL_SIZE_FORMAT
"\n",cpl_frame_get_filename(frm),
1013 (cpl_size)(ps.science_paws[i].whichsky[j]+1));
1016 if (ps.noffpaws != 0) {
1017 fprintf(stdout,
"There are %" CPL_SIZE_FORMAT
" offset sky frames\n",
1018 cpl_frameset_get_size(ps.offset_skies));
1019 for (i = 0; i < ps.noffpaws; i++) {
1020 n = cpl_frameset_get_size(ps.offsky_paws[i].orig);
1021 for (j = 0; j < n; j++) {
1022 frm = cpl_frameset_get_frame(ps.offsky_paws[i].orig,j);
1023 fprintf(stdout,
"%s sky%" CPL_SIZE_FORMAT
"\n",cpl_frame_get_filename(frm),
1024 (cpl_size)(ps.offsky_paws[i].whichsky[j]+1));
1028 fprintf(stdout,
"\nRequested sky algorithm: %" CPL_SIZE_FORMAT
"\n",
1029 (cpl_size)vircam_sci_config.skyalgo);
1030 for (i = 0; i < ps.nskys; i++) {
1031 fprintf(stdout,
"Sky%" CPL_SIZE_FORMAT
": %" CPL_SIZE_FORMAT
" ",
1032 (cpl_size)(i+1),(cpl_size)ps.skys[i].skyalgo);
1033 if (ps.skys[i].objmask != NULL)
1034 fprintf(stdout,
"mask: %s\nFormed from:\n",
1035 cpl_frame_get_filename(ps.skys[i].objmask));
1037 fprintf(stdout,
"\nFormed from:\n");
1038 for (j = 0; j < cpl_frameset_get_size(ps.skys[i].contrib); j++) {
1039 frm = cpl_frameset_get_frame(ps.skys[i].contrib,j);
1040 fprintf(stdout,
" %s\n",cpl_frame_get_filename(frm));
1049 ps.nscience = cpl_frameset_get_size(ps.science_frames);
1051 ps.product_frames_simple = cpl_malloc(ps.nscience*
sizeof(cpl_frame *));
1052 for (i = 0; i < ps.nscience; i++)
1053 ps.product_frames_simple[i] = NULL;
1054 if (ps.offset_skies != NULL) {
1055 ps.noffsets = cpl_frameset_get_size(ps.offset_skies);
1056 ps.product_frames_simple_off =
1057 cpl_malloc(ps.noffsets*
sizeof(cpl_frame *));
1058 for (i = 0; i < ps.noffsets; i++)
1059 ps.product_frames_simple_off[i] = NULL;
1066 cpl_msg_info(fctid,
"Beginning stage1 reduction");
1067 cpl_msg_indent_more();
1068 for (j = 1; j <= VIRCAM_NEXTN; j++) {
1070 gaincor_fac = (ps.gaincors)[j-1];
1071 cpl_msg_info(fctid,
"Extension [%" CPL_SIZE_FORMAT
"]",(cpl_size)j);
1088 ps.nscience = cpl_frameset_get_size(ps.science_frames);
1093 ps.noffsets = cpl_frameset_get_size(ps.offset_skies);
1098 ps.offsky_fits = NULL;
1105 for (i = 0; i < ps.nscience; i++) {
1106 ff = ps.sci_fits[i];
1112 cpl_msg_error(fctid,
"Unable to correct CRVAL in %s",
1118 for (i = 0; i < ps.noffsets; i++) {
1119 ff = ps.offsky_fits[i];
1128 vircam_sci_get_readnoise_gain(j,&readnoise,&gain);
1129 for (i = 0; i < ps.nscience; i++) {
1130 ff = ps.sci_fits[i];
1134 "[e-] Readnoise used in processing");
1137 "[e-/adu] Gain used in processing");
1139 cpl_msg_info(fctid,
"Detector is flagged dead in %s",
1150 frm = cpl_frameset_get_frame(ps.science_frames,i);
1151 tname = (
char *)cpl_frame_get_filename(frm);
1152 vircam_sci_product_name(tname,SIMPLE_FILE,
1153 vircam_sci_config.prettynames,i+1,fname);
1154 vircam_sci_save_simple(ff,framelist,parlist,0,
1155 cpl_frameset_get_frame(ps.science_frames,i),
1156 isfirst,VIRCAM_PRO_SIMPLE_SCI,fname,
1157 ps.product_frames_simple+i);
1159 for (i = 0; i < ps.noffsets; i++) {
1160 ff = ps.offsky_fits[i];
1162 cpl_msg_info(fctid,
"Detector is flagged dead in %s",
1173 frm = cpl_frameset_get_frame(ps.offset_skies,i);
1174 tname = (
char *)cpl_frame_get_filename(frm);
1175 vircam_sci_product_name(tname,SIMPLE_FILE,
1176 vircam_sci_config.prettynames,
1177 ps.nscience+i+1,fname);
1178 vircam_sci_save_simple(ff,framelist,parlist,0,
1179 cpl_frameset_get_frame(ps.offset_skies,i),
1180 isfirst,VIRCAM_PRO_SIMPLE_SKY,fname,
1181 ps.product_frames_simple_off+i);
1188 for (i = 0; i < nsci; i++)
1189 freeframe(ps.product_frames_simple[i]);
1190 for (i = 0; i < ps.noffsets; i++)
1191 freeframe(ps.product_frames_simple_off[i]);
1193 cpl_msg_indent_less();
1197 cpl_msg_info(fctid,
"Making skies");
1198 for (i = 0; i < ps.nskys; i++) {
1199 if (vircam_sci_makesky(framelist,parlist,&(ps.skys[i]),
1200 VIRCAM_PRO_SIMPLE_SCI) != VIR_OK) {
1201 cpl_msg_error(fctid,
"Error making sky %" CPL_SIZE_FORMAT
"",
1210 cpl_msg_info(fctid,
"Beginning stage2 reduction");
1211 (void)vircam_sci_sky_stripe_wcs(ps.nscipaws,ps.science_paws,
1212 VIRCAM_PRO_SIMPLE_SCI,framelist,parlist);
1213 (void)vircam_sci_sky_stripe_wcs(ps.noffpaws,ps.offsky_paws,
1214 VIRCAM_PRO_SIMPLE_SKY,framelist,parlist);
1218 cpl_msg_info(fctid,
"Beginning group processing");
1219 cpl_msg_indent_more();
1220 for (i = 0; i < ps.nscipaws; i++) {
1221 cpl_msg_info(fctid,
"Working on paw%" CPL_SIZE_FORMAT
"",
1223 cpl_msg_indent_more();
1224 for (j = 1; j <= VIRCAM_NEXTN; j++) {
1226 "Stacking paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1227 (cpl_size)(i+1),(cpl_size)j);
1228 vircam_sci_stack(&(ps.science_paws[i]),j);
1230 "Source extraction paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1231 (cpl_size)(i+1),(cpl_size)j);
1232 vircam_sci_cat(&(ps.science_paws[i]),j);
1234 "WCS fit paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1235 (cpl_size)(i+1),(cpl_size)j);
1236 vircam_sci_wcsfit(&(ps.science_paws[i].stack[j-1]),
1237 &(ps.science_paws[i].stackc[j-1]),
1238 &(ps.science_paws[i].cat[j-1]),1,2);
1240 1,current_catpath,current_cat,&stdscat,&status);
1243 &(ps.science_paws[i].mstds[j-1]),&status);
1246 cpl_msg_indent_less();
1248 "Doing photometric calibriation on paw%" CPL_SIZE_FORMAT
"",
1250 vircam_sci_photcal(&(ps.science_paws[i]));
1251 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[i].orig,0));
1252 cpl_msg_info(fctid,
"Saving paw%" CPL_SIZE_FORMAT
"",(cpl_size)(i+1));
1253 cpl_msg_indent_more();
1254 for (j = 1; j <= VIRCAM_NEXTN; j++) {
1256 "Saving image paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1257 (cpl_size)(i+1),(cpl_size)j);
1258 vircam_sci_save_stack(ps.science_paws[i].stack[j-1],framelist,
1260 vircam_sci_config.prettynames,i+1,
1261 &(ps.science_paws[i].product_frame_im));
1262 cpl_msg_info(fctid,
"Saving confidence map paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1263 (cpl_size)(i+1),(cpl_size)j);
1264 vircam_sci_save_stack_conf(ps.science_paws[i].stackc[j-1],framelist,
1266 vircam_sci_config.prettynames,i+1,
1267 &(ps.science_paws[i].product_frame_conf));
1269 "Saving catalogue paw%" CPL_SIZE_FORMAT
"[%" CPL_SIZE_FORMAT
"]",
1270 (cpl_size)(i+1),(cpl_size)j);
1271 vircam_sci_save_stack_cat(ps.science_paws[i].cat[j-1],
1272 framelist,parlist,
template,
1273 vircam_sci_config.prettynames,i+1,
1274 &(ps.science_paws[i].product_frame_cat));
1276 freeframe(
template);
1277 cpl_msg_indent_less();
1278 vircam_sci_paw_delete(ps.science_paws+i);
1280 cpl_msg_indent_less();
1288 static void vircam_sci_photcal(pawprint *paw) {
1299 vircam_photcal_extinct(paw->stack,paw->mstds,paw->cat,VIRCAM_NEXTN,
1300 filt,ps.tphottab,vircam_sci_config.minphotom,
1301 ps.schlf_n,ps.schlf_s,&status);
1304 static void vircam_sci_skydefine(
void) {
1306 cpl_frameset *newfrmset,**in;
1307 cpl_frame *
template;
1313 switch (vircam_sci_config.skyalgo) {
1322 vircam_sci_choose_skyalgo(&(ps.nskys),&(ps.skys));
1330 ps.skys = cpl_malloc(
sizeof(skystruct));
1331 ps.skys[0].skyframe = cpl_frame_duplicate(ps.master_sky);
1332 ps.skys[0].skyalgo = SKYMASTER;
1333 ps.skys[0].contrib = NULL;
1334 ps.skys[0].objmask = NULL;
1335 ps.skys[0].template = NULL;
1336 for (i = 0; i < ps.nscipaws; i++)
1337 vircam_sci_assign_sky_all(ps.science_paws[i],0);
1345 if (ps.noffpaws == 0) {
1346 ps.nskys = ps.nscipaws;
1347 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1348 for (i = 0; i < ps.nscipaws; i++) {
1349 newfrmset = cpl_frameset_duplicate(ps.science_paws[i].current);
1350 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[i].orig,0));
1351 ps.skys[i] = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,
1353 vircam_sci_assign_sky_all(ps.science_paws[i],i);
1356 ps.nskys = ps.noffpaws;
1357 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1358 for (i = 0; i < ps.noffpaws; i++) {
1359 newfrmset = cpl_frameset_duplicate(ps.offsky_paws[i].current);
1360 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.offsky_paws[i].orig,0));
1361 ps.skys[i] = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,
1363 vircam_sci_assign_sky_all(ps.offsky_paws[i],i);
1365 for (i = 0; i < ps.nscipaws; i++) {
1370 vircam_sci_assign_sky_all(ps.science_paws[i],j);
1379 case PAWSKY_MASK_PRE:
1380 ps.nskys = ps.nscipaws;
1381 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1382 for (i = 0; i < ps.nscipaws; i++) {
1383 newfrmset = cpl_frameset_duplicate(ps.science_paws[i].current);
1384 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[i].orig,0));
1385 ps.skys[i] = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,i+1);
1386 vircam_sci_assign_sky_all(ps.science_paws[i],i);
1394 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1395 if (ps.noffpaws == 0) {
1396 in = cpl_malloc(ps.nscipaws*
sizeof(cpl_frameset *));
1397 for (i = 0; i < ps.nscipaws; i++)
1398 in[i] = ps.science_paws[i].current;
1399 newfrmset = vircam_sci_merge_framesets(ps.nscipaws,in);
1401 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[0].orig,0));
1402 ps.skys[0] = vircam_sci_crsky(TILESKY,newfrmset,
template,1);
1403 for (i = 0; i < ps.nscipaws; i++)
1404 vircam_sci_assign_sky_all(ps.science_paws[i],0);
1406 in = cpl_malloc(ps.noffpaws*
sizeof(cpl_frameset *));
1407 for (i = 0; i < ps.noffpaws; i++)
1408 in[i] = ps.offsky_paws[i].current;
1409 newfrmset = vircam_sci_merge_framesets(ps.noffpaws,in);
1411 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.offsky_paws[0].orig,0));
1412 ps.skys[0] = vircam_sci_crsky(TILESKY,newfrmset,
template,1);
1413 for (i = 0; i < ps.noffpaws; i++)
1414 vircam_sci_assign_sky_all(ps.offsky_paws[i],0);
1415 for (i = 0; i < ps.nscipaws; i++)
1416 vircam_sci_assign_sky_all(ps.science_paws[i],0);
1426 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1427 in = cpl_malloc(ps.nscipaws*
sizeof(cpl_frameset *));
1428 for (i = 0; i < ps.nscipaws; i++)
1429 in[i] = ps.science_paws[i].current;
1430 newfrmset = vircam_sci_merge_framesets(ps.nscipaws,in);
1432 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[0].orig,0));
1433 ps.skys[0] = vircam_sci_crsky(TILESKY_MINUS,newfrmset,
template,1);
1434 for (i = 0; i < ps.nscipaws; i++)
1435 vircam_sci_assign_sky_all(ps.science_paws[i],0);
1444 ps.skys = cpl_malloc(ps.nskys*
sizeof(skystruct));
1445 newfrmset = cpl_frameset_duplicate(ps.science_paws[0].current);
1446 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[0].orig,0));
1447 ps.skys[0] = vircam_sci_crsky(PAWSKY_MINUS,newfrmset,
template,1);
1448 vircam_sci_assign_sky_all(ps.science_paws[0],0);
1453 static void vircam_sci_cat(pawprint *paw,
int extn) {
1460 (void)
vircam_imcore(paw->stack[extn-1],paw->stackc[extn-1],stk_cat.ipix,
1461 stk_cat.thresh,stk_cat.icrowd,stk_cat.rcore,
1462 stk_cat.nbsize,2,2.0,&tab,&status);
1463 paw->cat[extn-1] = tab;
1466 static void vircam_sci_stack(pawprint *paw,
int extn) {
1467 vir_fits **inf,*inconf,*out,*outc;
1475 ninf = (int)cpl_frameset_get_size(paw->current);
1477 vircam_imstack(inf,&inconf,NULL,ninf,1,stk.lthr,stk.hthr,stk.method,
1478 stk.seeing,&out,&outc,&status);
1484 for (i = 0; i < ninf; i++) {
1488 sum /= (double)ninf;
1491 "Mean MJD of the input images");
1492 freefitslist(inf,ninf);
1494 paw->stack[extn-1] = out;
1495 paw->stackc[extn-1] = outc;
1499 static int vircam_sci_sky_stripe_wcs(
int npaw, pawprint *paw,
const char *tag,
1500 cpl_frameset *framelist,
1501 cpl_parameterlist *parlist) {
1502 int i,j,jj,k,nf,n,isfirst,ii,status,whichsky,skyminus;
1504 cpl_frame *curframe,*
template,*product_frame;
1505 cpl_frameset *objframes;
1506 cpl_image *img,*simg;
1507 float med,sig,*sdata;
1508 vir_fits **sky_extns,*curfits[4],*tmpfits,*fconf;
1509 unsigned char *bpm[VIRCAM_NEXTN];
1510 cpl_mask *cplmasks[VIRCAM_NEXTN];
1511 const char *fctid =
"vircam_sci_sky_stripe_wcs";
1512 char tmpname[BUFSIZ];
1516 if (npaw == 0 || paw == NULL)
1521 for (i = 1; i <= VIRCAM_NEXTN; i++) {
1525 bpm[i-1] = cpl_calloc(nx*ny,
sizeof(
unsigned char));
1527 nx*ny*
sizeof(
unsigned char));
1528 cplmasks[i-1] = cpl_mask_wrap((cpl_size)nx,(cpl_size)ny,
1529 (cpl_binary *)bpm[i-1]);
1534 cpl_msg_indent_more();
1535 sky_extns = cpl_calloc(VIRCAM_NEXTN,
sizeof(vir_fits *));
1536 for (j = 0; j < VIRCAM_NEXTN; j++)
1537 sky_extns[j] = NULL;
1538 for (j = 0; j < npaw; j++) {
1542 objframes = paw[j].current;
1543 nf = cpl_frameset_get_size(objframes);
1545 skyminus = (ps.skys[paw[j].whichsky[0]].skyalgo == TILESKY_MINUS ||
1546 ps.skys[paw[j].whichsky[0]].skyalgo == PAWSKY_MINUS);
1547 for (jj = 0; jj < nf; jj++) {
1548 curframe = cpl_frameset_get_frame(objframes,jj);
1549 cpl_msg_info(fctid,
"Beginning work on %s",
1550 cpl_frame_get_filename(curframe));
1551 template = cpl_frameset_get_frame(paw[j].orig,jj);
1553 (void)snprintf(tmpname,BUFSIZ,
"tmp_%s",
1554 cpl_frame_get_filename(curframe));
1561 (whichsky == -1 || paw[j].whichsky[jj] != whichsky)) {
1562 whichsky = paw[j].whichsky[jj];
1563 for (i = 1; i <= VIRCAM_NEXTN; i++) {
1564 freefits(sky_extns[i-1]);
1565 sky_extns[i-1] =
vircam_fits_load(ps.skys[whichsky].skyframe,CPL_TYPE_FLOAT,i);
1567 sdata = cpl_image_get_data_float(img);
1568 nx = (long)cpl_image_get_size_x(img);
1569 ny = (long)cpl_image_get_size_y(img);
1571 vircam_qmedsig(sdata,bpm[i-1],npts,5.0,3,-1000.0,65535.0,&med,&sig);
1572 for (k = 0; k < npts; k++)
1581 for (i = 1; i <= VIRCAM_NEXTN; i++) {
1584 if (sky_extns[i-1] != NULL) {
1586 cpl_image_subtract(img,(
const cpl_image *)simg);
1591 cpl_image_reject_from_mask(img,cplmasks[i-1]);
1600 vircam_destripe_four(curfits,vircam_sci_config.str_filt,
1602 for (ii = 0; ii < 4; ii++) {
1607 vircam_sci_wcsfit(&tmpfits,&fconf,NULL,1,1);
1608 vircam_sci_save_simple(tmpfits,framelist,parlist,
1609 1,
template,isfirst,tag,
1610 tmpname,&product_frame);
1612 freefits(curfits[ii]);
1622 remove(cpl_frame_get_filename(curframe));
1623 cpl_frame_set_filename(product_frame,
1624 cpl_frame_get_filename(curframe));
1625 rename(tmpname,cpl_frame_get_filename(curframe));
1630 for (i = 0; i < VIRCAM_NEXTN; i++)
1631 freefits(sky_extns[i]);
1633 for (i = 0; i < VIRCAM_NEXTN; i++) {
1634 cpl_mask_unwrap(cplmasks[i]);
1637 freespace(sky_extns);
1638 cpl_msg_indent_less();
1642 static cpl_frame *vircam_sci_findtemplate(cpl_frame *in) {
1643 int i,j,imatch,jmatch,n;
1648 for (i = 0; i < ps.nscipaws; i++) {
1649 n = cpl_frameset_get_size(ps.science_paws[i].current);
1650 for (j = 0; j < n; j++) {
1651 frm = cpl_frameset_get_frame(ps.science_paws[i].current,j);
1652 if (! strcmp(cpl_frame_get_filename(in),
1653 cpl_frame_get_filename(frm))) {
1665 return(cpl_frameset_get_frame(ps.science_paws[imatch].orig,jmatch));
1668 static void vircam_sci_wcsfit(vir_fits **in, vir_fits **conf,
1669 vir_tfits **incat,
int nf,
int level) {
1670 int status,nstd,ncat,slevel,n,i,j;
1671 float *x,*y,*ra,*dec;
1674 cpl_table *stdscat,*newstds,*cat,*tmp,*tmp2,*matchstds;
1675 cpl_propertylist *p;
1677 const char *fctid =
"vircam_sci_wcsfit";
1681 for (j = 0; j < nf; j++) {
1688 (void)
vircam_imcore(in[j],conf[j],10,1.5,0,3.0,64,3,2.0,&tcat,
1696 current_catpath,current_cat,&stdscat,&status);
1697 if (status != VIR_OK) {
1699 cpl_msg_error(fctid,
1700 "Failed to find any standards for %s[%" CPL_SIZE_FORMAT
"]",
1710 (void)cpl_table_or_selected_float(stdscat,
"j_msig",CPL_LESS_THAN,0.2);
1711 (void)cpl_table_and_selected_float(stdscat,
"k_msig",CPL_LESS_THAN,0.2);
1712 newstds = cpl_table_extract_selected(stdscat);
1713 nstd = (int)cpl_table_get_nrow(newstds);
1721 ncat = (int)cpl_table_get_nrow(cat);
1722 if (ncat > 500 && ncat > 2.0*nstd) {
1723 tmp = cpl_table_duplicate(cat);
1724 (void)cpl_table_or_selected_float(tmp,
"Ellipticity",CPL_LESS_THAN,0.5);
1725 tmp2 = cpl_table_extract_selected(tmp);
1726 ncat = (int)cpl_table_get_nrow(tmp2);
1728 p = cpl_propertylist_new();
1729 cpl_propertylist_append_bool(p,
"Isophotal_flux",TRUE);
1730 cpl_table_sort(tmp2,(
const cpl_propertylist *)p);
1731 cpl_propertylist_delete(p);
1732 slevel = min(ncat,max(1,min(5000,max(500,2*nstd))));
1733 tmp = cpl_table_extract(tmp2,1,(cpl_size)slevel);
1735 ncat = (int)cpl_table_get_nrow(tmp);
1747 if (status != VIR_OK) {
1748 freetable(matchstds);
1749 cpl_msg_error(fctid,
"Failed to match standards to catalogue");
1759 freetable(matchstds);
1760 if (status != VIR_OK) {
1761 cpl_msg_error(fctid,
"Failed to fit WCS");
1771 n = (int)cpl_table_get_nrow(cat);
1774 cpl_msg_error(fctid,
"Failed to fill RA and Dec in catalogue");
1777 x = cpl_table_get_data_float(cat,
"X_coordinate");
1778 y = cpl_table_get_data_float(cat,
"Y_coordinate");
1779 ra = cpl_table_get_data_float(cat,
"RA");
1780 dec = cpl_table_get_data_float(cat,
"DEC");
1781 for (i = 0; i < n; i++) {
1786 cpl_wcs_delete(wcs);
1793 static int vircam_destripe_four(vir_fits **curfits,
int stripefilt,
1795 int i,nx,ny,n,k,m,ipstart,ipfin,ip;
1796 float *profiles[4],*meanprof,buf[4],*data,val,mad,rms;
1797 unsigned char *bpms[4],*bp;
1798 cpl_propertylist *plist;
1802 if (*status != VIR_OK)
1810 meanprof = cpl_malloc(ny*
sizeof(
float));
1811 bp = cpl_calloc(ny,
sizeof(
unsigned char));
1817 for (i = 0; i < 4; i++) {
1820 profiles[n] = cpl_malloc(ny*
sizeof(
float));
1821 bpms[n] = cpl_calloc(ny,
sizeof(
unsigned char));
1822 stripe_profile(curfits[i],stripefilt,profiles[n],bpms[n]);
1833 for (k = 0; k < ny; k++) {
1835 for (i = 0; i < n; i++) {
1838 buf[m++] = profiles[i][k];
1848 ipfin = ipstart + nx;
1849 for (i = 0; i < 4; i++) {
1853 for (ip = ipstart; ip < ipfin; ip++)
1854 data[ip] -= meanprof[k];
1862 for (i = 0; i < n; i++) {
1863 freespace(profiles[i]);
1873 for (i = 0; i < 4; i++) {
1882 cpl_propertylist_update_bool(plist,
"ESO DRS STRIPECOR",k);
1883 cpl_propertylist_set_comment(plist,
"ESO DRS STRIPECOR",
1884 "Stripe correction done");
1885 cpl_propertylist_update_float(plist,
"ESO DRS STRIPERMS",val);
1886 cpl_propertylist_set_comment(plist,
"ESO DRS STRIPERMS",
1887 "RMS of removed stripe profile");
1892 freespace(meanprof);
1900 static void stripe_profile(vir_fits *in,
int stripefilt,
float *profile,
1901 unsigned char *pbpm) {
1902 float *data,*copy,*d,lcut,hcut,skymed,skynoise,rmsold,rms,val;
1903 unsigned char *bpm,*ob,*b;
1911 nx = cpl_image_get_size_x(img);
1912 ny = cpl_image_get_size_y(img);
1913 data = cpl_image_get_data(img);
1914 bpm = (
unsigned char *)cpl_mask_get_data(cpl_image_get_bpm(img));
1919 vircam_qmedsig(data,bpm,npts,3.0,3,-65535.0,65535.0,&skymed,&skynoise);
1923 ob = cpl_calloc(ny,
sizeof(
unsigned char));
1924 copy = cpl_malloc(ny*
sizeof(
float));
1930 for (i = 0; i < ny; i++) {
1938 for (j = 0; j < 3; j++) {
1940 if (val == CX_MAXFLOAT) {
1942 }
else if (rms == rmsold) {
1945 lcut = val - 3.0*skynoise;
1946 hcut = val + 3.0*skynoise;
1950 pbpm[i] = (val == CX_MAXFLOAT);
1951 profile[i] = (pbpm[i] ? 0.0 : val);
1952 copy[i] = profile[i];
1961 if (stripefilt && rms > 15.0) {
1964 for (i = 0; i < ny; i++) {
1966 profile[i] -= copy[i];
1971 for (i = 0; i < ny; i++)
1982 static void vircam_sci_paws_delete(
int npaws, pawprint **paws) {
1985 for (i = 0; i < npaws; i++)
1986 vircam_sci_paw_delete(*paws+i);
1990 static void vircam_sci_paw_delete(pawprint *paw) {
1993 if (paw->current == NULL)
1995 n = cpl_frameset_get_size(paw->current);
1996 freespace(paw->whichsky);
1997 freeframeset(paw->orig);
1998 freeframeset(paw->current);
1999 for (i = 0; i < VIRCAM_NEXTN; i++) {
2000 freefits(paw->stack[i]);
2001 freefits(paw->stackc[i]);
2002 freetfits(paw->cat[i]);
2003 freetable(paw->mstds[i]);
2007 static void vircam_sci_paws_create(cpl_frameset *infrms,
int *npaws,
2009 cpl_size nlab,*labels,*labels2,nlab2;
2010 cpl_frameset *copy,*testme,*tf;
2022 copy = cpl_frameset_duplicate(infrms);
2023 labels = cpl_frameset_labelise(copy,vircam_sci_cmp_tstart,&nlab);
2030 *paws = cpl_malloc(nalloc*
sizeof(pawprint));
2034 for (i = 0; i < nlab; i++) {
2039 testme = cpl_frameset_extract(copy,labels,(cpl_size)i);
2040 if (vircam_sci_istile(cpl_frameset_get_frame(testme,0))) {
2041 pj = vircam_sci_ispj(testme);
2042 labels2 = cpl_frameset_labelise(testme,vircam_sci_cmp_jit,&nlab2);
2043 for (j = 0; j < nlab2; j++) {
2044 if (*npaws+1 > nalloc) {
2046 *paws = cpl_realloc(*paws,nalloc*
sizeof(pawprint));
2048 tf = cpl_frameset_extract(testme,labels2,(cpl_size)j);
2049 vircam_sci_paw_init(*paws+*npaws,tf,pj);
2055 vircam_sci_paw_init(*paws+*npaws,testme,0);
2058 freeframeset(testme);
2063 *paws = cpl_realloc(*paws,*npaws*
sizeof(pawprint));
2067 cpl_frameset_delete(copy);
2071 static int vircam_sci_istile(cpl_frame *frm) {
2072 cpl_propertylist *plist;
2073 int hasoffs,noffsets;
2078 plist = cpl_propertylist_load(cpl_frame_get_filename(frm),0);
2079 hasoffs = cpl_propertylist_has(plist,
"OFFSTNUM");
2081 noffsets = cpl_propertylist_get_int(plist,
"NOFFSETS");
2084 cpl_propertylist_delete(plist);
2085 return(hasoffs && noffsets != 1);
2088 static void vircam_sci_paw_init(pawprint *paw, cpl_frameset *frms,
int ispj) {
2089 cpl_propertylist *plist;
2096 paw->orig = cpl_frameset_duplicate(frms);
2097 paw->current = vircam_sci_update_frameset(paw->orig);
2098 n = cpl_frameset_get_size(frms);
2099 paw->whichsky = cpl_malloc(n*
sizeof(
int));
2100 for (i = 0; i < n; i++)
2101 paw->whichsky[i] = -1;
2103 for (i = 0; i < VIRCAM_NEXTN; i++) {
2104 paw->stack[i] = NULL;
2105 paw->stackc[i] = NULL;
2107 paw->mstds[i] = NULL;
2109 paw->product_frame_im = NULL;
2110 paw->product_frame_conf = NULL;
2111 paw->product_frame_cat = NULL;
2116 fr = cpl_frameset_get_frame(frms,0);
2117 plist = cpl_propertylist_load(cpl_frame_get_filename(fr),0);
2129 cpl_propertylist_delete(plist);
2130 n = (int)cpl_frameset_get_size(frms);
2131 fr = cpl_frameset_get_frame(frms,n-1);
2132 plist = cpl_propertylist_load(cpl_frame_get_filename(fr),0);
2135 paw->mjd_end += exptime/(24.0*3600.0);
2139 cpl_propertylist_delete(plist);
2142 static int vircam_sci_makesky(cpl_frameset *framelist,
2143 cpl_parameterlist *parlist, skystruct *sky,
2151 switch (sky->skyalgo) {
2157 retval = vircam_sci_pawsky_minus(framelist,parlist,sky->contrib,
2158 sky->template,tag,sky->fname,
2162 retval = vircam_sci_tilesky_minus(framelist,parlist,sky->contrib,
2163 sky->template,tag,sky->fname,
2167 retval = vircam_sci_pawsky_mask(framelist,parlist,sky->skyalgo,
2168 sky->contrib,sky->template,
2169 sky->fname,&(sky->skyframe));
2171 case PAWSKY_MASK_PRE:
2172 retval = vircam_sci_pawsky_mask(framelist,parlist,sky->skyalgo,
2173 sky->contrib,sky->template,
2174 sky->fname,&(sky->skyframe));
2177 retval = vircam_sci_tilesky(framelist,parlist,sky->contrib,
2178 sky->template,sky->fname,&(sky->skyframe));
2184 static int vircam_sci_tilesky_minus(cpl_frameset *framelist,
2185 cpl_parameterlist *parlist,
2186 cpl_frameset *in, cpl_frame *
template,
2187 const char *tag,
char *skyname,
2188 cpl_frame **skyframe) {
2189 int n,i,status,isfirst,j;
2190 vir_fits *objmaskfits,**infits,*inconf,*tmpfits,*skyout;
2191 cpl_frame **product_frames,*curframe;
2192 char tmpname[BUFSIZ];
2193 const char *fctid =
"vircam_sci_tilesky_minus";
2195 n = cpl_frameset_get_size(in);
2197 product_frames = cpl_malloc(n*
sizeof(cpl_frame *));
2198 cpl_msg_info(fctid,
"Creating sky %s",skyname);
2199 cpl_msg_indent_more();
2200 for (i = 1; i <= VIRCAM_NEXTN; i++) {
2201 cpl_msg_info(fctid,
"Beginning on extn %" CPL_SIZE_FORMAT
"",
2206 if (vircam_tilesky_minus(infits,inconf,objmaskfits,n,1,&skyout,
2207 &status) != VIR_OK) {
2208 freefitslist(infits,n);
2210 freespace(product_frames);
2214 for (j = 0; j < n; j++) {
2216 (void)snprintf(tmpname,BUFSIZ,
"tmp_%s",
2219 curframe = cpl_frameset_get_frame(in,j);
2220 template = vircam_sci_findtemplate(curframe);
2221 vircam_sci_save_simple(tmpfits,framelist,parlist,0,
template,
2222 isfirst,tag,tmpname,(product_frames+j));
2225 vircam_sci_save_sky(skyout,framelist,parlist,skyname,
template,
2227 freefitslist(infits,n);
2231 cpl_msg_indent_less();
2232 for (i = 0; i < n; i++) {
2233 curframe = cpl_frameset_get_frame(in,i);
2234 template = product_frames[i];
2235 remove(cpl_frame_get_filename(curframe));
2236 rename(cpl_frame_get_filename(
template),
2237 cpl_frame_get_filename(curframe));
2238 freeframe(product_frames[i]);
2240 freespace(product_frames);
2241 freefits(objmaskfits);
2246 static int vircam_sci_pawsky_minus(cpl_frameset *framelist,
2247 cpl_parameterlist *parlist,
2248 cpl_frameset *in, cpl_frame *
template,
2249 const char *tag,
char *skyname,
2250 cpl_frame **skyframe) {
2251 int n,i,status,isfirst,j,k;
2252 vir_fits *objmaskfits,**infits,*inconf,*tmpfits,*skyout;
2253 cpl_frame **product_frames,*curframe;
2254 char tmpname[BUFSIZ];
2255 const char *fctid =
"vircam_sci_pawsky_minus";
2257 n = cpl_frameset_get_size(in);
2258 if (ps.master_objmask != NULL)
2262 product_frames = cpl_malloc(n*
sizeof(cpl_frame *));
2263 cpl_msg_info(fctid,
"Creating sky %s",skyname);
2264 cpl_msg_indent_more();
2265 for (i = 1; i <= VIRCAM_NEXTN; i++) {
2266 cpl_msg_info(fctid,
"Beginning on extn %" CPL_SIZE_FORMAT
"",
2271 if (ps.master_objmask != NULL) {
2272 for (k = 0; k < n; k++)
2273 vircam_sci_wcsfit(infits+k,&inconf,NULL,1,1);
2275 if (vircam_pawsky_minus(infits,inconf,objmaskfits,n,1,&skyout,
2276 &status) != VIR_OK) {
2277 freefitslist(infits,n);
2279 freespace(product_frames);
2283 for (j = 0; j < n; j++) {
2285 (void)snprintf(tmpname,BUFSIZ,
"tmp_%s",
2288 curframe = cpl_frameset_get_frame(in,j);
2289 template = vircam_sci_findtemplate(curframe);
2290 vircam_sci_save_simple(tmpfits,framelist,parlist,0,
template,
2291 isfirst,tag,tmpname,(product_frames+j));
2294 vircam_sci_save_sky(skyout,framelist,parlist,skyname,
template,
2296 freefitslist(infits,n);
2300 cpl_msg_indent_less();
2301 for (i = 0; i < n; i++) {
2302 curframe = cpl_frameset_get_frame(in,i);
2303 template = product_frames[i];
2304 remove(cpl_frame_get_filename(curframe));
2305 rename(cpl_frame_get_filename(
template),
2306 cpl_frame_get_filename(curframe));
2307 freeframe(product_frames[i]);
2309 freespace(product_frames);
2310 freefits(objmaskfits);
2314 static void vircam_sci_choose_skyalgo(
int *nskys, skystruct **skys) {
2317 int nalloc,i,n,n2,jst,jfn,j,j_1,j_2;
2319 cpl_frameset **in,*newfrmset;
2320 cpl_frame *frm,*
template;
2324 halfhour = 1.0/48.0;
2331 *skys = cpl_malloc(nalloc*
sizeof(skystruct));
2337 if (ps.noffpaws > 0) {
2338 if (vircam_sci_istile(cpl_frameset_get_frame(ps.offsky_paws[0].orig,0))) {
2342 in = cpl_malloc(ps.noffpaws*
sizeof(cpl_frameset *));
2343 for (i = 0; i < ps.noffpaws; i++)
2344 in[i] = ps.offsky_paws[i].current;
2345 newfrmset = vircam_sci_merge_framesets(ps.noffpaws,in);
2350 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.offsky_paws[0].orig,0));
2351 newsky = vircam_sci_crsky(TILESKY,newfrmset,
template,1);
2353 (*skys)[*nskys-1] = newsky;
2358 for (i = 0; i < ps.noffpaws; i++)
2359 vircam_sci_assign_sky_all(ps.offsky_paws[i],*nskys-1);
2360 for (i = 0; i < ps.nscipaws; i++)
2361 vircam_sci_assign_sky_all(ps.science_paws[i],*nskys-1);
2363 newfrmset = cpl_frameset_duplicate(ps.offsky_paws[0].current);
2364 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.offsky_paws[0].orig,0));
2365 newsky = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,*nskys+1);
2367 (*skys)[*nskys-1] = newsky;
2368 vircam_sci_assign_sky_all(ps.offsky_paws[0],*nskys-1);
2369 vircam_sci_assign_sky_all(ps.science_paws[0],*nskys-1);
2382 if (ps.science_paws[0].tilenum == -1) {
2383 dt = ps.science_paws[0].mjd_end - ps.science_paws[0].mjd_start;
2384 n = cpl_frameset_get_size(ps.science_paws[0].current);
2389 if (dt < halfhour || n < 16) {
2390 newfrmset = cpl_frameset_duplicate(ps.science_paws[0].current);
2391 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[0].orig,0));
2392 newsky = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,
2395 (*skys)[*nskys-1] = newsky;
2396 vircam_sci_assign_sky_all(ps.science_paws[0],*nskys-1);
2403 for (i = 0; i < 2; i++) {
2411 newfrmset = cpl_frameset_new();
2412 for (j = jst; j < jfn; j++) {
2413 frm = cpl_frameset_get_frame(ps.science_paws[0].current,j);
2414 cpl_frameset_insert(newfrmset,frm);
2416 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[0].orig,jst));
2417 newsky = vircam_sci_crsky(PAWSKY_MASK,newfrmset,
template,
2420 if (*nskys > nalloc) {
2422 *skys = cpl_realloc(*skys,nalloc*
sizeof(skystruct));
2424 (*skys)[*nskys-1] = newsky;
2425 for (j = jst; j < jfn; j++)
2426 ps.science_paws[0].whichsky[j] = *nskys-1;
2435 dt = ps.science_paws[n-1].mjd_end - ps.science_paws[0].mjd_start;
2436 if (! strncmp(ps.science_paws[0].projname,VIDEOPROJ,10)) {
2438 for (j = 0; j < 2; j++) {
2446 in = cpl_malloc((j_2-j_1)*
sizeof(cpl_frameset *));
2447 for (i = j_1; i < j_2; i++)
2448 in[i-j_1] = ps.science_paws[i].current;
2449 newfrmset = vircam_sci_merge_framesets((j_2-j_1),in);
2451 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[j_1].orig,0));
2452 newsky = vircam_sci_crsky(TILESKY_MINUS,newfrmset,
template,
2455 if (*nskys > nalloc) {
2457 *skys = cpl_realloc(*skys,nalloc*
sizeof(skystruct));
2459 (*skys)[*nskys-1] = newsky;
2460 for (i = j_1; i < j_2; i++)
2461 vircam_sci_assign_sky_all(ps.science_paws[i],*nskys-1);
2468 }
else if (dt < halfhour ||
2469 ! strncmp(ps.science_paws[0].projname,VMCPROJ,10)) {
2470 in = cpl_malloc(ps.nscipaws*
sizeof(cpl_frameset *));
2471 for (i = 0; i < ps.nscipaws; i++)
2472 in[i] = ps.science_paws[i].current;
2473 newfrmset = vircam_sci_merge_framesets(ps.nscipaws,in);
2478 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[0].orig,0));
2479 newsky = vircam_sci_crsky(TILESKY,newfrmset,
template,1);
2481 (*skys)[*nskys-1] = newsky;
2485 for (i = 0; i < ps.nscipaws; i++)
2486 vircam_sci_assign_sky_all(ps.science_paws[i],*nskys-1);
2493 if (ps.science_paws[0].ispj) {
2495 for (j = 0; j < 2; j++) {
2503 in = cpl_malloc((j_2-j_1)*
sizeof(cpl_frameset *));
2504 for (i = j_1; i < j_2; i++)
2505 in[i-j_1] = ps.science_paws[i].current;
2506 newfrmset = vircam_sci_merge_framesets((j_2-j_1),in);
2508 template = cpl_frame_duplicate(cpl_frameset_get_frame(ps.science_paws[j_1].orig,0));
2509 newsky = vircam_sci_crsky(TILESKY,newfrmset,
template,
2512 if (*nskys > nalloc) {
2514 *skys = cpl_realloc(*skys,nalloc*
sizeof(skystruct));
2516 (*skys)[*nskys-1] = newsky;
2517 for (i = j_1; i < j_2; i++)
2518 vircam_sci_assign_sky_all(ps.science_paws[i],
2530 static int vircam_sci_ispj(cpl_frameset *frms) {
2531 int n,offnum,i,offnum1,offnum2;
2532 cpl_propertylist *plist,*tmp;
2538 plist = cpl_propertylist_new();
2543 n = cpl_frameset_get_size(frms);
2544 for (i = 0; i < n; i++) {
2545 frm = cpl_frameset_get_frame(frms,i);
2546 tmp = cpl_propertylist_load(cpl_frame_get_filename(frm),0);
2547 strcpy(dateobs,cpl_propertylist_get_string(tmp,
"DATE-OBS"));
2548 offnum = cpl_propertylist_get_int(tmp,
"OFFSET_I");
2549 cpl_propertylist_append_int(plist,dateobs,offnum);
2550 cpl_propertylist_delete(tmp);
2556 cpl_propertylist_sort(plist,vircam_sci_cmp_property);
2561 offnum1 = cpl_property_get_int(cpl_propertylist_get(plist,0));
2562 offnum2 = cpl_property_get_int(cpl_propertylist_get(plist,1));
2563 cpl_propertylist_delete(plist);
2564 return(offnum1 == offnum2);
2567 static int vircam_sci_cmp_property(
const cpl_property *p1,
2568 const cpl_property *p2) {
2569 return(strcmp(cpl_property_get_name(p1),cpl_property_get_name(p2)));
2572 static void vircam_sci_assign_sky_all(pawprint paw,
int whichone) {
2575 n = cpl_frameset_get_size(paw.current);
2576 for (i = 0; i < n; i++)
2577 paw.whichsky[i] = whichone;
2580 static skystruct vircam_sci_crsky(
int algorithm, cpl_frameset *frms,
2581 cpl_frame *
template,
int snum) {
2585 if (ps.master_objmask != NULL)
2586 s.objmask = cpl_frame_duplicate(ps.master_objmask);
2589 s.skyalgo = algorithm;
2591 s.template =
template;
2592 vircam_sci_product_name((
char *)cpl_frame_get_filename(cpl_frameset_get_frame(frms,0)),
2593 SKY_FILE,vircam_sci_config.prettynames,snum,
2598 static cpl_frameset *vircam_sci_merge_framesets(
int n, cpl_frameset **in) {
2605 new = cpl_frameset_new();
2609 for (i = 0; i < n; i++) {
2610 nf = cpl_frameset_get_size(in[i]);
2611 for (j = 0; j < nf; j++) {
2612 frm = cpl_frame_duplicate(cpl_frameset_get_frame(in[i],j));
2613 cpl_frameset_insert(
new,frm);
2619 static int vircam_sci_tilesky(cpl_frameset *framelist,
2620 cpl_parameterlist *parlist, cpl_frameset *in,
2621 cpl_frame *
template,
char *fname,
2622 cpl_frame **product_frame) {
2623 int j,nfiles,isfirst,status;
2624 const char *fctid=
"vircam_sci_tilesky";
2625 vir_fits **infits,*skyout;
2629 *product_frame = NULL;
2633 nfiles = cpl_frameset_get_size(in);
2634 cpl_msg_info(fctid,
"Creating sky %s",fname);
2635 cpl_msg_indent_more();
2636 for (j = 1; j <= VIRCAM_NEXTN; j++) {
2637 cpl_msg_info(fctid,
"Extension [%" CPL_SIZE_FORMAT
"]",(cpl_size)j);
2655 if (vircam_sci_save_sky(skyout,framelist,parlist,fname,
template,
2656 isfirst,product_frame) != VIR_OK) {
2657 freefitslist(infits,nfiles);
2664 freefitslist(infits,nfiles);
2667 cpl_msg_indent_less();
2671 static int vircam_sci_pawsky_mask(cpl_frameset *framelist,
2672 cpl_parameterlist *parlist,
int algo,
2673 cpl_frameset *contrib, cpl_frame *
template,
2674 char *fname, cpl_frame **product_frame) {
2675 int j,nfiles,status,isfirst;
2676 const char *fctid=
"vircam_sci_pawsky_mask";
2677 vir_fits **infits,*conf,*skyout,*opmfits;
2681 *product_frame = NULL;
2685 nfiles = cpl_frameset_get_size(contrib);
2686 cpl_msg_info(fctid,
"Creating sky %s",fname);
2687 cpl_msg_indent_more();
2688 for (j = 1; j <= VIRCAM_NEXTN; j++) {
2689 cpl_msg_info(fctid,
"Extension [%" CPL_SIZE_FORMAT
"]",(cpl_size)j);
2705 if (algo == PAWSKY_MASK) {
2707 psm.niter,psm.ipix,psm.thresh,psm.nbsize,
2708 psm.smkern,&status);
2712 psm.nbsize,&skyout,&status);
2718 if (vircam_sci_save_sky(skyout,framelist,parlist,fname,
template,
2719 isfirst,product_frame) != VIR_OK) {
2720 freefitslist(infits,nfiles);
2728 freefitslist(infits,nfiles);
2732 cpl_msg_indent_less();
2757 extern int vircam_sci_save_sky(vir_fits *outsky, cpl_frameset *framelist,
2758 cpl_parameterlist *parlist,
2759 char *fname, cpl_frame *
template,
int isfirst,
2760 cpl_frame **product_frame) {
2761 cpl_propertylist *p;
2764 const char *fctid =
"vircam_sci_save_sky";
2779 *product_frame = cpl_frame_new();
2780 cpl_frame_set_filename(*product_frame,fname);
2781 cpl_frame_set_tag(*product_frame,VIRCAM_PRO_OFFSET_SKY);
2782 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_IMAGE);
2783 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
2784 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
2790 parlist,vircam_recipename,
2791 "PRO-1.15",
template,0);
2795 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,p,
2796 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
2797 cpl_msg_error(fctid,
"Cannot save product PHU");
2798 cpl_frame_delete(*product_frame);
2801 cpl_frameset_insert(framelist,*product_frame);
2813 vircam_recipename,
"PRO-1.15",
template);
2814 if (cpl_image_save(fim,fname,CPL_TYPE_FLOAT,p,CPL_IO_EXTEND) !=
2816 cpl_msg_error(fctid,
"Cannot save product image extension");
2822 cpl_propertylist_delete(p);
2829 static int vircam_sci_cmp_jit(
const cpl_frame *frame1,
2830 const cpl_frame *frame2) {
2832 cpl_propertylist *pp;
2836 if (frame1 == NULL || frame2 == NULL)
2838 pp = cpl_propertylist_load(cpl_frame_get_filename(frame1),0);
2840 cpl_propertylist_delete(pp);
2841 pp = cpl_propertylist_load(cpl_frame_get_filename(frame2),0);
2843 cpl_propertylist_delete(pp);
2848 static int vircam_sci_cmp_tstart(
const cpl_frame *frame1,
2849 const cpl_frame *frame2) {
2850 char ts1[80],ts2[80];
2851 cpl_propertylist *pp;
2855 if (frame1 == NULL || frame2 == NULL)
2861 pp = cpl_propertylist_load(cpl_frame_get_filename(frame1),0);
2862 (void)vircam_pfits_get_tplstart(pp,ts1);
2863 cpl_propertylist_delete(pp);
2864 pp = cpl_propertylist_load(cpl_frame_get_filename(frame2),0);
2865 (void)vircam_pfits_get_tplstart(pp,ts2);
2866 cpl_propertylist_delete(pp);
2870 if (strcmp(ts1,ts2))
2876 static int vircam_pfits_get_tplstart(cpl_propertylist *plist,
char *tplstart) {
2877 strcpy(tplstart,cpl_propertylist_get_string(plist,
"ESO TPL START"));
2878 if (cpl_error_get_code() == CPL_ERROR_NONE) {
2886 static cpl_frameset *vircam_sci_update_frameset(cpl_frameset *frms) {
2890 char *fname,bname[BUFSIZ];
2899 copy = cpl_frameset_duplicate(frms);
2903 n = cpl_frameset_get_size(frms);
2904 for (i = 0; i < n; i++) {
2905 fr = cpl_frameset_get_frame(copy,i);
2906 fname = cpl_strdup(cpl_frame_get_filename(fr));
2907 vircam_sci_product_name(fname,SIMPLE_FILE,vircam_sci_config.prettynames,
2909 cpl_frame_set_filename(fr,basename(bname));
2918 static int vircam_sci_testfrms(cpl_frameset *frms,
int nextn_expected,
2930 nf = cpl_frameset_get_size(frms);
2932 for (i = 0; i < nf; i++) {
2933 fr = cpl_frameset_get_frame(frms,i);
2934 nerr += vircam_sci_testfrm_1(fr,nextn_expected,isimg);
2942 static int vircam_sci_testfrm_1(cpl_frame *fr,
int nextn_expected,
int isimg) {
2946 const char *fctid=
"vircam_sci_testfrm";
2956 nextn = cpl_frame_get_nextensions(fr);
2957 if (nextn != nextn_expected) {
2958 cpl_msg_error(fctid,
"Frame %s has %" CPL_SIZE_FORMAT
" extensions, expected %" CPL_SIZE_FORMAT
"\n",
2959 cpl_frame_get_filename(fr),(cpl_size)nextn,
2960 (cpl_size)nextn_expected);
2967 for (j = 1; j <= nextn; j++) {
2971 cpl_msg_error(fctid,
2972 "Frame image %s[%" CPL_SIZE_FORMAT
"] won't load\n",
2973 cpl_frame_get_filename(fr),(cpl_size)j);
2980 if (testt == NULL) {
2981 cpl_msg_error(fctid,
2982 "Frame table %s[%" CPL_SIZE_FORMAT
"] won't load\n",
2983 cpl_frame_get_filename(fr),(cpl_size)j);
3012 extern void vircam_sci_init(
void) {
3017 ps.master_dark = NULL;
3018 ps.master_twilight_flat = NULL;
3019 ps.master_conf = NULL;
3020 ps.master_sky = NULL;
3021 ps.master_objmask = NULL;
3026 ps.readgain_file = NULL;
3027 ps.science_frames = NULL;
3028 ps.offset_skies = NULL;
3029 ps.product_frames_simple = NULL;
3030 ps.product_frames_simple_off = NULL;
3036 ps.science_paws = NULL;
3038 ps.offsky_paws = NULL;
3052 ps.offsky_fits = NULL;
3078 extern void vircam_sci_tidy(
int level) {
3087 freetfits(ps.fchantab);
3088 freefitslist(ps.sci_fits,ps.nscience);
3089 freefitslist(ps.offsky_fits,ps.noffsets);
3097 freespace(ps.labels);
3098 freeframe(ps.master_dark);
3099 freeframe(ps.master_twilight_flat);
3100 freeframe(ps.master_conf);
3101 freeframe(ps.master_sky);
3102 freeframe(ps.master_objmask);
3104 freeframe(ps.chantab);
3105 freeframe(ps.phottab);
3106 freeframe(ps.readgain_file);
3107 freetable(ps.tphottab);
3108 freeframeset(ps.science_frames);
3109 freeframeset(ps.offset_skies);
3110 freepropertylist(ps.phupaf);
3111 freespace(ps.product_frames_simple);
3114 freespace(ps.product_frames_simple_off);
3115 freespace(ps.gaincors);
3116 freespace(ps.catpath);
3117 freespace(ps.catname);
3118 for (i = 0; i < ps.nskys; i++) {
3119 freeframeset(ps.skys[i].contrib);
3120 freeframe(ps.skys[i].objmask);
3121 freeframe(ps.skys[i].template);
3124 freepaws(ps.science_paws,ps.nscipaws);
3125 freepaws(ps.offsky_paws,ps.noffpaws);
3126 freeframe(ps.schlf_n);
3127 freeframe(ps.schlf_s);
3148 extern void vircam_sci_get_readnoise_gain(
int jext,
float *readnoise,
3150 cpl_propertylist *p_rg;
3151 const char *fctid =
"vircam_sci_get_readnoise_gain";
3155 p_rg = cpl_propertylist_load(cpl_frame_get_filename(ps.readgain_file),
3160 switch (cpl_propertylist_get_type(p_rg,
"ESO QC READNOISE")) {
3161 case CPL_TYPE_FLOAT:
3162 *readnoise = cpl_propertylist_get_float(p_rg,
"ESO QC READNOISE");
3164 case CPL_TYPE_DOUBLE:
3165 *readnoise = (float)cpl_propertylist_get_double(p_rg,
3166 "ESO QC READNOISE");
3171 cpl_msg_error(fctid,
"Unable to get READNOISE estimate, guessing %g\n",
3177 switch (cpl_propertylist_get_type(p_rg,
"ESO QC CONAD")) {
3178 case CPL_TYPE_FLOAT:
3179 *gain = cpl_propertylist_get_float(p_rg,
"ESO QC CONAD");
3181 case CPL_TYPE_DOUBLE:
3182 *gain = (float)cpl_propertylist_get_double(p_rg,
"ESO QC CONAD");
3187 cpl_msg_error(fctid,
"Unable to get GAIN estimate, guessing %g\n",
3190 cpl_propertylist_delete(p_rg);
3214 extern int vircam_sci_save_simple(vir_fits *obj, cpl_frameset *framelist,
3215 cpl_parameterlist *parlist,
int isprod,
3216 cpl_frame *
template,
int isfirst,
3217 const char *tag,
char *fname,
3218 cpl_frame **product_frame) {
3219 cpl_propertylist *plist;
3221 const char *fctid =
"vircam_sci_save_simple";
3231 if (access(fname,F_OK))
3236 *product_frame = cpl_frame_new();
3237 cpl_frame_set_filename(*product_frame,fname);
3243 cpl_frame_set_tag(*product_frame,tag);
3244 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_IMAGE);
3245 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
3246 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
3252 parlist,vircam_recipename,
3253 "PRO-1.15",
template,1);
3257 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,CPL_IO_DEFAULT) !=
3259 cpl_msg_error(fctid,
"Cannot save product PHU");
3260 cpl_frame_delete(*product_frame);
3264 cpl_frameset_insert(framelist,*product_frame);
3276 vircam_recipename,
"PRO-1.15",
template);
3278 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
3279 cpl_msg_error(fctid,
"Cannot save product image extension -- %s",
3280 cpl_error_get_message());
3310 extern int vircam_sci_save_stack(vir_fits *stack, cpl_frameset *framelist,
3311 cpl_parameterlist *parlist,
3312 cpl_frame *
template,
int fnametype,
3313 int stack_num, cpl_frame **product_frame) {
3314 cpl_propertylist *plist;
3315 int isfirst,isdummy;
3316 char fname[BUFSIZ],*base,*tname;
3317 const char *fctid =
"vircam_sci_save_stack";
3322 isfirst = (*product_frame == NULL);
3323 tname = cpl_strdup(cpl_frame_get_filename(
template));
3324 base = basename(tname);
3325 vircam_sci_product_name(base,STACK_FILE,fnametype,stack_num,fname);
3332 if (access(fname,F_OK))
3337 *product_frame = cpl_frame_new();
3338 cpl_frame_set_filename(*product_frame,fname);
3344 cpl_frame_set_tag(*product_frame,VIRCAM_PRO_JITTERED_SCI);
3345 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_IMAGE);
3346 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
3347 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
3355 "PRO-1.15",
template,1);
3359 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
3360 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
3361 cpl_msg_error(fctid,
"Cannot save product PHU");
3362 cpl_frame_delete(*product_frame);
3365 cpl_frameset_insert(framelist,*product_frame);
3377 parlist,vircam_recipename,
3378 "PRO-1.15",
template);
3380 plist,CPL_IO_EXTEND) != CPL_ERROR_NONE) {
3381 cpl_msg_error(fctid,
"Cannot save product image extension -- %s",
3382 cpl_error_get_message());
3412 extern int vircam_sci_save_stack_conf(vir_fits *stack, cpl_frameset *framelist,
3413 cpl_parameterlist *parlist,
3414 cpl_frame *
template,
int fnametype,
3416 cpl_frame **product_frame) {
3417 cpl_propertylist *plist;
3418 int isfirst,isdummy;
3419 char fname[BUFSIZ],*tname,*base;
3420 const char *fctid =
"vircam_sci_save_stack_conf";
3425 isfirst = (*product_frame == NULL);
3426 tname = cpl_strdup(cpl_frame_get_filename(
template));
3427 base = basename(tname);
3428 vircam_sci_product_name(base,STACK_CONF,fnametype,stack_num,fname);
3435 if (access(fname,F_OK))
3440 *product_frame = cpl_frame_new();
3441 cpl_frame_set_filename(*product_frame,fname);
3447 cpl_frame_set_tag(*product_frame,VIRCAM_PRO_CONF_SCI);
3448 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_IMAGE);
3449 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
3450 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
3456 parlist,vircam_recipename,
3457 "PRO-1.15",
template,1);
3461 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
3462 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
3463 cpl_msg_error(fctid,
"Cannot save product PHU");
3464 cpl_frame_delete(*product_frame);
3467 cpl_frameset_insert(framelist,*product_frame);
3479 parlist,vircam_recipename,
3480 "PRO-1.15",
template);
3482 plist,CPL_IO_EXTEND) != CPL_ERROR_NONE) {
3483 cpl_msg_error(fctid,
"Cannot save product image extension -- %s",
3484 cpl_error_get_message());
3514 extern int vircam_sci_save_stack_cat(vir_tfits *stack, cpl_frameset *framelist,
3515 cpl_parameterlist *parlist,
3516 cpl_frame *
template,
int fnametype,
3517 int stack_num, cpl_frame **product_frame) {
3518 cpl_propertylist *plist;
3519 int isfirst,isdummy;
3520 char fname[BUFSIZ],*tname,*base;
3521 const char *fctid =
"vircam_sci_save_stack_cat";
3526 isfirst = (*product_frame == NULL);
3527 tname = cpl_strdup(cpl_frame_get_filename(
template));
3528 base = basename(tname);
3529 vircam_sci_product_name(base,STACK_CAT,fnametype,stack_num,fname);
3536 if (access(fname,F_OK))
3541 *product_frame = cpl_frame_new();
3542 cpl_frame_set_filename(*product_frame,fname);
3548 cpl_frame_set_tag(*product_frame,VIRCAM_PRO_OBJCAT_SCI);
3549 cpl_frame_set_type(*product_frame,CPL_FRAME_TYPE_TABLE);
3550 cpl_frame_set_group(*product_frame,CPL_FRAME_GROUP_PRODUCT);
3551 cpl_frame_set_level(*product_frame,CPL_FRAME_LEVEL_FINAL);
3557 parlist,vircam_recipename,
3562 if (cpl_image_save(NULL,fname,CPL_TYPE_UCHAR,plist,
3563 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
3564 cpl_msg_error(fctid,
"Cannot save product PHU");
3565 cpl_frame_delete(*product_frame);
3568 cpl_frameset_insert(framelist,*product_frame);
3580 parlist,vircam_recipename,
3583 plist,fname,CPL_IO_EXTEND) != CPL_ERROR_NONE) {
3584 cpl_msg_error(fctid,
"Cannot save product table extension -- %s",
3585 cpl_error_get_message());
3625 static void vircam_sci_product_name(
char *
template,
int producttype,
3626 int nametype,
int fnumber,
char *outfname) {
3627 const char *esonames[] = {
"exp_",
"exp_conf_",
"exp_cat",
"stack_",
3628 "stack_conf_",
"stack_cat_",
"sky_"};
3629 const char *suffix[] = {
"_ex",
"_ex_conf",
"_ex_cat",
"_st",
"_st_conf",
3631 char *fname,*bname,*dot;
3638 (void)sprintf(outfname,
"%s%d.fits",esonames[producttype],fnumber);
3645 fname = cpl_strdup(
template);
3646 bname = basename(fname);
3647 (void)sprintf(outfname,
"tmp_%s",bname);
3654 fname = cpl_strdup(
template);
3655 bname = basename(fname);
3656 if (producttype != SKY_FILE) {
3657 (void)sprintf(outfname,
"%s",bname);
3658 dot = strrchr(outfname,
'.');
3659 (void)sprintf(dot,
"%s.fits",suffix[producttype]);
3661 sprintf(outfname,
"%s%s",suffix[producttype],bname);
3669 (void)strcpy(outfname,
"");