vircam_dark_current.c

00001 /* $Id: vircam_dark_current.c,v 1.50 2010/06/30 12:42:00 jim Exp $
00002  *
00003  * This file is part of the VIRCAM Pipeline
00004  * Copyright (C) 2005 Cambridge Astronomy Survey Unit
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019  */
00020 
00021 /*
00022  * $Author: jim $
00023  * $Date: 2010/06/30 12:42:00 $
00024  * $Revision: 1.50 $
00025  * $Name: v1-1-0 $
00026  */
00027 
00028 /* Includes */
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 /* Function prototypes */
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 /* Static global variables */
00059 
00060 static struct {
00061 
00062     /* Input */
00063 
00064     float       thresh;
00065     int         extenum;
00066 
00067     /* Output */
00068 
00069     float       mean_dark_current;
00070 } vircam_dark_current_config;
00071 
00072 static struct {
00073     int              *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 /* Function code */
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     /* Get the recipe out of the plugin */
00221 
00222     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00223         recipe = (cpl_recipe *)plugin;
00224     else
00225         return(-1);
00226 
00227     /* Create the parameters list in the cpl_recipe object */
00228 
00229     recipe->parameters = cpl_parameterlist_new();
00230 
00231     /* Fill in the rejection threshold parameter */
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     /* Extension number of input frames to use */
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     /* Get out of here */
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     /* Get the recipe out of the plugin */
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     /* Get the recipe out of the plugin */
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,nlab,i,j,nx,ny,n,retval,live;
00311     long npts;
00312     double intercept,slope,sig;
00313     const char *fctid = "vircam_dark_current";
00314     float *outdata,val;
00315     unsigned char *bpm;
00316     vir_fits *ff;
00317     cpl_frame *cur_frame;
00318     cpl_propertylist *plist;
00319     cpl_parameter *p;
00320     
00321     /* Check validity of input frameset */
00322 
00323     if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
00324         cpl_msg_error(fctid,"Input framelist NULL or has no input data\n");
00325         return(-1);
00326     }
00327 
00328     /* Check the files in the frameset */
00329 
00330     if (vircam_frameset_fexists(framelist) != VIR_OK) {
00331         cpl_msg_error(fctid,"Input frameset is missing files. Check SOF");
00332         return(-1);
00333     }
00334 
00335     /* Initialise some variables */
00336 
00337     vircam_dark_current_init();
00338 
00339     /* Get the parameters */
00340 
00341     p = cpl_parameterlist_find(parlist,"vircam.vircam_dark_current.thresh");
00342     vircam_dark_current_config.thresh = (float)cpl_parameter_get_double(p);
00343     p = cpl_parameterlist_find(parlist,"vircam.vircam_dark_current.extenum");
00344     vircam_dark_current_config.extenum = cpl_parameter_get_int(p);
00345 
00346     /* Sort out raw from calib frames */
00347 
00348     if (vircam_dfs_set_groups(framelist) != VIR_OK) {
00349         cpl_msg_error(fctid,"Cannot identify RAW and CALIB frames");
00350         return(-1);
00351     }
00352 
00353     /* Get dark frames. Make sure there are at least 2 of them */
00354 
00355     if ((ps.labels = cpl_frameset_labelise(framelist,vircam_compare_tags,
00356                                            &nlab)) == NULL) {
00357         cpl_msg_error(fctid,"Cannot labelise the input frameset");
00358         vircam_dark_current_tidy();
00359         return(-1);
00360     }
00361     if ((ps.darklist = vircam_frameset_subgroup(framelist,ps.labels,nlab,
00362                                                 VIRCAM_DARKCUR_RAW)) == NULL) {
00363         cpl_msg_error(fctid,"Cannot find dark frames in input frameset");
00364         vircam_dark_current_tidy();
00365         return(-1);
00366     }
00367     ps.nframes = cpl_frameset_get_size(ps.darklist);
00368     if (ps.nframes < 2) {
00369         cpl_msg_error(fctid,"Dark frameset doesn't have enough frames");
00370         vircam_dark_current_tidy();
00371         return(-1);
00372     }
00373 
00374     /* Check to see if there is a master bad pixel map. If there isn't one 
00375        then look for a confidence map */
00376 
00377     ps.master_mask = vircam_mask_define(framelist,ps.labels,nlab);
00378 
00379     /* Get some workspace for the data arrays */
00380 
00381     ps.data = cpl_malloc(ps.nframes*sizeof(float *));
00382     ps.subset = cpl_malloc(ps.nframes*sizeof(double));
00383     ps.exps = cpl_malloc(ps.nframes*sizeof(double));
00384 
00385     /* Fill in the exposure times */
00386 
00387     for (i = 0; i < ps.nframes; i++) {
00388         cur_frame = cpl_frameset_get_frame(ps.darklist,i);
00389         plist = cpl_propertylist_load(cpl_frame_get_filename(cur_frame),0);
00390         if (vircam_pfits_get_exptime(plist,&val) != VIR_OK) {
00391             cpl_msg_error(fctid,"Unable to get exposure time for %s",
00392                           cpl_frame_get_filename(cur_frame));
00393             return(-1);
00394         }
00395         ps.exps[i] = (double)val;
00396         cpl_propertylist_delete(plist);
00397     }
00398 
00399     /* Now, how many image extensions do we want to do? If the extension
00400        number is zero, then we loop for all possible extensions. If it
00401        isn't then we just do the extension specified */
00402 
00403     vircam_exten_range(vircam_dark_current_config.extenum,
00404                        (const cpl_frame *)cpl_frameset_get_frame(ps.darklist,0),
00405                        &jst,&jfn);
00406     if (jst == -1 || jfn == -1) {
00407         cpl_msg_error(fctid,"Unable to continue");
00408         vircam_dark_current_tidy();
00409         return(-1);
00410     }
00411 
00412     /* Get some space for the good frames */
00413 
00414     ps.good = cpl_malloc(ps.nframes*sizeof(vir_fits *));
00415 
00416     /* Now loop for all the extensions... */
00417 
00418     for (j = jst; j <= jfn; j++) {
00419         isfirst = (j == jst);
00420         dummy = 0;
00421         vircam_dark_current_config.mean_dark_current = 0.0;
00422 
00423         /* Load the image data from each frame. If there was an
00424            error loading, then just create a dummy output */
00425 
00426         ps.allfits = vircam_fits_load_list(ps.darklist,CPL_TYPE_FLOAT,j);
00427         if (ps.allfits == NULL) {
00428             cpl_msg_info(fctid,"Extension %d darks wouldn't load",j);
00429             dummy = 1;
00430             retval = vircam_dark_current_lastbit(j,framelist,parlist);
00431             if (retval != 0)
00432                 return(-1);
00433             continue;
00434         }
00435 
00436         /* Are any of these images good? */
00437 
00438         ps.ngood = 0;
00439         for (i = 0; i < ps.nframes; i++) {
00440             ff = ps.allfits[i];
00441             vircam_pfits_get_detlive(vircam_fits_get_ehu(ff),&live);
00442             if (! live) {
00443                 cpl_msg_info(fctid,"Detector flagged dead %s",
00444                              vircam_fits_get_fullname(ff));
00445                 vircam_fits_set_error(ff,VIR_FATAL);
00446             } else {
00447                 ps.good[ps.ngood] = ff;
00448                 ps.ngood += 1;
00449             }
00450         }       
00451 
00452         /* If there are too few good images, then signal that we need to 
00453            create some dummy products and move on */
00454 
00455         if (ps.ngood < 2) {
00456             cpl_msg_warning(fctid,"Need at least 2 good images -- %d found",
00457                           ps.ngood);
00458             dummy = 1;
00459             retval = vircam_dark_current_lastbit(j,framelist,parlist);
00460             freefitslist(ps.allfits,ps.nframes);
00461             freeimage(ps.outimage);
00462             if (retval != 0) 
00463                 return(-1);
00464             continue;
00465         }
00466 
00467         /* Get the data arrays */
00468 
00469         for (i = 0; i < ps.ngood; i++)
00470             ps.data[i] = cpl_image_get_data(vircam_fits_get_image(ps.allfits[i]));
00471 
00472         /* Load the BPM */
00473 
00474         nx = cpl_image_get_size_x(vircam_fits_get_image(ps.good[0]));
00475         ny = cpl_image_get_size_y(vircam_fits_get_image(ps.good[0]));
00476         retval = vircam_mask_load(ps.master_mask,j,nx,ny);      
00477         if (retval == VIR_FATAL) {
00478             cpl_msg_info(fctid,"Unable to load mask image %s[%d]",
00479                          vircam_mask_get_filename(ps.master_mask),j);
00480             cpl_msg_info(fctid,"Forcing all pixels to be good from now on");
00481             vircam_mask_force(ps.master_mask,nx,ny);
00482         }
00483         bpm = vircam_mask_get_data(ps.master_mask);
00484 
00485         /* Get an output image */
00486 
00487         ps.outimage = cpl_image_new(nx,ny,CPL_TYPE_FLOAT);
00488         outdata = cpl_image_get_data(ps.outimage);
00489 
00490         /* Now loop over all pixels and work out the slope */
00491 
00492         cpl_msg_info(fctid,"Doing dark current fits for extension %d",j);
00493         npts = (long)(nx*ny);
00494         for (n = 0; n < npts; n++) {
00495             if (bpm[n] != 0) {
00496                 slope = 0.0;
00497             } else {
00498                 for (i = 0; i < ps.ngood; i++)
00499                     ps.subset[i] = (double)(ps.data[i][n]);
00500                 vircam_linfit(ps.ngood,ps.exps,ps.subset,&intercept,&slope,
00501                     &sig);
00502             }
00503 
00504             /* Store the slope away */
00505 
00506             outdata[n] = (float)slope;
00507         }
00508 
00509         /* Get the median value of the dark current */
00510 
00511         vircam_dark_current_config.mean_dark_current = 
00512             vircam_med(outdata,bpm,npts);
00513 
00514         /* Save the last part of the processing and saving */
00515 
00516         (void)vircam_dark_current_lastbit(j,framelist,parlist);
00517 
00518         /* Tidy up */
00519 
00520         freeimage(ps.outimage);
00521         vircam_mask_clear(ps.master_mask);
00522         freefitslist(ps.allfits,ps.nframes);
00523     }
00524 
00525     /* Tidy up */
00526 
00527     vircam_dark_current_tidy();
00528 
00529     return(0);
00530 }
00531 
00532 /*---------------------------------------------------------------------------*/
00539 /*---------------------------------------------------------------------------*/
00540 
00541 static int vircam_dark_current_save(cpl_frameset *framelist, 
00542                                     cpl_parameterlist *parlist) {
00543     cpl_propertylist *plist,*p;
00544     const char *fctid = "vircam_dark_current_save";
00545     const char *outfile = "darkcurrent.fits";
00546     const char *outpaf = "darkcurrent";
00547     const char *recipeid = "vircam_dark_current";
00548     float darkcur_med;
00549 
00550     /* If we need to make a PHU then do that now based on the first frame
00551        in the input frame list */
00552 
00553     darkcur_med = vircam_dark_current_config.mean_dark_current;
00554     if (isfirst) {
00555 
00556         /* Create a new product frame object and define some tags */
00557 
00558         product_frame = cpl_frame_new();
00559         cpl_frame_set_filename(product_frame,outfile);
00560         cpl_frame_set_tag(product_frame,VIRCAM_PRO_DARKCUR);
00561         cpl_frame_set_type(product_frame,CPL_FRAME_TYPE_IMAGE);
00562         cpl_frame_set_group(product_frame,CPL_FRAME_GROUP_PRODUCT);
00563         cpl_frame_set_level(product_frame,CPL_FRAME_LEVEL_FINAL);
00564 
00565         /* Set the PHU header */
00566 
00567         plist = vircam_fits_get_phu(ps.allfits[0]);
00568         ps.phupaf = vircam_paf_phu_items(plist);
00569         vircam_dfs_set_product_primary_header(plist,product_frame,framelist,
00570                                               parlist,(char *)recipeid,
00571                                               "PRO-1.15",NULL,0);
00572         vircam_paf_append(ps.phupaf,plist,"ESO PRO CATG");
00573 
00574         /* 'Save' the PHU image */
00575 
00576         if (cpl_image_save(NULL,outfile,CPL_BPP_8_UNSIGNED,plist,
00577                            CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
00578             cpl_msg_error(fctid,"Cannot save product PHU");
00579             cpl_propertylist_delete(plist);
00580             return(-1);
00581         }
00582         cpl_frameset_insert(framelist,product_frame);
00583     }
00584 
00585     /* Get the header for the extension */
00586 
00587     plist = vircam_fits_get_ehu(ps.allfits[0]);
00588     vircam_dfs_set_product_exten_header(plist,product_frame,framelist,
00589                                         parlist,(char *)recipeid,
00590                                         "PRO-1.15",NULL);
00591 
00592     /* Add the mean dark current to the header as a QC parameter */
00593 
00594     cpl_propertylist_update_float(plist,"ESO QC DARKCURRENT",darkcur_med);
00595     cpl_propertylist_set_comment(plist,"ESO QC DARKCURRENT",
00596                                  "[ADU/s] Median dark current");
00597     if (dummy)
00598         vircam_dummy_property(plist);
00599 
00600     /* Now save the image */
00601 
00602     if (cpl_image_save(ps.outimage,outfile,CPL_BPP_IEEE_FLOAT,plist,
00603                        CPL_IO_EXTEND) != CPL_ERROR_NONE) {
00604         cpl_msg_error(fctid,"Cannot save product image extension");
00605         cpl_propertylist_delete(plist);
00606         return(-1);
00607     }
00608 
00609     /* Write a PAF now */
00610 
00611     p = vircam_paf_req_items(plist);
00612     vircam_merge_propertylists(p,ps.phupaf);
00613     if (vircam_paf_print((char *)outpaf,"VIRCAM/vircam_dark_current","QC file",
00614                          p) != VIR_OK)
00615         cpl_msg_warning(fctid,"Unable to write PAF\n");
00616     cpl_propertylist_delete(p);
00617 
00618     /* Get out of here */
00619 
00620     return(0);
00621 }
00622 
00623 /*---------------------------------------------------------------------------*/
00631 /*---------------------------------------------------------------------------*/
00632 
00633 static int vircam_dark_current_lastbit(int jext, cpl_frameset *framelist,
00634                                        cpl_parameterlist *parlist) {
00635     int retval;
00636     const char *fctid="vircam_dark_current_lastbit";
00637 
00638     /* If this is a dummy result then create it now */
00639 
00640     if (dummy)
00641         ps.outimage = vircam_dummy_image(ps.allfits[0]);
00642                        
00643     /* Save the result */
00644 
00645     cpl_msg_info(fctid,"Saving products for extension %d",jext);
00646     retval = vircam_dark_current_save(framelist,parlist);
00647     if (retval != 0) {
00648         vircam_dark_current_tidy();
00649         return(-1);
00650     }
00651     return(0);
00652 }
00653 
00654 
00655 /*---------------------------------------------------------------------------*/
00659 /*---------------------------------------------------------------------------*/
00660 
00661 static void vircam_dark_current_init(void) {
00662     ps.labels = NULL;
00663     ps.darklist = NULL;
00664     ps.master_mask = NULL;
00665     ps.data = NULL;
00666     ps.allfits = NULL;
00667     ps.subset = NULL;
00668     ps.exps = NULL;
00669     ps.outimage = NULL;
00670     ps.nframes = 0;
00671     ps.good = NULL;
00672     ps.phupaf = NULL;
00673 }
00674 
00675 /*---------------------------------------------------------------------------*/
00679 /*---------------------------------------------------------------------------*/
00680 
00681 static void vircam_dark_current_tidy(void) {
00682 
00683     freespace(ps.labels);
00684     freeframeset(ps.darklist);
00685     freemask(ps.master_mask);
00686     freespace(ps.data);
00687     freespace(ps.subset);
00688     freespace(ps.exps);
00689     freeimage(ps.outimage);
00690     freefitslist(ps.allfits,ps.nframes);
00691     ps.nframes = 0;
00692     freespace(ps.good);
00693     freepropertylist(ps.phupaf);
00694 }
00695 
00698 /*
00699 
00700 $Log: vircam_dark_current.c,v $
00701 Revision 1.50  2010/06/30 12:42:00  jim
00702 A few fixes to stop compiler compaints
00703 
00704 Revision 1.49  2009/09/09 09:50:21  jim
00705 Modified to try and get headers right
00706 
00707 Revision 1.48  2008/10/01 04:59:13  jim
00708 Added call to vircam_frameset_fexists to check input frameset
00709 
00710 Revision 1.47  2008/09/30 11:33:23  jim
00711 Added PRO CATG to pafs
00712 
00713 Revision 1.46  2007/11/20 09:40:27  jim
00714 changed values for linear fit to doubles
00715 
00716 Revision 1.45  2007/11/14 14:47:53  jim
00717 vircam_linfit now works only with doubles
00718 
00719 Revision 1.44  2007/10/25 18:39:22  jim
00720 Altered to remove some lint messages
00721 
00722 Revision 1.43  2007/10/15 12:53:26  jim
00723 Modified for compatibiliity with cpl_4.0
00724 
00725 Revision 1.42  2007/09/06 21:37:53  jim
00726 fixed call to vircam_dfs_setup_product_ routines to use the full input
00727 frameset
00728 
00729 Revision 1.41  2007/08/23 09:01:34  jim
00730 Error when there aren't enough frames is now just a warning
00731 
00732 Revision 1.40  2007/07/18 15:35:41  jim
00733 Added better error handling for missing or corrupt mask extensions
00734 
00735 Revision 1.39  2007/07/09 13:21:55  jim
00736 Modified to use new version of vircam_exten_range
00737 
00738 Revision 1.38  2007/06/13 08:11:27  jim
00739 Modified docs to reflect changes in DFS tags
00740 
00741 Revision 1.37  2007/04/04 10:36:18  jim
00742 Modified to use new dfs tags
00743 
00744 Revision 1.36  2007/03/29 12:19:38  jim
00745 Little changes to improve documentation
00746 
00747 Revision 1.35  2007/03/01 12:41:48  jim
00748 Modified slightly after code checking
00749 
00750 Revision 1.34  2007/02/25 06:26:35  jim
00751 Plugged a few memory leaks
00752 
00753 Revision 1.33  2007/02/15 06:59:37  jim
00754 Added ability to write QC paf files
00755 
00756 Revision 1.32  2007/02/07 10:12:39  jim
00757 Removed calls to vircam_ndit_correct as this is now no longer necessary
00758 
00759 Revision 1.31  2007/02/06 13:11:11  jim
00760 Fixed entry for PRO dictionary in cpl_dfs_set_product_header
00761 
00762 Revision 1.30  2006/11/27 12:13:21  jim
00763 Swapped calls to cpl_propertylist_append to cpl_propertylist_update
00764 
00765 Revision 1.29  2006/11/10 09:19:47  jim
00766 fixed typo
00767 
00768 Revision 1.28  2006/09/29 11:19:30  jim
00769 changed aliases on parameter names
00770 
00771 Revision 1.27  2006/09/09 16:49:39  jim
00772 Header comment update
00773 
00774 Revision 1.26  2006/09/04 23:02:14  jim
00775 Modified to deal with det live issues. Also does a better job of dealing
00776 with duff input
00777 
00778 Revision 1.25  2006/06/20 19:07:00  jim
00779 Corrects for ndit != 1
00780 
00781 Revision 1.24  2006/06/15 09:58:57  jim
00782 Minor changes to docs
00783 
00784 Revision 1.23  2006/06/09 11:32:59  jim
00785 A few more minor fixes for lint
00786 
00787 Revision 1.22  2006/06/09 11:26:25  jim
00788 Small changes to keep lint happy
00789 
00790 Revision 1.21  2006/05/17 11:15:38  jim
00791 plugged memory leak
00792 
00793 Revision 1.20  2006/05/04 11:53:14  jim
00794 Fixed the way the _save routine works to be more consistent with the
00795 standard CPL way of doing things
00796 
00797 Revision 1.19  2006/04/27 09:46:01  jim
00798 Modified DFS frame types to conform to new dictionary
00799 
00800 Revision 1.18  2006/04/25 13:45:56  jim
00801 Fixed to adhere to new calling sequence for vircam_dfs routines
00802 
00803 Revision 1.17  2006/03/23 21:18:45  jim
00804 Minor changes mainly to comment headers
00805 
00806 Revision 1.16  2006/03/22 12:13:51  jim
00807 Modified to use new vircam_mask capability
00808 
00809 Revision 1.15  2006/03/15 10:43:40  jim
00810 Fixed a few things
00811 
00812 Revision 1.14  2006/03/03 14:29:06  jim
00813 Now calls routines with vir_fits.
00814 
00815 Revision 1.13  2006/02/18 11:50:43  jim
00816 Modified the way the dfs product keywords are written using the vircam
00817 routines, rather than the cpl routine that doesn't understand image
00818 extensions
00819 
00820 Revision 1.12  2006/01/23 10:35:55  jim
00821 Now allows either an BPM or CPM to be used as a mask
00822 
00823 Revision 1.11  2005/12/14 22:19:12  jim
00824 fixed docs
00825 
00826 Revision 1.10  2005/12/09 09:47:58  jim
00827 Many changes to add more documentation
00828 
00829 Revision 1.9  2005/12/02 10:45:37  jim
00830 The tags used in the sof are now written to the description string in the
00831 constructor. This is so that if they change in the vircam_dfs.h file, they
00832 aren't then hardcopied into each of the recipes...
00833 
00834 Revision 1.8  2005/12/01 16:25:06  jim
00835 Fixed default output file extension
00836 
00837 Revision 1.7  2005/11/25 09:37:10  jim
00838 Fitting now done by vircam_linfit
00839 
00840 Revision 1.6  2005/11/23 14:57:40  jim
00841 A bit of tidying in response to splint messages
00842 
00843 Revision 1.5  2005/11/08 12:47:44  jim
00844 Made garbage collection a little better
00845 
00846 Revision 1.4  2005/11/03 15:16:28  jim
00847 Lots of changes mainly to strengthen error reporting
00848 
00849 Revision 1.3  2005/08/09 11:09:39  jim
00850 Replaced dodgy call to cpl_framelist_delete with correct cpl_frameset_delete
00851 
00852 Revision 1.2  2005/08/09 10:24:38  jim
00853 Replaced dodgy calls to cpl_msg_err with correct cpl_msg_error
00854 
00855 Revision 1.1.1.1  2005/08/05 08:29:09  jim
00856 Initial import
00857 
00858 
00859 */

Generated on 7 Feb 2011 for VIRCAM Pipeline by  doxygen 1.6.1