vircam_mesostep_analyse.c

00001 /* $Id: vircam_mesostep_analyse.c,v 1.22 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.22 $
00025  * $Name: v1-1-0 $
00026  */
00027 
00028 /* Includes */
00029 
00030 #ifdef HAVE_CONFIG_H
00031 #include <config.h>
00032 #endif
00033 
00034 #include <stdio.h>
00035 #include <math.h>
00036 #include <string.h>
00037 #include <cpl.h>
00038 
00039 #include "vircam_utils.h"
00040 #include "vircam_mask.h"
00041 #include "vircam_pfits.h"
00042 #include "vircam_dfs.h"
00043 #include "vircam_mods.h"
00044 #include "vircam_fits.h"
00045 #include "vircam_tfits.h"
00046 #include "vircam_jmp_utils.h"
00047 
00048 /* Function prototypes */
00049 
00050 static int vircam_mesostep_analyse_create(cpl_plugin *);
00051 static int vircam_mesostep_analyse_exec(cpl_plugin *);
00052 static int vircam_mesostep_analyse_destroy(cpl_plugin *);
00053 static int vircam_mesostep_analyse(cpl_parameterlist *, cpl_frameset *);
00054 static cpl_propertylist *vircam_mesostep_analyse_dummyqc(int type);
00055 
00056 
00057 static char vircam_mesostep_analyse_description[] =
00058 "vircam_mesostep_analyse -- VIRCAM mesostep processing recipe.\n\n"
00059 "Process a complete mesostep sequence of vircam data. Remove instrumental\n"
00060 "signature and sky subtract if desired. Work out the illumination correction\n"
00061 "for all of the input frames and then smooth the result by fitting a 2d\n"
00062 "polynomial. Evaluate the polynomial at the grid points to form the final\n"
00063 "illumination correction data product\n"
00064 "The program accepts the following files in the SOF:\n\n"
00065 "    Tag                   Description\n"
00066 "    -----------------------------------------------------------------------\n"
00067 "    %-21s A list of raw science images\n"
00068 "    %-21s A master dark frame\n"
00069 "    %-21s A master twilight flat frame\n"
00070 "    %-21s A channel table\n"
00071 "    %-21s A photometric calibration table\n"
00072 "    %-21s A master confidence map or\n"
00073 "    %-21s A master bad pixel mask\n"
00074 "    %-21s A master standard star index\n"
00075 "All of the above are required\n"
00076 "\n";
00077 
00156 /* Function code */
00157 
00158 /*---------------------------------------------------------------------------*/
00166 /*---------------------------------------------------------------------------*/
00167 
00168 int cpl_plugin_get_info(cpl_pluginlist *list) {
00169     cpl_recipe  *recipe = cpl_calloc(1,sizeof(*recipe));
00170     cpl_plugin  *plugin = &recipe->interface;
00171     char alldesc[SZ_ALLDESC];
00172     (void)snprintf(alldesc,SZ_ALLDESC,vircam_mesostep_analyse_description,
00173                    VIRCAM_ILLUM_RAW,VIRCAM_CAL_DARK,VIRCAM_CAL_TWILIGHT_FLAT,
00174                    VIRCAM_CAL_CHANTAB,VIRCAM_CAL_PHOTTAB,VIRCAM_CAL_CONF,
00175                    VIRCAM_CAL_BPM,VIRCAM_CAL_2MASS);
00176 
00177     cpl_plugin_init(plugin,
00178                     CPL_PLUGIN_API,
00179                     VIRCAM_BINARY_VERSION,
00180                     CPL_PLUGIN_TYPE_RECIPE,
00181                     "vircam_mesostep_analyse",
00182                     "VIRCAM mesostep analysis recipe",
00183                     alldesc,
00184                     "Jim Lewis",
00185                     "jrl@ast.cam.ac.uk",
00186                     vircam_get_license(),
00187                     vircam_mesostep_analyse_create,
00188                     vircam_mesostep_analyse_exec,
00189                     vircam_mesostep_analyse_destroy);
00190 
00191     cpl_pluginlist_append(list,plugin);
00192 
00193     return(0);
00194 }
00195 
00196 /*---------------------------------------------------------------------------*/
00205 /*---------------------------------------------------------------------------*/
00206 
00207 static int vircam_mesostep_analyse_create(cpl_plugin *plugin) {
00208     cpl_recipe      *recipe;
00209     cpl_parameter   *p;
00210 
00211     /* Get the recipe out of the plugin */
00212 
00213     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00214         recipe = (cpl_recipe *)plugin;
00215     else 
00216         return(-1);
00217 
00218     /* Create the parameters list in the cpl_recipe object */
00219 
00220     recipe->parameters = cpl_parameterlist_new();
00221 
00222     /* Fill in the minimum object size */
00223 
00224     p = cpl_parameter_new_value("vircam.vircam_mesostep_analyse.ipix",
00225                                 CPL_TYPE_INT,
00226                                 "Minimum pixel area for each detected object",
00227                                 "vircam.vircam_mesostep_analyse",5);
00228     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"ipix");
00229     cpl_parameterlist_append(recipe->parameters,p);
00230 
00231     /* Fill in the detection threshold parameter */
00232 
00233     p = cpl_parameter_new_value("vircam.vircam_mesostep_analyse.thresh",
00234                                 CPL_TYPE_DOUBLE,
00235                                 "Detection threshold in sigma above sky",
00236                                 "vircam.vircam_mesostep_analyse",2.0);
00237     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"thr");
00238     cpl_parameterlist_append(recipe->parameters,p);
00239 
00240     /* Fill in flag to use deblending software or not */
00241 
00242     p = cpl_parameter_new_value("vircam.vircam_mesostep_analyse.icrowd",
00243                                 CPL_TYPE_BOOL,"Use deblending?",
00244                                 "vircam.vircam_mesostep_analyse",0);
00245     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"icrowd");
00246     cpl_parameterlist_append(recipe->parameters,p);
00247 
00248     /* Fill in core radius */
00249 
00250     p = cpl_parameter_new_value("vircam.vircam_mesostep_analyse.rcore",
00251                                 CPL_TYPE_DOUBLE,"Value of Rcore in pixels",
00252                                 "vircam.vircam_mesostep_analyse",3.0);
00253     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"rcore");
00254     cpl_parameterlist_append(recipe->parameters,p);
00255 
00256     /* Fill in background smoothing box size */
00257 
00258     p = cpl_parameter_new_value("vircam.vircam_mesostep_analyse.nbsize",
00259                                 CPL_TYPE_INT,"Background smoothing box size",
00260                                 "vircam.vircam_mesostep_analyse",64);
00261     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"nb");
00262     cpl_parameterlist_append(recipe->parameters,p);
00263 
00264     /* Fill in flag to destripe the images */
00265 
00266     p = cpl_parameter_new_value("vircam.vircam_mesostep_analyse.destripe",
00267                                 CPL_TYPE_BOOL,"Destripe images?",
00268                                 "vircam.vircam_mesostep_analyse",1);
00269     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"destripe");
00270     cpl_parameterlist_append(recipe->parameters,p);
00271 
00272     /* Fill in flag to correct sky background */
00273 
00274     p = cpl_parameter_new_value("vircam.vircam_mesostep_analyse.skycor",
00275                                 CPL_TYPE_BOOL,"Sky correct images?",
00276                                 "vircam.vircam_mesostep_analyse",1);
00277     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"skycor");
00278     cpl_parameterlist_append(recipe->parameters,p);
00279 
00280     /* Order for surface fit */
00281 
00282     p = cpl_parameter_new_value("vircam.vircam_mesostep_analyse.nord",
00283                                 CPL_TYPE_INT,
00284                                 "Polynomial order for surface fit",
00285                                 "vircam.vircam_mesostep_analyse",3);
00286     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"nord");
00287     cpl_parameterlist_append(recipe->parameters,p);
00288 
00289     /* Extension number of input frames to use */
00290 
00291     p = cpl_parameter_new_range("vircam.vircam_mesostep_analyse.extenum",
00292                                 CPL_TYPE_INT,
00293                                 "Extension number to be done, 0 == all",
00294                                 "vircam.vircam_mesostep_analyse",
00295                                 1,0,16);
00296     cpl_parameter_set_alias(p,CPL_PARAMETER_MODE_CLI,"ext");
00297     cpl_parameterlist_append(recipe->parameters,p);
00298         
00299     /* Get out of here */
00300 
00301     return(0);
00302 }
00303         
00304 /*---------------------------------------------------------------------------*/
00310 /*---------------------------------------------------------------------------*/
00311 
00312 static int vircam_mesostep_analyse_exec(cpl_plugin *plugin) {
00313     cpl_recipe  *recipe;
00314 
00315     /* Get the recipe out of the plugin */
00316 
00317     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00318         recipe = (cpl_recipe *)plugin;
00319     else 
00320         return(-1);
00321 
00322     return(vircam_mesostep_analyse(recipe->parameters,recipe->frames));
00323 }
00324                                 
00325 /*---------------------------------------------------------------------------*/
00331 /*---------------------------------------------------------------------------*/
00332 
00333 static int vircam_mesostep_analyse_destroy(cpl_plugin *plugin) {
00334     cpl_recipe *recipe ;
00335 
00336     /* Get the recipe out of the plugin */
00337 
00338     if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
00339         recipe = (cpl_recipe *)plugin;
00340     else 
00341         return(-1);
00342 
00343     cpl_parameterlist_delete(recipe->parameters);
00344     return(0);
00345 }
00346 
00347 /*---------------------------------------------------------------------------*/
00354 /*---------------------------------------------------------------------------*/
00355 
00356 static int vircam_mesostep_analyse(cpl_parameterlist *parlist, 
00357                                    cpl_frameset *framelist) {
00358     const char *fctid="vircam_mesostep_analyse";
00359     cpl_parameter *p;
00360     cpl_polynomial *poly;
00361     int nlab,jst,jfn,status,isconf,j,i,live,nrows,n,ndit;
00362     float *xx1,*xx2,*yy1,*yy2,*ill,gaincor_fac;
00363     double *bv_x,*bv_y,*vdata,val;
00364     cpl_bivector *bv;
00365     cpl_vector *v;
00366     vir_fits *ff;
00367     cpl_table *ic;
00368     cpl_frame *catindex;
00369     cpl_propertylist *pp;
00370 
00371     /* Check validity of input frameset */
00372 
00373     if (framelist == NULL || cpl_frameset_get_size(framelist) <= 0) {
00374         cpl_msg_error(fctid,"Input framelist NULL or has no input data\n");
00375         return(-1);
00376     }
00377 
00378     /* Check the files in the frameset */
00379 
00380     if (vircam_frameset_fexists(framelist) != VIR_OK) {
00381         cpl_msg_error(fctid,"Input frameset is missing files. Check SOF");
00382         return(-1);
00383     }
00384 
00385     /* Initialise some things */
00386 
00387     vircam_jmp_init();
00388     (void)strncpy(vircam_recipename,fctid,VIRCAM_PATHSZ);
00389     (void)snprintf(vircam_recipepaf,VIRCAM_PATHSZ,"VIRCAM/%s",fctid);
00390     recflag = RECMES;
00391 
00392     /* Get the parameters */
00393 
00394     p = cpl_parameterlist_find(parlist,
00395                                "vircam.vircam_mesostep_analyse.ipix");
00396     vircam_jmp_config.ipix = cpl_parameter_get_int(p);
00397     p = cpl_parameterlist_find(parlist,
00398                                "vircam.vircam_mesostep_analyse.thresh");
00399     vircam_jmp_config.threshold = (float)cpl_parameter_get_double(p);
00400     p = cpl_parameterlist_find(parlist,
00401                                "vircam.vircam_mesostep_analyse.icrowd");
00402     vircam_jmp_config.icrowd = cpl_parameter_get_bool(p);
00403     p = cpl_parameterlist_find(parlist,
00404                                "vircam.vircam_mesostep_analyse.rcore");
00405     vircam_jmp_config.rcore = (float)cpl_parameter_get_double(p);
00406     p = cpl_parameterlist_find(parlist,
00407                                "vircam.vircam_mesostep_analyse.nbsize");
00408     vircam_jmp_config.nbsize = cpl_parameter_get_int(p);
00409     p = cpl_parameterlist_find(parlist,
00410                                "vircam.vircam_mesostep_analyse.destripe");
00411     vircam_jmp_config.destripe = cpl_parameter_get_bool(p);
00412     p = cpl_parameterlist_find(parlist,
00413                                "vircam.vircam_mesostep_analyse.skycor");
00414     vircam_jmp_config.skycor = cpl_parameter_get_bool(p);
00415     p = cpl_parameterlist_find(parlist,
00416                                "vircam.vircam_mesostep_analyse.nord");
00417     vircam_jmp_config.nord = cpl_parameter_get_int(p);
00418     p = cpl_parameterlist_find(parlist,
00419                                "vircam.vircam_mesostep_analyse.extenum");
00420     vircam_jmp_config.extenum = cpl_parameter_get_int(p);
00421 
00422     /* Sort out raw from calib frames */
00423 
00424     if (vircam_dfs_set_groups(framelist) != VIR_OK) {
00425         cpl_msg_error(fctid,"Cannot identify RAW and CALIB frames");
00426         vircam_jmp_tidy(0);
00427         return(-1);
00428     }
00429 
00430     /* Label the input frames */
00431 
00432     if ((ps.labels = cpl_frameset_labelise(framelist,vircam_compare_tags,
00433                                            &nlab)) == NULL) {
00434         cpl_msg_error(fctid,"Cannot labelise the input frames");
00435         vircam_jmp_tidy(0);
00436         return(-1);
00437     }
00438 
00439     /* Get the input science frames */
00440 
00441     if ((ps.science_frames = 
00442          vircam_frameset_subgroup(framelist,ps.labels,nlab,
00443                                   VIRCAM_ILLUM_RAW)) == NULL) {
00444         cpl_msg_error(fctid,"No science images to process!");
00445         vircam_jmp_tidy(0);
00446         return(-1);
00447     }
00448 
00449     /* Check to see if there is a master dark frame */
00450 
00451     if ((ps.master_dark = 
00452          vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00453                                     VIRCAM_CAL_DARK)) == NULL) {
00454         cpl_msg_error(fctid,"No master dark found");
00455         vircam_jmp_tidy(0);
00456         return(-1);
00457     }
00458         
00459     /* Check to see if there is a master twilight flat frame */
00460 
00461     if ((ps.master_twilight_flat = 
00462          vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00463                                     VIRCAM_CAL_TWILIGHT_FLAT)) == NULL) {
00464         cpl_msg_error(fctid,"No master twilight flat found");
00465         vircam_jmp_tidy(0);
00466         return(-1);
00467     }
00468         
00469     /* Get the gain corrections */
00470 
00471     status = VIR_OK;
00472     if (vircam_gaincor_calc(ps.master_twilight_flat,&i,&(ps.gaincors),
00473                             &status) != VIR_OK) {
00474         cpl_msg_error(fctid,"Error calculating gain corrections");
00475         vircam_jmp_tidy(0);
00476         return(-1);
00477     }
00478         
00479     /* Check to see if there is a master confidence map. If there isn't
00480        then look for a bad pixel mask that can be converted into a 
00481        confidence map (in an emergency) */
00482 
00483     isconf = 1;
00484     if ((ps.master_conf = 
00485          vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00486                                     VIRCAM_CAL_CONF)) == NULL) {
00487         isconf = 0;
00488         if ((ps.master_conf = 
00489              vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00490                                         VIRCAM_CAL_BPM)) == NULL) {
00491             cpl_msg_error(fctid,"No master confidence map found");
00492             vircam_jmp_tidy(0);
00493             return(-1);
00494         }
00495     }
00496     ps.mask = vircam_mask_define(framelist,ps.labels,nlab);
00497         
00498     /* Check to see if there is a channel table */
00499 
00500     if ((ps.chantab = vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00501                                                  VIRCAM_CAL_CHANTAB)) == NULL) {
00502         cpl_msg_error(fctid,"No channel table found");
00503         vircam_jmp_tidy(0);
00504         return(-1);
00505     }
00506 
00507     /* Check to see if there is a photometric table */
00508 
00509     if ((ps.phottab = vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00510                                                  VIRCAM_CAL_PHOTTAB)) == NULL) {
00511         cpl_msg_error(fctid,"No photometric table found");
00512         vircam_jmp_tidy(0);
00513         return(-1);
00514     }
00515     if ((ps.tphottab = cpl_table_load(cpl_frame_get_filename(ps.phottab),1,0)) == NULL) {
00516         cpl_msg_error(fctid,"Unable to load photometric table");
00517         vircam_jmp_tidy(0);
00518         return(-1);
00519     }
00520 
00521     /* Is the 2mass index file specified? */
00522 
00523     if ((catindex = vircam_frameset_subgroup_1(framelist,ps.labels,nlab,
00524                                                VIRCAM_CAL_2MASS)) == NULL) {
00525         cpl_msg_info(fctid,"No 2MASS index found -- cannot continue");
00526         vircam_jmp_tidy(0);
00527         return(-1);
00528     }
00529     
00530     /* Get catalogue parameters */
00531 
00532     if (vircam_catpars(catindex,&(ps.catpath),&(ps.catname)) == VIR_FATAL) {
00533         vircam_jmp_tidy(0);
00534         cpl_frame_delete(catindex);
00535         return(-1);
00536     }
00537     cpl_frame_delete(catindex);
00538 
00539     /* Get the number of DITs */
00540 
00541     pp = cpl_propertylist_load(cpl_frame_get_filename(cpl_frameset_get_frame(ps.science_frames,0)),0);
00542     if (vircam_pfits_get_ndit(pp,&ndit) != VIR_OK) {
00543         cpl_msg_error(fctid,"No value for NDIT available");
00544         freepropertylist(pp);
00545         vircam_jmp_tidy(0);
00546         return(-1);
00547     }
00548     cpl_propertylist_delete(pp);
00549 
00550     /* Now, how many image extensions do we want to do? If the extension
00551        number is zero, then we loop for all possible extensions. If it
00552        isn't then we just do the extension specified */
00553 
00554     vircam_exten_range(vircam_jmp_config.extenum,
00555                        (const cpl_frame *)cpl_frameset_get_frame(ps.science_frames,0),
00556                        &jst,&jfn);
00557     if (jst == -1 || jfn == -1) {
00558         cpl_msg_error(fctid,"Unable to continue");
00559         vircam_jmp_tidy(0);
00560         return(-1);
00561     }
00562 
00563     /* Now loop for all the extensions... */
00564 
00565     status = VIR_OK;
00566     for (j = jst; j <= jfn; j++) {
00567         isfirst = (j == jst);
00568         gaincor_fac = (ps.gaincors)[j-1];
00569 
00570         /* Load up the calibration frames into vir_fits/vir_tfits structures 
00571            It is a fatal error if any one of them can't load properly */
00572         
00573         ps.fdark = vircam_fits_load(ps.master_dark,CPL_TYPE_FLOAT,j);
00574         if (ps.fdark == NULL) {
00575             cpl_msg_error(fctid,"Error loading master dark %s[%d]\n%s",
00576                           cpl_frame_get_filename(ps.master_dark),j,
00577                           cpl_error_get_message());
00578             vircam_jmp_tidy(0);
00579             return(-1);
00580         }
00581         ps.fflat = vircam_fits_load(ps.master_twilight_flat,CPL_TYPE_FLOAT,j);
00582         if (ps.fflat == NULL) {
00583             cpl_msg_error(fctid,"Error loading master flat %s[%d]\n%s",
00584                           cpl_frame_get_filename(ps.master_twilight_flat),j,
00585                           cpl_error_get_message());
00586             vircam_jmp_tidy(0);
00587             return(-1);
00588         }
00589         ps.fconf = vircam_fits_load(ps.master_conf,CPL_TYPE_INT,j);
00590         if (ps.fconf == NULL) {
00591             cpl_msg_error(fctid,"Error loading master conf %s[%d]\n%s",
00592                           cpl_frame_get_filename(ps.master_conf),j,
00593                           cpl_error_get_message());
00594             vircam_jmp_tidy(0);
00595             return(-1);
00596         }
00597         if (! isconf) 
00598             vircam_jmp_bpm2conf();
00599         if (vircam_mask_load(ps.mask,j,
00600                              cpl_image_get_size_x(vircam_fits_get_image(ps.fconf)),
00601                              cpl_image_get_size_y(vircam_fits_get_image(ps.fconf))) != VIR_OK) {
00602             cpl_msg_error(fctid,"Error loading mask from master conf %s[%d]\n%s",
00603                           cpl_frame_get_filename(ps.master_conf),j,
00604                           cpl_error_get_message());
00605             vircam_jmp_tidy(0);
00606             return(-1);
00607         }
00608         ps.fchantab = vircam_tfits_load(ps.chantab,j);
00609         if (ps.fchantab == NULL) {
00610             cpl_msg_error(fctid,"Error loading channel table %s[%d]\n%s",
00611                           cpl_frame_get_filename(ps.chantab),j,
00612                           cpl_error_get_message());
00613             vircam_jmp_tidy(0);
00614             return(-1);
00615         }
00616 
00617         /* Load up the vir_fits structures for the science images */
00618 
00619         ps.nscience = cpl_frameset_get_size(ps.science_frames);
00620         ps.sci_fits = vircam_fits_load_list(ps.science_frames,CPL_TYPE_FLOAT,j);
00621         if (ps.sci_fits == NULL) {
00622             cpl_msg_error(fctid,"Error loading science frames extension %d: %s",
00623                           j,cpl_error_get_message());
00624             vircam_jmp_tidy(0);
00625             return(-1);
00626         }
00627 
00628         /* Loop through and mark the frames where the header says the detector
00629            wasn't live */
00630 
00631         for (i = 0; i < ps.nscience; i++) {
00632             ff = ps.sci_fits[i];
00633             vircam_pfits_get_detlive(vircam_fits_get_ehu(ff),&live);
00634             if (! live) 
00635                 vircam_fits_set_error(ff,VIR_FATAL);
00636         }
00637 
00638         /* Loop for all the science frames and do the 2d corrections */
00639 
00640         cpl_msg_info(fctid,"Doing stage1 corrections on %s",
00641                      vircam_fits_get_extname(ps.sci_fits[0]));
00642         for (i = 0; i < ps.nscience; i++) {
00643             ff = ps.sci_fits[i];
00644             if (vircam_fits_get_status(ff) == VIR_FATAL) {
00645                 cpl_msg_info(fctid,"Detector is flagged dead in %s",
00646                              vircam_fits_get_fullname(ff));
00647                 continue;
00648             }
00649             status = VIR_OK;
00650             (void)vircam_darkcor(ff,ps.fdark,1.0,&status);
00651             (void)vircam_lincor(ff,ps.fchantab,1,ndit,&status);
00652             (void)vircam_flatcor(ff,ps.fflat,&status);
00653             (void)vircam_gaincor(ff,gaincor_fac,&status);
00654             if (vircam_jmp_config.destripe) 
00655                 (void)vircam_destripe(ff,ps.mask,&status);
00656             vircam_fits_set_error(ff,status);
00657         }
00658 
00659         /* Do a simple sky correction if requested */
00660 
00661         if (vircam_jmp_config.skycor) {
00662             cpl_msg_info(fctid,"Doing sky correction");
00663             vircam_jmp_skycor();
00664         }
00665 
00666         /* Calculate the illumination correction */
00667 
00668         cpl_msg_info(fctid,"Doing illumination correction");
00669         (void)strcpy(current_cat,ps.catname);
00670         (void)strcpy(current_catpath,ps.catpath);
00671         vircam_jmp_illum();     
00672 
00673         /* Get the data from the illumination correction table */
00674 
00675         if (ps.illcor != NULL) {
00676             ic = vircam_tfits_get_table(ps.illcor);
00677             nrows = cpl_table_get_nrow(ic);
00678             xx1 = cpl_table_get_data_float(ic,"xmin");
00679             xx2 = cpl_table_get_data_float(ic,"xmax");
00680             yy1 = cpl_table_get_data_float(ic,"ymin");
00681             yy2 = cpl_table_get_data_float(ic,"ymax");
00682             ill = cpl_table_get_data_float(ic,"illcor");
00683             n = 0;
00684             for (i = 0; i < nrows; i++) 
00685                 if (ill[i] != -99.0)
00686                     n++;
00687 
00688             /* If there is nothing to fit, then don't bother with the rest
00689                of this */
00690 
00691             if (n == 0) {
00692                 cpl_msg_warning(fctid,"Illum correction table is all NULLs");
00693 
00694             } else {
00695                 
00696                 /* Create bivector and vector objects with the xy positions 
00697                    and the illumination correction */
00698 
00699                 bv = cpl_bivector_new(n);
00700                 bv_x = cpl_bivector_get_x_data(bv);
00701                 bv_y = cpl_bivector_get_y_data(bv);
00702                 v = cpl_vector_new(n);
00703                 vdata = cpl_vector_get_data(v);
00704                 n = 0;
00705                 for (i = 0; i < nrows; i++) {
00706                     if (ill[i] == -99.0)
00707                         continue;
00708                     bv_x[n] = 0.5*(double)(xx2[i] + xx1[i]);
00709                     bv_y[n] = 0.5*(double)(yy2[i] + yy1[i]);
00710                     vdata[n++] = (double)ill[i];
00711                 }
00712 
00713                 /* Now fit a surface to these results */
00714 
00715                 poly = cpl_polynomial_fit_2d_create(bv,v,vircam_jmp_config.nord,
00716                                                     NULL);
00717                 cpl_vector_delete(v);
00718                 if (cpl_error_get_code() != 0) {
00719                     cpl_error_reset();
00720                 } else {
00721 
00722                     /* Evaluate the polynomial at the input points and replace 
00723                        the values in the illumination correction with the new 
00724                        value. */
00725 
00726                     v = cpl_vector_new(2);
00727                     vdata = cpl_vector_get_data(v);
00728                     for (i = 0; i < nrows; i++) {
00729                         vdata[0] = 0.5*(double)(xx2[i] + xx1[i]);
00730                         vdata[1] = 0.5*(double)(yy2[i] + yy1[i]);
00731                         val = cpl_polynomial_eval(poly,v);
00732                         ill[i] = val;
00733                     }
00734                     cpl_vector_delete(v);
00735                 }
00736                 cpl_bivector_delete(bv);
00737                 cpl_polynomial_delete(poly);
00738             }
00739         }
00740 
00741         /* Save the table */
00742 
00743         cpl_msg_info(fctid,"Saving illumination correction table");
00744         dummyqc = vircam_mesostep_analyse_dummyqc(3);
00745         vircam_jmp_save_illum(framelist,parlist);
00746         freepropertylist(dummyqc);
00747         
00748         /* Clean up on aisle 12! */
00749 
00750         vircam_jmp_tidy(1);
00751     }
00752 
00753     /* Final cleanup */
00754 
00755     vircam_jmp_tidy(0);
00756     return(0);
00757 }
00758 
00759 static cpl_propertylist *vircam_mesostep_analyse_dummyqc(int type) {
00760     cpl_propertylist *p;
00761 
00762     /* Get an empty property list */
00763 
00764     p = cpl_propertylist_new();
00765 
00766     /* Now switch for the various products */
00767 
00768     switch (type) {
00769 
00770     /* Illumination tables */
00771 
00772     case 3:
00773         cpl_propertylist_update_float(p,"ESO QC ILLUMCOR_RMS",0.0);
00774         cpl_propertylist_set_comment(p,"ESO QC ILLUMCOR_RMS",
00775                                      "RMS of illumination correction map");
00776         break;
00777     default:
00778         break;
00779     }
00780 
00781     /* Get out of here */
00782 
00783     return(p);
00784 } 
00785 
00788 /*
00789 
00790 $Log: vircam_mesostep_analyse.c,v $
00791 Revision 1.22  2010/06/30 12:42:00  jim
00792 A few fixes to stop compiler compaints
00793 
00794 Revision 1.21  2009/07/03 12:30:04  jim
00795 Default value of rcore is now 3
00796 
00797 Revision 1.20  2008/12/09 11:35:51  jim
00798 Fixed bug in illumination correction routine which didn't deal properly with
00799 the situation where the fit failed
00800 
00801 Revision 1.19  2008/10/01 04:59:13  jim
00802 Added call to vircam_frameset_fexists to check input frameset
00803 
00804 Revision 1.18  2008/05/06 12:15:20  jim
00805 Changed to use new version of vircam_catpars
00806 
00807 Revision 1.17  2007/11/26 09:59:06  jim
00808 Recipe now takes ndit into account when doing linearity correction
00809 
00810 Revision 1.16  2007/10/25 18:39:22  jim
00811 Altered to remove some lint messages
00812 
00813 Revision 1.15  2007/10/19 06:55:06  jim
00814 Modifications made to use new method for directing the recipes to the
00815 standard catalogues using the sof
00816 
00817 Revision 1.14  2007/07/09 13:21:56  jim
00818 Modified to use new version of vircam_exten_range
00819 
00820 Revision 1.13  2007/06/13 08:11:27  jim
00821 Modified docs to reflect changes in DFS tags
00822 
00823 Revision 1.12  2007/05/08 21:31:16  jim
00824 fixed typo
00825 
00826 Revision 1.11  2007/05/08 10:42:44  jim
00827 Added gain correction
00828 
00829 Revision 1.10  2007/05/02 12:53:11  jim
00830 typo fixes in docs
00831 
00832 Revision 1.9  2007/04/04 16:05:59  jim
00833 Modified to make paf information a bit more correct
00834 
00835 Revision 1.8  2007/04/04 10:36:18  jim
00836 Modified to use new dfs tags
00837 
00838 Revision 1.7  2007/03/29 12:19:38  jim
00839 Little changes to improve documentation
00840 
00841 Revision 1.6  2007/03/14 14:49:13  jim
00842 Fixed problem with missing paf files in jmp recipes if detlive = F. Also
00843 fixed problem where extra dummy products were being created
00844 
00845 Revision 1.5  2007/02/07 10:12:40  jim
00846 Removed calls to vircam_ndit_correct as this is now no longer necessary
00847 
00848 Revision 1.4  2006/12/19 13:33:02  jim
00849 Blocked off bivariate fit so that in the event that the original illumnation
00850 correction fails, it doesn't then try to fit the surface.
00851 
00852 Revision 1.3  2006/12/18 16:43:15  jim
00853 fixed bug with nord parameter doc
00854 
00855 Revision 1.2  2006/12/18 16:42:27  jim
00856 Blocked off the fitting bit so that it doesn't get done if the initial
00857 illumination correction fails.
00858 
00859 Revision 1.1  2006/12/04 21:10:14  jim
00860 Initial entry
00861 
00862 
00863 */

Generated on 7 Feb 2011 for VIRCAM Pipeline by  doxygen 1.6.1