00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #ifdef HAVE_CONFIG_H
00031 #include <config.h>
00032 #endif
00033
00034 #include <cpl.h>
00035 #include <stdio.h>
00036 #include <math.h>
00037
00038 #include "vircam_utils.h"
00039 #include "vircam_mask.h"
00040 #include "vircam_pfits.h"
00041 #include "vircam_dfs.h"
00042 #include "vircam_stats.h"
00043 #include "vircam_paf.h"
00044
00045
00046
00047 static int vircam_dark_current_create(cpl_plugin *) ;
00048 static int vircam_dark_current_exec(cpl_plugin *) ;
00049 static int vircam_dark_current_destroy(cpl_plugin *) ;
00050 static int vircam_dark_current(cpl_parameterlist *, cpl_frameset *) ;
00051 static int vircam_dark_current_save(cpl_frameset *filelist,
00052 cpl_parameterlist *parlist);
00053 static int vircam_dark_current_lastbit(int jext, cpl_frameset *framelist,
00054 cpl_parameterlist *parlist);
00055 static void vircam_dark_current_init(void);
00056 static void vircam_dark_current_tidy(void);
00057
00058
00059
00060 static struct {
00061
00062
00063
00064 float thresh;
00065 int extenum;
00066
00067
00068
00069 float mean_dark_current;
00070 } vircam_dark_current_config;
00071
00072 static struct {
00073 cpl_size *labels;
00074 cpl_frameset *darklist;
00075 vir_mask *master_mask;
00076 int nframes;
00077 float **data;
00078 vir_fits **allfits;
00079 double *subset;
00080 double *exps;
00081 cpl_image *outimage;
00082 vir_fits **good;
00083 int ngood;
00084 cpl_propertylist *phupaf;
00085 } ps;
00086
00087 static cpl_frame *product_frame = NULL;
00088 static int isfirst;
00089 static int dummy;
00090
00091 static char vircam_dark_current_description[] =
00092 "vircam_dark_current -- VIRCAM recipe for measuring dark current.\n"
00093 "A list of dark frames is given. A robust estimate of the dark current\n"
00094 "is calculated by fitting a median slope to the dark value vs exposure time\n"
00095 "for each pixel. The output is to a dark current map which shows the dark\n"
00096 "current in counts per second for each input pixel.\n\n"
00097 "The program requires the following files in the SOF:\n\n"
00098 " Tag Description\n"
00099 " -----------------------------------------------------------------------\n"
00100 " %-21s A list of raw dark images with various exposure times\n"
00101 " %-21s Optional master bad pixel map or\n"
00102 " %-21s Optional master confidence map\n"
00103 "\n";
00104
00167
00168
00169
00177
00178
00179 int cpl_plugin_get_info(cpl_pluginlist *list) {
00180 cpl_recipe *recipe = cpl_calloc(1,sizeof(*recipe));
00181 cpl_plugin *plugin = &recipe->interface;
00182 char alldesc[SZ_ALLDESC];
00183 (void)snprintf(alldesc,SZ_ALLDESC,vircam_dark_current_description,
00184 VIRCAM_DARKCUR_RAW,VIRCAM_CAL_BPM,VIRCAM_CAL_CONF);
00185
00186 cpl_plugin_init(plugin,
00187 CPL_PLUGIN_API,
00188 VIRCAM_BINARY_VERSION,
00189 CPL_PLUGIN_TYPE_RECIPE,
00190 "vircam_dark_current",
00191 "VIRCAM recipe to determine detector dark current",
00192 alldesc,
00193 "Jim Lewis",
00194 "jrl@ast.cam.ac.uk",
00195 vircam_get_license(),
00196 vircam_dark_current_create,
00197 vircam_dark_current_exec,
00198 vircam_dark_current_destroy);
00199
00200 cpl_pluginlist_append(list,plugin);
00201
00202 return(0);
00203 }
00204
00205
00214
00215
00216 static int vircam_dark_current_create(cpl_plugin *plugin) {
00217 cpl_recipe *recipe;
00218 cpl_parameter *p;
00219
00220
00221
00222 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00223 recipe = (cpl_recipe *)plugin;
00224 else
00225 return(-1);
00226
00227
00228
00229 recipe->parameters = cpl_parameterlist_new();
00230
00231
00232
00233 p = cpl_parameter_new_value("vircam.vircam_dark_current.thresh",
00234 CPL_TYPE_DOUBLE,
00235 "Rejection threshold in sigma above background", "vircam.vircam_dark_current",5.0);
00236 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"thresh");
00237 cpl_parameterlist_append(recipe->parameters,p);
00238
00239
00240
00241 p = cpl_parameter_new_range("vircam.vircam_dark_current.extenum",
00242 CPL_TYPE_INT,
00243 "Extension number to be done, 0 == all",
00244 "vircam.vircam_dark_current",
00245 1,0,16);
00246 cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"ext");
00247 cpl_parameterlist_append(recipe->parameters,p);
00248
00249
00250
00251 return(0);
00252 }
00253
00254
00255
00261
00262
00263 static int vircam_dark_current_destroy(cpl_plugin *plugin) {
00264 cpl_recipe *recipe ;
00265
00266
00267
00268 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00269 recipe = (cpl_recipe *)plugin;
00270 else
00271 return(-1);
00272
00273 cpl_parameterlist_delete(recipe->parameters);
00274 return(0);
00275 }
00276
00277
00278
00284
00285
00286 static int vircam_dark_current_exec(cpl_plugin *plugin) {
00287 cpl_recipe *recipe;
00288
00289
00290
00291 if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00292 recipe = (cpl_recipe *)plugin;
00293 else
00294 return(-1);
00295
00296 return(vircam_dark_current(recipe->parameters,recipe->frames));
00297 }
00298
00299
00306
00307
00308 static int vircam_dark_current(cpl_parameterlist *parlist,
00309 cpl_frameset *framelist) {
00310 int jst,jfn,i,j,nx,ny,n,retval,live;
00311 cpl_size nlab;
00312 long npts;
00313 double intercept,slope,sig;
00314 const char *fctid = "vircam_dark_current";
00315 float *outdata,val;
00316 unsigned char *bpm;
00317 vir_fits *ff;
00318 cpl_frame *cur_frame;
00319 cpl_propertylist *plist;
00320 cpl_parameter *p;
00321
00322
00323
00324 if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
00325 cpl_msg_error(fctid,"Input framelist NULL or has no input data");
00326 return(-1);
00327 }
00328
00329
00330
00331 if (vircam_frameset_fexists(framelist) != VIR_OK) {
00332 cpl_msg_error(fctid,"Input frameset is missing files. Check SOF");
00333 return(-1);
00334 }
00335
00336
00337
00338 vircam_dark_current_init();
00339
00340
00341
00342 p = cpl_parameterlist_find(parlist,"vircam.vircam_dark_current.thresh");
00343 vircam_dark_current_config.thresh = (float)cpl_parameter_get_double(p);
00344 p = cpl_parameterlist_find(parlist,"vircam.vircam_dark_current.extenum");
00345 vircam_dark_current_config.extenum = cpl_parameter_get_int(p);
00346
00347
00348
00349 if (vircam_dfs_set_groups(framelist) != VIR_OK) {
00350 cpl_msg_error(fctid,"Cannot identify RAW and CALIB frames");
00351 return(-1);
00352 }
00353
00354
00355
00356 if ((ps.labels = cpl_frameset_labelise(framelist,vircam_compare_tags,
00357 &nlab)) == NULL) {
00358 cpl_msg_error(fctid,"Cannot labelise the input frameset");
00359 vircam_dark_current_tidy();
00360 return(-1);
00361 }
00362 if ((ps.darklist = vircam_frameset_subgroup(framelist,ps.labels,nlab,
00363 VIRCAM_DARKCUR_RAW)) == NULL) {
00364 cpl_msg_error(fctid,"Cannot find dark frames in input frameset");
00365 vircam_dark_current_tidy();
00366 return(-1);
00367 }
00368 ps.nframes = cpl_frameset_get_size(ps.darklist);
00369 if (ps.nframes < 2) {
00370 cpl_msg_error(fctid,"Dark frameset doesn't have enough frames");
00371 vircam_dark_current_tidy();
00372 return(-1);
00373 }
00374
00375
00376
00377
00378 ps.master_mask = vircam_mask_define(framelist,ps.labels,nlab);
00379
00380
00381
00382 ps.data = cpl_malloc(ps.nframes*sizeof(float *));
00383 ps.subset = cpl_malloc(ps.nframes*sizeof(double));
00384 ps.exps = cpl_malloc(ps.nframes*sizeof(double));
00385
00386
00387
00388 for (i = 0; i < ps.nframes; i++) {
00389 cur_frame = cpl_frameset_get_frame(ps.darklist,i);
00390 plist = cpl_propertylist_load(cpl_frame_get_filename(cur_frame),0);
00391 if (vircam_pfits_get_exptime(plist,&val) != VIR_OK) {
00392 cpl_msg_error(fctid,"Unable to get exposure time for %s",
00393 cpl_frame_get_filename(cur_frame));
00394 return(-1);
00395 }
00396 ps.exps[i] = (double)val;
00397 cpl_propertylist_delete(plist);
00398 }
00399
00400
00401
00402
00403
00404 vircam_exten_range(vircam_dark_current_config.extenum,
00405 (const cpl_frame *)cpl_frameset_get_frame(ps.darklist,0),
00406 &jst,&jfn);
00407 if (jst == -1 || jfn == -1) {
00408 cpl_msg_error(fctid,"Unable to continue");
00409 vircam_dark_current_tidy();
00410 return(-1);
00411 }
00412
00413
00414
00415 ps.good = cpl_malloc(ps.nframes*sizeof(vir_fits *));
00416
00417
00418
00419 for (j = jst; j <= jfn; j++) {
00420 isfirst = (j == jst);
00421 dummy = 0;
00422 vircam_dark_current_config.mean_dark_current = 0.0;
00423
00424
00425
00426
00427 ps.allfits = vircam_fits_load_list(ps.darklist,CPL_TYPE_FLOAT,j);
00428 if (ps.allfits == NULL) {
00429 cpl_msg_info(fctid,
00430 "Extension %" CPL_SIZE_FORMAT " darks wouldn't load",
00431 (cpl_size)j);
00432 dummy = 1;
00433 retval = vircam_dark_current_lastbit(j,framelist,parlist);
00434 if (retval != 0)
00435 return(-1);
00436 continue;
00437 }
00438
00439
00440
00441 ps.ngood = 0;
00442 for (i = 0; i < ps.nframes; i++) {
00443 ff = ps.allfits[i];
00444 vircam_pfits_get_detlive(vircam_fits_get_ehu(ff),&live);
00445 if (! live) {
00446 cpl_msg_info(fctid,"Detector flagged dead %s",
00447 vircam_fits_get_fullname(ff));
00448 vircam_fits_set_error(ff,VIR_FATAL);
00449 } else {
00450 ps.good[ps.ngood] = ff;
00451 ps.ngood += 1;
00452 }
00453 }
00454
00455
00456
00457
00458 if (ps.ngood < 2) {
00459 cpl_msg_warning(fctid,
00460 "Need at least 2 good images -- %" CPL_SIZE_FORMAT" found",
00461 (cpl_size)(ps.ngood));
00462 dummy = 1;
00463 retval = vircam_dark_current_lastbit(j,framelist,parlist);
00464 freefitslist(ps.allfits,ps.nframes);
00465 freeimage(ps.outimage);
00466 if (retval != 0)
00467 return(-1);
00468 continue;
00469 }
00470
00471
00472
00473 for (i = 0; i < ps.ngood; i++)
00474 ps.data[i] = cpl_image_get_data(vircam_fits_get_image(ps.allfits[i]));
00475
00476
00477
00478 nx = (int)cpl_image_get_size_x(vircam_fits_get_image(ps.good[0]));
00479 ny = (int)cpl_image_get_size_y(vircam_fits_get_image(ps.good[0]));
00480 retval = vircam_mask_load(ps.master_mask,j,nx,ny);
00481 if (retval == VIR_FATAL) {
00482 cpl_msg_info(fctid,
00483 "Unable to load mask image %s[%" CPL_SIZE_FORMAT "]",
00484 vircam_mask_get_filename(ps.master_mask),(cpl_size)j);
00485 cpl_msg_info(fctid,"Forcing all pixels to be good from now on");
00486 vircam_mask_force(ps.master_mask,nx,ny);
00487 }
00488 bpm = vircam_mask_get_data(ps.master_mask);
00489
00490
00491
00492 ps.outimage = cpl_image_new((cpl_size)nx,(cpl_size)ny,CPL_TYPE_FLOAT);
00493 outdata = cpl_image_get_data(ps.outimage);
00494
00495
00496
00497 cpl_msg_info(fctid,
00498 "Doing dark current fits for extension %" CPL_SIZE_FORMAT,
00499 (cpl_size)j);
00500 npts = (long)(nx*ny);
00501 for (n = 0; n < npts; n++) {
00502 if (bpm[n] != 0) {
00503 slope = 0.0;
00504 } else {
00505 for (i = 0; i < ps.ngood; i++)
00506 ps.subset[i] = (double)(ps.data[i][n]);
00507 vircam_linfit(ps.ngood,ps.exps,ps.subset,&intercept,&slope,
00508 &sig);
00509 }
00510
00511
00512
00513 outdata[n] = (float)slope;
00514 }
00515
00516
00517
00518 vircam_dark_current_config.mean_dark_current =
00519 vircam_med(outdata,bpm,npts);
00520
00521
00522
00523 (void)vircam_dark_current_lastbit(j,framelist,parlist);
00524
00525
00526
00527 freeimage(ps.outimage);
00528 vircam_mask_clear(ps.master_mask);
00529 freefitslist(ps.allfits,ps.nframes);
00530 }
00531
00532
00533
00534 vircam_dark_current_tidy();
00535
00536 return(0);
00537 }
00538
00539
00546
00547
00548 static int vircam_dark_current_save(cpl_frameset *framelist,
00549 cpl_parameterlist *parlist) {
00550 cpl_propertylist *plist,*p;
00551 const char *fctid = "vircam_dark_current_save";
00552 const char *outfile = "darkcurrent.fits";
00553 const char *outpaf = "darkcurrent";
00554 const char *recipeid = "vircam_dark_current";
00555 float darkcur_med;
00556
00557
00558
00559
00560 darkcur_med = vircam_dark_current_config.mean_dark_current;
00561 if (isfirst) {
00562
00563
00564
00565 product_frame = cpl_frame_new();
00566 cpl_frame_set_filename(product_frame,outfile);
00567 cpl_frame_set_tag(product_frame,VIRCAM_PRO_DARKCUR);
00568 cpl_frame_set_type(product_frame,CPL_FRAME_TYPE_IMAGE);
00569 cpl_frame_set_group(product_frame,CPL_FRAME_GROUP_PRODUCT);
00570 cpl_frame_set_level(product_frame,CPL_FRAME_LEVEL_FINAL);
00571
00572
00573
00574 plist = vircam_fits_get_phu(ps.allfits[0]);
00575 ps.phupaf = vircam_paf_phu_items(plist);
00576 vircam_dfs_set_product_primary_header(plist,product_frame,framelist,
00577 parlist,(char *)recipeid,
00578 "PRO-1.15",NULL,0);
00579 vircam_paf_append(ps.phupaf,plist,"ESO PRO CATG");
00580
00581
00582
00583 if (cpl_image_save(NULL,outfile,CPL_TYPE_UCHAR,plist,
00584 CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
00585 cpl_msg_error(fctid,"Cannot save product PHU");
00586 cpl_propertylist_delete(plist);
00587 return(-1);
00588 }
00589 cpl_frameset_insert(framelist,product_frame);
00590 }
00591
00592
00593
00594 plist = vircam_fits_get_ehu(ps.allfits[0]);
00595 vircam_dfs_set_product_exten_header(plist,product_frame,framelist,
00596 parlist,(char *)recipeid,
00597 "PRO-1.15",NULL);
00598
00599
00600
00601 cpl_propertylist_update_float(plist,"ESO QC DARKCURRENT",darkcur_med);
00602 cpl_propertylist_set_comment(plist,"ESO QC DARKCURRENT",
00603 "[ADU/s] Median dark current");
00604 if (dummy)
00605 vircam_dummy_property(plist);
00606
00607
00608
00609 if (cpl_image_save(ps.outimage,outfile,CPL_TYPE_FLOAT,plist,
00610 CPL_IO_EXTEND) != CPL_ERROR_NONE) {
00611 cpl_msg_error(fctid,"Cannot save product image extension");
00612 cpl_propertylist_delete(plist);
00613 return(-1);
00614 }
00615
00616
00617
00618 p = vircam_paf_req_items(plist);
00619 vircam_merge_propertylists(p,ps.phupaf);
00620 if (vircam_paf_print((char *)outpaf,"VIRCAM/vircam_dark_current","QC file",
00621 p) != VIR_OK)
00622 cpl_msg_warning(fctid,"Unable to write PAF");
00623 cpl_propertylist_delete(p);
00624
00625
00626
00627 return(0);
00628 }
00629
00630
00638
00639
00640 static int vircam_dark_current_lastbit(int jext, cpl_frameset *framelist,
00641 cpl_parameterlist *parlist) {
00642 int retval;
00643 const char *fctid="vircam_dark_current_lastbit";
00644
00645
00646
00647 if (dummy)
00648 ps.outimage = vircam_dummy_image(ps.allfits[0]);
00649
00650
00651
00652 cpl_msg_info(fctid,"Saving products for extension %" CPL_SIZE_FORMAT,
00653 (cpl_size)jext);
00654 retval = vircam_dark_current_save(framelist,parlist);
00655 if (retval != 0) {
00656 vircam_dark_current_tidy();
00657 return(-1);
00658 }
00659 return(0);
00660 }
00661
00662
00663
00667
00668
00669 static void vircam_dark_current_init(void) {
00670 ps.labels = NULL;
00671 ps.darklist = NULL;
00672 ps.master_mask = NULL;
00673 ps.data = NULL;
00674 ps.allfits = NULL;
00675 ps.subset = NULL;
00676 ps.exps = NULL;
00677 ps.outimage = NULL;
00678 ps.nframes = 0;
00679 ps.good = NULL;
00680 ps.phupaf = NULL;
00681 }
00682
00683
00687
00688
00689 static void vircam_dark_current_tidy(void) {
00690
00691 freespace(ps.labels);
00692 freeframeset(ps.darklist);
00693 freemask(ps.master_mask);
00694 freespace(ps.data);
00695 freespace(ps.subset);
00696 freespace(ps.exps);
00697 freeimage(ps.outimage);
00698 freefitslist(ps.allfits,ps.nframes);
00699 ps.nframes = 0;
00700 freespace(ps.good);
00701 freepropertylist(ps.phupaf);
00702 }
00703
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873