dark.c

00001 /*----------------------------------------------------------------------------
00002    
00003    File name    :       dark.c
00004    Author       :   A. Modigliani
00005    Created on   :   Sep 17, 2003
00006    Description  :   Master dark creation 
00007 
00008  ---------------------------------------------------------------------------*/
00009 
00010 /*----------------------------------------------------------------------------
00011                                 Includes
00012  ---------------------------------------------------------------------------*/
00013 #include "dark.h"
00014 #include "sinfoni_pro_save.h"
00015 #include "dark_ini_by_cpl.h"
00016 #include "sinfoni_dfs.h"
00017 
00018 /*----------------------------------------------------------------------------
00019                                 Defines
00020  ---------------------------------------------------------------------------*/
00021 int sinfoni_dark_ron_reduce(cpl_frameset * framelist,
00022                             dark_config* cfg,
00023                             cpl_table* qclog);
00024 
00025 int sinfoni_dark_fpn_reduce(cpl_frameset * framelist,
00026                             dark_config* cfg,
00027                             cpl_table* qclog);
00028 
00029 int sinfoni_dark_ron_reduce2(cpl_frameset * framelist,
00030                             dark_config* cfg,
00031                             cpl_table* qclog);
00032 
00033 int sinfoni_dark_compare(cpl_frame   *   frame1,cpl_frame   *   frame2);
00034 int sinfoni_mdark_compare(cpl_frame   *   frame1,cpl_frame   *   frame2);
00035 
00036 int
00037 master_dark_qclog(cpl_frameset* raw, 
00038                    dark_config* cfg, OneImage** image_list, OneImage* image);
00039 
00040 
00041 
00042 
00043 /*----------------------------------------------------------------------------
00044                              Function Definitions
00045  ---------------------------------------------------------------------------*/
00046 
00047 /*----------------------------------------------------------------------------
00048    Function     :       dark()
00049    In           :       ini_file: file name of according .ini file
00050    Out          :       integer (0 if it worked, -1 if it doesn't) 
00051    Job          :       generates master dark frames out of a stack of dark 
00052                         frames.
00053                         1) Sorts frames according to integration time
00054                         2) Take the clean mean of a stack of frames with the 
00055                         same integration time
00056 
00057  ---------------------------------------------------------------------------*/
00058 
00059 int dark (const char* plugin_id, cpl_parameterlist* config, 
00060           cpl_frameset* sof, char* dark_name)
00061 {
00062     
00063   const char* _id = "dark";
00064     dark_config * cfg=NULL ;
00065     OneImage ** image_list=NULL ;
00066     OneImage ** object_list=NULL ;
00067 
00068     OneCube * cube=NULL ;
00069     OneImage * image=NULL ;
00070     OneImage * eclipse_image=NULL ;
00071 
00072     cpl_image* dark_img=NULL;
00073     cpl_image* dark_imgw=NULL;
00074 
00075     cpl_image* tmp_img=NULL;
00076 
00077     cpl_image* imgw=NULL;
00078     cpl_frame* first_frame=NULL;
00079     cpl_vector* qc_dark_median=NULL;
00080     cpl_frameset* raw=NULL;
00081     cpl_table* qclog_tbl=NULL;
00082     cpl_propertylist* rplist=NULL;
00083     cpl_frameset* f_one=NULL;
00084 
00085     char* tmp_name;
00086     char** name_list;
00087 
00088     int i = 0;
00089     int j = 0;
00090     int n = 0;
00091     int count = 0;
00092     int* n_times;
00093     float exp_time = 0.;    
00094     float* int_time;   
00095     float time_val = 0.; 
00096 
00097     char*   ref_file=NULL;
00098     int zone_def[4];
00099     double qc_ron_val=0;
00100     double qc_ron_err=0;
00101     double qc_darkmed_ave=0;
00102     double qc_darkmed_stdev=0;
00103     double fpn=0;
00104     int zone[4];
00105     char* key_value=NULL;
00106     int naxis1=0;
00107     int naxis2=0;
00108 
00109     int* selection=NULL;
00110     int nsets=0;
00111     /* 
00112        -----------------------------------------------------------------
00113        1) parse the file names and parameters to the dark_config data 
00114           structure cfg 
00115        -----------------------------------------------------------------
00116      */
00117     raw=cpl_frameset_new();
00118     cfg = parse_cpl_input_dark(config,sof,&raw);
00119 
00120     if(cpl_error_get_code() != CPL_ERROR_NONE) {
00121       cpl_msg_error(_id,"error parsing cpl input");
00122       cpl_msg_error(_id,(char* ) cpl_error_get_message());
00123       return -1;
00124     }
00125 
00126     if (cfg == NULL)
00127     {
00128         cpl_msg_error (_id, "could not parse cpl input!\n") ;
00129         cpl_frameset_delete(raw);
00130         return -1 ;
00131     }
00132 
00133 
00134     /* 
00135        -----------------------------------------------------------------
00136        2) GET FRAMES AND SORT ACCORDING TO EXPOSURE TIME 
00137        -----------------------------------------------------------------
00138      */
00139      
00140     /* 
00141        2.1) get the total integration time from the fits header and 
00142             store it in an array
00143      */
00144 
00145     /* 2.1.1) get a data cube to stack darks */
00146     cpl_msg_info(_id,"Build data cube");
00147     /* take a clean mean of the frames */
00148     image_list = (OneImage**) cpl_calloc (cfg -> nframes, sizeof(OneImage*)) ;
00149     int_time = (float*) cpl_calloc(cfg -> nframes, sizeof(float)) ;
00150 
00151 
00152     /* head_list = (fits_header**) cpl_calloc(cfg -> nframes, sizeof(fits_header*)); */
00153     name_list = (char**) cpl_calloc(MAX_NAME_SIZE,sizeof(char*));
00154     tmp_name = (char*) cpl_calloc(MAX_NAME_SIZE,sizeof(char));
00155 
00156     for ( i = 0 ; i < cfg->nframes ; i++ )
00157     {
00158         if (is_fits_file (cfg->inFrameList[i]) != 1) {
00159        cpl_msg_error(_id,"Input file %s is not FITS",cfg->inFrameList[i]);
00160            return -1;
00161         }
00162         image_list[i] = load_image(cfg->inFrameList[i]) ;
00163         exp_time = spiffi_get_exptime(cfg->inFrameList[i]);
00164         if ( exp_time == FLAG) {
00165        cpl_msg_error(_id,"could not get exposure time from fits header!\n");
00166            return -1;
00167     }
00168         array_set_value(int_time, exp_time, i);
00169         /* read the fits header to change the gain and noise parameter */
00170         /* head_list[i] = fits_read_header(cfg->inFrameList[i]); */
00171     }
00172 
00173 
00174     /*
00175        2.2) find the number of frames with the same integration time
00176      */
00177     cpl_msg_info(_id,"Find frames with same tint");
00178     n = 0;
00179     /*
00180     header_list = (fits_header**) cpl_calloc(cfg -> nframes, sizeof(fits_header*));
00181     header_list[0] = head_list[0];
00182     */
00183     n_times = (int*) cpl_calloc(cfg -> nframes, sizeof(int));
00184     cpl_msg_info(_id,"Sort frames with same tint");
00185 
00186     for ( i = 0 ; i < cfg->nframes-1 ; i++ )
00187     {
00188          if ( array_get_value(int_time, i+1) != 
00189              array_get_value(int_time, i)
00190         ) {
00191 
00192     n_times[n] = i+1;
00193         n = n+1;
00194         /* header_list[n] = head_list[n]; */
00195 
00196     }
00197     
00198     }
00199 
00200  
00201     /* 
00202        2.3) store the images with the same tint in data cubes and take 
00203             clean means
00204      */
00205     cpl_msg_info(_id,"Do clean mean");
00206     if ( n == 0 ) {
00207 
00208 
00209 
00210        cpl_msg_info(_id,"n == 0 ");
00211        time_val = array_get_value(int_time, 0);
00212 
00213 
00214 
00215        object_list = new_image_list(cfg->nframes);
00216 
00217 
00218        if ( object_list == NULL ) {
00219           cpl_msg_error(_id,"could not allocate memory for object_list\n");
00220        cpl_image_delete(dark_img);
00221        cpl_vector_delete(qc_dark_median);
00222        cpl_free(n_times);
00223        cpl_free(int_time);
00224        cpl_free(image_list);
00225        cpl_free(name_list);
00226        cpl_free(tmp_name);
00227        if(cfg) dark_free(cfg);
00228        cpl_frameset_delete(raw);
00229           return -1;
00230 
00231        }
00232        /* here we have a leak of 80 bytes */
00233 
00234 
00235 
00236        count = 0;
00237        /* do also QC log */
00238        qc_dark_median=cpl_vector_new(cfg->nframes);
00239 
00240        for ( j = 0 ; j < cfg->nframes ; j++ ) {
00241          imgw=cpl_image_wrap_float(image_list[j]->lx,
00242                                    image_list[j]->ly,
00243                                    image_list[j]->data);
00244          tmp_img=cpl_image_duplicate(imgw);
00245          cpl_image_unwrap(imgw);
00246      cpl_vector_set(qc_dark_median,j,cpl_image_get_median(tmp_img));
00247          insert_image(object_list, image_list[j], count);
00248          cpl_image_delete(tmp_img);
00249          count = count + 1;
00250        }
00251 
00252        qc_darkmed_ave=cpl_vector_get_mean(qc_dark_median);
00253        if (cfg->nframes > 1) qc_darkmed_stdev=cpl_vector_get_stdev(qc_dark_median);
00254        /* rms   = stdev * sqrt(1-1/(double)cpl_vector_get_size(myvector));  */
00255        /* qc_darkmed_stdev = qc_darkmed_stdev * sqrt(1-1/(double)cpl_vector_get_size(qc_dark_median)); */  
00256 
00257 
00258        cube = list_make_cube(object_list, count);
00259        image = average_with_rejection(cube, cfg->lo_reject, cfg->hi_reject);
00260        if ( image == NULL ) {
00261           cpl_msg_error(_id,"average_with_rejection failed\n");
00262           cpl_vector_delete(qc_dark_median);
00263           cpl_free(n_times);
00264           cpl_free(int_time);
00265           cpl_free(image_list);
00266           cpl_free(name_list);
00267           cpl_free(tmp_name);
00268           if(cfg) dark_free(cfg);
00269           cpl_frameset_delete(raw);
00270 
00271           return -1;
00272 
00273        }
00274        destroy_list(object_list);
00275        destroy_cube(cube);
00276 
00277 
00278 
00279         cpl_msg_info(_id,"dark_name=%s\n",dark_name);
00280        imgw=cpl_image_wrap_float(image->lx,image->ly,image->data);
00281        dark_img=cpl_image_duplicate(imgw);
00282        cpl_image_unwrap(imgw);
00283 
00284 
00285        /*
00286        master_dark_qclog(raw,cfg,image_list,image);
00287        */
00288        
00289        first_frame = cpl_frameset_get_frame(raw, 0) ;
00290    
00291        ref_file = cpl_strdup(cpl_frame_get_filename(first_frame)) ;
00292        (cpl_error_code)((rplist = cpl_propertylist_load(ref_file, 0)) == NULL);
00293        cpl_free(ref_file);
00294 
00295        naxis1=cpl_propertylist_get_int(rplist,"NAXIS1");
00296        naxis2=cpl_propertylist_get_int(rplist,"NAXIS1");
00297        cpl_propertylist_delete(rplist);
00298 
00299        if(cfg->qc_ron_xmin < 1) {
00300      cpl_msg_error(_id,"qc_ron_xmin %d < 1",cfg->qc_ron_xmin);
00301          cpl_image_delete(dark_img);
00302          cpl_vector_delete(qc_dark_median);
00303          cpl_free(n_times);
00304          cpl_free(int_time);
00305          cpl_free(image_list);
00306          cpl_free(name_list);
00307          cpl_free(tmp_name);
00308          if(cfg) dark_free(cfg);
00309          cpl_frameset_delete(raw);
00310          return -1;
00311        }
00312 
00313        if(cfg->qc_ron_xmax > naxis1) {
00314      cpl_msg_error(_id,"qc_ron_xmax %d > %d",cfg->qc_ron_xmax,naxis1);
00315          cpl_image_delete(dark_img);
00316          cpl_vector_delete(qc_dark_median);
00317          cpl_free(n_times);
00318          cpl_free(int_time);
00319          cpl_free(image_list);
00320          cpl_free(name_list);
00321          cpl_free(tmp_name);
00322          if(cfg) dark_free(cfg);
00323          cpl_frameset_delete(raw);
00324          return -1;
00325        }
00326 
00327        if(cfg->qc_ron_ymin < 1) {
00328      cpl_msg_error(_id,"qc_ron_ymin %d < 1",cfg->qc_ron_ymin);
00329          cpl_image_delete(dark_img);
00330          cpl_vector_delete(qc_dark_median);
00331          cpl_free(n_times);
00332          cpl_free(int_time);
00333          cpl_free(image_list);
00334          cpl_free(name_list);
00335          cpl_free(tmp_name);
00336          if(cfg) dark_free(cfg);
00337          cpl_frameset_delete(raw);
00338          return -1;
00339        }
00340 
00341        if(cfg->qc_ron_ymax > naxis2) {
00342      cpl_msg_error(_id,"qc_ron_ymax %d > %d",cfg->qc_ron_ymax,naxis2);
00343          cpl_image_delete(dark_img);
00344          cpl_vector_delete(qc_dark_median);
00345          cpl_free(n_times);
00346          cpl_free(int_time);
00347          cpl_free(image_list);
00348          cpl_free(name_list);
00349          cpl_free(tmp_name);
00350          if(cfg) dark_free(cfg);
00351          cpl_frameset_delete(raw);
00352          return -1;
00353        }
00354 
00355 
00356 
00357 
00358 
00359 
00360 
00361        zone_def[0]=cfg->qc_ron_xmin;
00362        zone_def[1]=cfg->qc_ron_xmax;
00363        zone_def[2]=cfg->qc_ron_ymin;
00364        zone_def[3]=cfg->qc_ron_ymax;
00365 
00366 
00367 
00368        if( CPL_ERROR_NONE != cpl_flux_get_noise_window(dark_img,
00369                                               zone_def,
00370                                               cfg->qc_ron_hsize,
00371                                               cfg->qc_ron_nsamp,
00372                                               &qc_ron_val,
00373                                               &qc_ron_err)) {
00374          cpl_msg_error(_id,"In computation RON on image %s",dark_name);
00375        }
00376 
00377 
00378 
00379        if(cfg->qc_fpn_xmin < 1) {
00380      cpl_msg_error(_id,"qc_fpn_xmin %d < 1",cfg->qc_fpn_xmin);
00381          cpl_image_delete(dark_img);
00382          cpl_vector_delete(qc_dark_median);
00383          cpl_free(n_times);
00384          cpl_free(int_time);
00385          cpl_free(image_list);
00386          cpl_free(name_list);
00387          cpl_free(tmp_name);
00388          if(cfg) dark_free(cfg);
00389          cpl_frameset_delete(raw);
00390          return -1;
00391        }
00392 
00393        if(cfg->qc_fpn_xmax > naxis1) {
00394      cpl_msg_error(_id,"qc_fpn_xmax %d > %d",cfg->qc_fpn_xmax,naxis1);
00395          cpl_image_delete(dark_img);
00396          cpl_vector_delete(qc_dark_median);
00397          cpl_free(n_times);
00398          cpl_free(int_time);
00399          cpl_free(image_list);
00400          cpl_free(name_list);
00401          cpl_free(tmp_name);
00402          if(cfg) dark_free(cfg);
00403          cpl_frameset_delete(raw);
00404          return -1;
00405        }
00406 
00407        if(cfg->qc_fpn_ymin < 1) {
00408      cpl_msg_error(_id,"qc_fpn_ymin %d < 1",cfg->qc_fpn_ymin);
00409          cpl_image_delete(dark_img);
00410          cpl_vector_delete(qc_dark_median);
00411          cpl_free(n_times);
00412          cpl_free(int_time);
00413          cpl_free(image_list);
00414          cpl_free(name_list);
00415          cpl_free(tmp_name);
00416          if(cfg) dark_free(cfg);
00417          cpl_frameset_delete(raw);
00418          return -1;
00419        }
00420 
00421        if(cfg->qc_fpn_ymax > naxis2) {
00422      cpl_msg_error(_id,"qc_fpn_ymax %d > %d",cfg->qc_fpn_ymax,naxis2);
00423          cpl_image_delete(dark_img);
00424          cpl_vector_delete(qc_dark_median);
00425          cpl_free(n_times);
00426          cpl_free(int_time);
00427          cpl_free(image_list);
00428          cpl_free(name_list);
00429          cpl_free(tmp_name);
00430          if(cfg) dark_free(cfg);
00431          cpl_frameset_delete(raw);
00432          return -1;
00433        }
00434 
00435        zone[0]=cfg->qc_fpn_xmin;
00436        zone[1]=cfg->qc_fpn_xmax;
00437        zone[2]=cfg->qc_fpn_ymin;
00438        zone[3]=cfg->qc_fpn_ymax;
00439        cpl_flux_get_noise_window(dark_img, zone, cfg->qc_fpn_hsize,
00440               cfg->qc_fpn_nsamp, &fpn, NULL); 
00441 
00442 
00443 
00444        /* QC LOG */
00445        
00446        qclog_tbl = sinfoni_qclog_init(5);
00447        key_value = cpl_calloc(FILE_NAME_SZ,sizeof(char));
00448        sprintf(key_value,"%f",qc_darkmed_ave);
00449        sinfoni_qclog_add(qclog_tbl,0,"QC DARKMED AVE","CPL_TYPE_DOUBLE",
00450                      key_value,"Average of raw darks medians");
00451 
00452        sprintf(key_value,"%f",qc_darkmed_stdev);
00453        sinfoni_qclog_add(qclog_tbl,1,"QC DARKMED STDEV","CPL_TYPE_DOUBLE",
00454                      key_value,"STDEV of raw darks medians");
00455 
00456        sprintf(key_value,"%f",qc_ron_val);
00457        sinfoni_qclog_add(qclog_tbl,2,"QC RON","CPL_TYPE_DOUBLE",
00458                      key_value,"Read Out Noise");
00459        
00460        sprintf(key_value,"%f",qc_ron_err);
00461        sinfoni_qclog_add(qclog_tbl,3,"QC RONRMS","CPL_TYPE_DOUBLE",
00462                      key_value,"RMS on Read Out Noise");
00463 
00464       
00465        sprintf(key_value,"%g",fpn);
00466        sinfoni_qclog_add(qclog_tbl,4,"QC DARKFPN","CPL_TYPE_DOUBLE",
00467                      key_value,"Fixed Pattern Noise of combined frames");
00468 
00469       
00470 
00471 
00472 
00473 
00474        /* special way to calculate RON: for each couple */
00475        
00476        selection = cpl_frameset_labelise(raw,sinfoni_dark_compare,&nsets);
00477        for ( i = 0 ; i < nsets ; i++ ) {
00478          cpl_msg_info(_id,"Reduce data set no %d out of %d", i+1, nsets);
00479          cpl_msg_indent_more();
00480      f_one = cpl_frameset_extract(raw,selection,i);
00481          if (cpl_frameset_get_size(f_one) < 2) {
00482            cpl_msg_warning(_id," Setting %d skipped (not enough frames)",i+1);
00483      } else {
00484            if (sinfoni_dark_ron_reduce(f_one,cfg,qclog_tbl) ) {
00485          cpl_msg_warning(_id, "Cannot reduce set number %d", i+1) ;
00486        }
00487      }
00488          cpl_frameset_delete(f_one);
00489          cpl_msg_indent_less();
00490 
00491        }
00492        cpl_free(selection);
00493 
00494 
00495        /* generate a dummy_set with the master dark and a dummy dark=2*master_dark */
00496 
00497       if(-1 == sinfoni_pro_save_ima(dark_img,raw,sof,dark_name,
00498            PRO_MASTER_DARK,qclog_tbl,plugin_id,config)) {
00499           cpl_msg_error(_id,"cannot save ima %s", dark_name);
00500           cpl_table_delete(qclog_tbl);
00501           destroy_image(image);
00502           cpl_free(key_value);
00503           cpl_image_delete(dark_img);
00504           cpl_vector_delete(qc_dark_median);
00505           cpl_free(n_times);
00506           cpl_free(int_time);
00507           cpl_free(image_list);
00508           cpl_free(name_list);
00509           cpl_free(tmp_name);
00510           if(cfg) dark_free(cfg);
00511           cpl_frameset_delete(raw);
00512           return -1;
00513        }
00514        cpl_table_delete(qclog_tbl);
00515        destroy_image(image);
00516        cpl_free(key_value);
00517 
00518 
00519 
00520 
00521  
00522 
00523     } else if (n == 1) {
00524 
00525        cpl_msg_info(_id,"n == 1");
00526        time_val = array_get_value(int_time, 0);
00527        object_list = new_image_list(n_times[0]); 
00528        if (object_list == NULL) {
00529           cpl_msg_error(_id,"could not allocate memory\n");
00530           return -1;
00531        }
00532 
00533        count = 0;
00534 
00535        for (j =0; j < n_times[0]; j++) {
00536           insert_image(object_list, image_list[j], count);
00537           count = count + 1;
00538        }
00539 
00540        cube = list_make_cube(object_list, count); 
00541        image = average_with_rejection(cube, cfg->lo_reject, cfg->hi_reject);
00542 
00543        if (image == NULL) {
00544           cpl_msg_error(_id,"average_with_rejection failed!\n");
00545           return -1;
00546        }
00547        destroy_list(object_list);
00548        destroy_cube(cube);
00549 
00550 
00551        dark_imgw=cpl_image_wrap_float(image->lx,image->ly,image->data);
00552        dark_img=cpl_image_duplicate(dark_imgw);
00553        cpl_image_unwrap(dark_imgw);
00554 
00555        qclog_tbl = sinfoni_qclog_init(1);
00556        key_value = cpl_calloc(FILE_NAME_SZ,sizeof(char));
00557        sprintf(key_value,"%d",1);
00558        sinfoni_qclog_add(qclog_tbl,0,"QC NAME","CPL_TYPE_DOUBLE",key_value,"A description");
00559 
00560        if(-1 == sinfoni_pro_save_ima(dark_img,raw,sof,dark_name,
00561            PRO_MASTER_DARK,qclog_tbl,plugin_id,config)) {
00562            cpl_msg_error(_id,"cannot save ima %s", dark_name);
00563 
00564           cpl_table_delete(qclog_tbl);
00565           destroy_image(image);
00566           cpl_free(key_value);
00567 
00568           /* if(head_list) free(head_list); */
00569           /* if(header_list) free(header_list); */
00570           if(int_time) cpl_free(int_time);
00571           if(image_list) cpl_free(image_list);
00572           if(n_times)   cpl_free(n_times);
00573           if(name_list) cpl_free(name_list);
00574           if(tmp_name)  cpl_free(tmp_name);
00575            if(cfg) dark_free(cfg);
00576 
00577 
00578            return -1;
00579 
00580        }
00581        destroy_image(image);
00582        cpl_free(key_value);
00583        cpl_table_delete(qclog_tbl);
00584 
00585        time_val = array_get_value(int_time, n_times[0]);
00586        object_list = new_image_list(cfg->nframes-n_times[0]); 
00587        if (object_list == NULL ) {
00588           cpl_msg_error(_id,"could not allocate memory\n");
00589           return -1;
00590        }
00591        count = 0;
00592 
00593 
00594        for (j = n_times[0]; j < cfg->nframes; j++) {
00595          insert_image(object_list, image_list[j], count);
00596          count = count + 1;
00597        }
00598        cube = list_make_cube(object_list, count); 
00599        eclipse_image = average_with_rejection(cube, cfg->lo_reject, cfg->hi_reject);
00600        if (image == NULL ) {
00601           cpl_msg_error(_id,"average_with_rejection failed!\n");
00602           return -1;
00603        }
00604        destroy_list(object_list);
00605        destroy_cube(cube);
00606 
00607 
00608        dark_imgw=cpl_image_wrap_float(eclipse_image->lx,eclipse_image->ly,eclipse_image->data);
00609        dark_img=cpl_image_duplicate(dark_imgw);
00610        cpl_image_unwrap(dark_imgw);
00611 
00612        qclog_tbl = sinfoni_qclog_init(1);
00613        key_value = cpl_calloc(FILE_NAME_SZ,sizeof(char));
00614        sprintf(key_value,"%d",1);
00615        sinfoni_qclog_add(qclog_tbl,0,"QC NAME","CPL_TYPE_DOUBLE",key_value,"A description");
00616 
00617 
00618 
00619        if(-1 == sinfoni_pro_save_ima(dark_img,raw,sof,dark_name,
00620            PRO_MASTER_DARK,qclog_tbl,plugin_id,config)) {
00621            cpl_msg_error(_id,"cannot save ima %s", dark_name);
00622 
00623           cpl_table_delete(qclog_tbl);
00624           destroy_image(eclipse_image);
00625           cpl_free(key_value);
00626 
00627           /* if(head_list) cpl_free(head_list); */
00628           /* if(header_list) cpl_free(header_list); */
00629           if(int_time) cpl_free(int_time);
00630           if(image_list) cpl_free(image_list);
00631           if(n_times)   cpl_free(n_times);
00632           if(name_list) cpl_free(name_list);
00633           if(tmp_name)  cpl_free(tmp_name);
00634            if(cfg) dark_free(cfg);
00635 
00636 
00637            return -1;
00638        }
00639        destroy_image(eclipse_image);
00640        cpl_free(key_value);
00641        cpl_table_delete(qclog_tbl);
00642 
00643     } else {
00644 
00645        cpl_msg_info(_id,"n==else\n");
00646 
00647        for (i= 0; i < n+1; i++) {
00648          if ( i == 0 ) {
00649         time_val = array_get_value(int_time, 0);
00650         object_list = new_image_list(n_times[0]); 
00651         if ( object_list == NULL ) {
00652            cpl_msg_error(_id,"could not allocate memory\n");
00653                return -1;
00654         }
00655             count = 0;
00656             for (j = 0; j < n_times[0]; j++) {
00657            insert_image(object_list, image_list[j], count);
00658            count = count + 1;
00659         }
00660             cube = list_make_cube(object_list, count); 
00661             image = average_with_rejection(cube, 
00662                                        cfg->lo_reject, 
00663                                        cfg->hi_reject);
00664             if (image == NULL) {
00665                cpl_msg_error(_id,"er2 average_with_rejection failed!\n");
00666                return -1;
00667         }
00668             destroy_list(object_list);
00669             destroy_cube(cube);
00670 
00671             cpl_msg_info(_id,"dark_name-%s\n",dark_name);
00672             dark_imgw=cpl_image_wrap_float(image->lx,image->ly,image->data);
00673             dark_img=cpl_image_duplicate(dark_imgw);
00674             cpl_image_unwrap(dark_imgw);
00675 
00676             qclog_tbl = sinfoni_qclog_init(1);
00677             key_value = cpl_calloc(FILE_NAME_SZ,sizeof(char));
00678             sprintf(key_value,"%d",1);
00679             sinfoni_qclog_add(qclog_tbl,0,"QC NAME","CPL_TYPE_DOUBLE",key_value,"A description");
00680 
00681 
00682             if(-1 == sinfoni_pro_save_ima(dark_img,raw,sof,dark_name,
00683               PRO_MASTER_DARK,qclog_tbl,plugin_id,config)) {
00684               cpl_msg_error(_id,"cannot save ima %s", dark_name);
00685 
00686               cpl_table_delete(qclog_tbl);
00687               destroy_image(image);
00688               cpl_free(key_value);
00689 
00690               /* if(head_list) cpl_free(head_list); */
00691               /* if(header_list) cpl_free(header_list); */
00692               if(int_time) cpl_free(int_time);
00693               if(image_list) cpl_free(image_list);
00694               if(n_times)   cpl_free(n_times);
00695               if(name_list) cpl_free(name_list);
00696               if(tmp_name)  cpl_free(tmp_name);
00697               if(cfg) dark_free(cfg);
00698 
00699               return -1;
00700         }
00701             cpl_free(key_value);
00702             cpl_table_delete(qclog_tbl);
00703             destroy_image(image);
00704      } else if ( i == n ) {
00705             time_val = array_get_value(int_time, n_times[n-1]);
00706             object_list = new_image_list(cfg->nframes - n_times[n-1]); 
00707             if (object_list == NULL) {
00708            cpl_msg_error(_id,"could not allocate memory\n");
00709            return -1;
00710         }
00711             count = 0;
00712             for (j = n_times[n-1]; j < cfg->nframes; j++) {
00713            insert_image(object_list, image_list[j], count);
00714            count = count + 1;
00715         }
00716             cube = list_make_cube(object_list, count); 
00717             image = average_with_rejection(cube, 
00718                                            cfg->lo_reject, 
00719                                            cfg->hi_reject);
00720 
00721             if (image == NULL) {
00722            cpl_msg_error(_id,"er3 average_with_rejection failed!\n");
00723            return -1;
00724         }
00725             destroy_list(object_list);
00726             destroy_cube(cube);
00727 
00728 
00729             dark_imgw=cpl_image_wrap_float(image->lx,image->ly,image->data);
00730             dark_img=cpl_image_duplicate(dark_imgw);
00731             cpl_image_unwrap(dark_imgw);
00732 
00733             qclog_tbl = sinfoni_qclog_init(1);
00734             key_value = cpl_calloc(FILE_NAME_SZ,sizeof(char));
00735             sprintf(key_value,"%d",1);
00736             sinfoni_qclog_add(qclog_tbl,0,"QC NAME","CPL_TYPE_DOUBLE",key_value,"A description");
00737 
00738             if(-1 == sinfoni_pro_save_ima(dark_img,raw,sof,dark_name,
00739                  PRO_MASTER_DARK,qclog_tbl,plugin_id,config)) {
00740                  cpl_msg_error(_id,"cannot save ima %s", dark_name);
00741 
00742 
00743               cpl_table_delete(qclog_tbl);
00744               destroy_image(image);
00745               cpl_free(key_value);
00746 
00747               /* if(head_list) cpl_free(head_list); */
00748               /* if(header_list) cpl_free(header_list); */
00749               if(int_time) cpl_free(int_time);
00750               if(image_list) cpl_free(image_list);
00751               if(n_times)   cpl_free(n_times);
00752               if(name_list) cpl_free(name_list);
00753               if(tmp_name)  cpl_free(tmp_name);
00754               if(cfg) dark_free(cfg);
00755 
00756                  return -1;
00757         }
00758             cpl_free(key_value);
00759             cpl_table_delete(qclog_tbl);
00760 
00761             destroy_image(image);
00762     } else {
00763         time_val = array_get_value(int_time, n_times[i-1]);
00764         object_list = new_image_list(n_times[i] - n_times[i-1]); 
00765             if ( object_list == NULL ) {
00766                 cpl_msg_error(_id,"could not allocate memory\n");
00767                 return -1;
00768         }
00769             count = 0;
00770             for (j = n_times[i-1]; j < n_times[i]; j++) {
00771             insert_image(object_list, image_list[j], count);
00772                 count = count + 1;
00773         }
00774             cube = list_make_cube(object_list, count); 
00775             image = average_with_rejection(cube, 
00776                                            cfg->lo_reject, 
00777                                            cfg->hi_reject);
00778 
00779             if ( image == NULL ) {
00780            cpl_msg_error(_id,"average_with_rejection failed!\n");
00781            return -1;
00782         }
00783             destroy_list(object_list);
00784             destroy_cube(cube);
00785 
00786 
00787 
00788             dark_imgw=cpl_image_wrap_float(image->lx,image->ly,image->data);
00789             dark_img=cpl_image_duplicate(dark_imgw);
00790             cpl_image_unwrap(dark_imgw);
00791 
00792             qclog_tbl = sinfoni_qclog_init(1);
00793             key_value = cpl_calloc(FILE_NAME_SZ,sizeof(char));
00794             sprintf(key_value,"%d",1);
00795             sinfoni_qclog_add(qclog_tbl,0,"QC NAME","CPL_TYPE_DOUBLE",key_value,"A description");
00796 
00797             if(-1 == sinfoni_pro_save_ima(dark_img,raw,sof,dark_name,
00798                 PRO_MASTER_DARK,qclog_tbl,plugin_id,config)) {
00799                 cpl_msg_error(_id,"cannot save ima %s", dark_name);
00800 
00801                 destroy_image(image);
00802             cpl_free(key_value);
00803                 cpl_table_delete(qclog_tbl);
00804         /*
00805                 for (i = 0; i< cfg->nframes; i++) {
00806                     if(head_list[i]) fits_header_destroy(head_list[i]);
00807                 }
00808         */
00809 
00810                 /* if(head_list) cpl_free(head_list); */
00811                 /* if(header_list) cpl_free(header_list); */
00812                 if(int_time) cpl_free(int_time);
00813                 if(image_list) cpl_free(image_list);
00814                 if(n_times)   cpl_free(n_times);
00815                 if(name_list) cpl_free(name_list);
00816                 if(tmp_name)  cpl_free(tmp_name);
00817                 if(cfg) dark_free(cfg);
00818 
00819 
00820                 return -1;
00821         }
00822             destroy_image(image);
00823         cpl_free(key_value);
00824             cpl_table_delete(qclog_tbl);
00825     }
00826        
00827        } /* end for loop */
00828     } /* end else over n */
00829 
00830 
00831 
00832        cpl_image_delete(dark_img);
00833        cpl_vector_delete(qc_dark_median);
00834        cpl_free(n_times);
00835        cpl_free(int_time);
00836        cpl_free(image_list);
00837        cpl_free(name_list);
00838        cpl_free(tmp_name);
00839        if(cfg) dark_free(cfg);
00840        cpl_frameset_delete(raw);
00841        return 0;
00842 }
00843 
00844 
00845 
00846 
00847 
00848 
00849 /*--------------------------------------------------------------------*/
00856 /*--------------------------------------------------------------------*/
00857  int sinfoni_dark_ron_reduce(cpl_frameset    *   framelist,
00858                  dark_config     *   cfg,
00859                  cpl_table       *   qclog_tbl)
00860         {
00861             const char      *   fctid = "sinfoni_dark_ron_reduce" ;
00862             cpl_imagelist   *   iset =NULL;
00863             int                 i =0;
00864             double* ron=NULL;
00865         int nraw=0;
00866             int niset=0;
00867             char key_name[FILE_NAME_SZ];
00868             char key_value[FILE_NAME_SZ];
00869             /* Test entries */
00870 
00871             if (framelist == NULL) return -1 ;
00872 
00873           /* Load the current set */
00874             if ((iset = sinfoni_frameset_to_iset(framelist)) == NULL) {
00875                 cpl_msg_error(fctid, "Cannot load the data") ;
00876                 return -1 ;
00877             }
00878             /* Loop on all pairs */
00879             nraw = cpl_table_get_nrow(qclog_tbl);
00880             niset=cpl_imagelist_get_size(iset);
00881             cpl_table_set_size(qclog_tbl,nraw+niset-1);
00882         ron = cpl_calloc(niset,sizeof(double));
00883             sinfoni_get_ron(framelist,
00884                             cfg->qc_ron_xmin,cfg->qc_ron_xmax,
00885                             cfg->qc_ron_ymin,cfg->qc_ron_ymax,
00886                             cfg->qc_ron_hsize,cfg->qc_ron_nsamp,
00887                             &ron);
00888 
00889             for (i=0 ; i<niset-1 ; i++) {
00890 
00891                 /* Write the paf file on disk */
00892                 /* Write QC LOG */
00893 
00894                 sprintf(key_name,"%s%d","QC RON",i+1);
00895                 cpl_table_set_string(qclog_tbl,"key_name",nraw+i,key_name);
00896                 cpl_table_set_string(qclog_tbl,"key_type",nraw+i,"CPL_TYPE_DOUBLE");
00897 
00898                 sprintf(key_value,"%f",ron[i]);
00899                 cpl_table_set_string(qclog_tbl,"key_value",nraw+i,key_value);
00900                 cpl_table_set_string(qclog_tbl,"key_help",nraw+i,"Read Out Noise");
00901 
00902             }
00903         cpl_free(ron);
00904             cpl_imagelist_delete(iset) ;
00905 
00906             return 0 ;
00907         }
00908 
00909 
00910 /*--------------------------------------------------------------------*/
00917 /*--------------------------------------------------------------------*/
00918  int sinfoni_dark_fpn_reduce(cpl_frameset    *   framelist,
00919                  dark_config     *   cfg,
00920                  cpl_table       *   qclog_tbl)
00921         {
00922             const char      *   fctid = "sinfoni_dark_fpn_reduce" ;
00923             cpl_imagelist   *   iset =NULL;
00924             int                 i =0;
00925             double* fpn=NULL;
00926         int nraw=0;
00927             int niset=0;
00928             char key_name[FILE_NAME_SZ];
00929             char key_value[FILE_NAME_SZ];
00930             /* Test entries */
00931 
00932             if (framelist == NULL) return -1 ;
00933 
00934           /* Load the current set */
00935             if ((iset = sinfoni_frameset_to_iset(framelist)) == NULL) {
00936                 cpl_msg_error(fctid, "Cannot load the data") ;
00937                 return -1 ;
00938             }
00939             /* Loop on all pairs */
00940             nraw = cpl_table_get_nrow(qclog_tbl);
00941             niset=cpl_imagelist_get_size(iset);
00942             cpl_table_set_size(qclog_tbl,nraw+niset-1);
00943         fpn = cpl_calloc(niset,sizeof(double));
00944             sinfoni_get_ron(framelist,
00945                             cfg->qc_fpn_xmin,cfg->qc_fpn_xmax,
00946                             cfg->qc_fpn_ymin,cfg->qc_fpn_ymax,
00947                             cfg->qc_fpn_hsize,cfg->qc_fpn_nsamp,
00948                             &fpn);
00949             printf("niset=%d\n",niset);
00950             for (i=0 ; i<niset-1 ; i++) {
00951 
00952                 /* Write the paf file on disk */
00953                 /* Write QC LOG */
00954 
00955                 sprintf(key_name,"%s%d","QC FPN",i+1);
00956                 cpl_table_set_string(qclog_tbl,"key_name",nraw+i,key_name);
00957                 cpl_table_set_string(qclog_tbl,"key_type",nraw+i,"CPL_TYPE_DOUBLE");
00958 
00959                 sprintf(key_value,"%f",fpn[i]);
00960                 cpl_table_set_string(qclog_tbl,"key_value",nraw+i,key_value);
00961                 cpl_table_set_string(qclog_tbl,"key_help",nraw+i,"Read Out Noise");
00962 
00963             }
00964         cpl_free(fpn);
00965             cpl_imagelist_delete(iset) ;
00966 
00967             return 0 ;
00968         }
00969 
00970 
00971 
00972 
00973 /*--------------------------------------------------------------------*/
00980 /*--------------------------------------------------------------------*/
00981  int sinfoni_dark_ron_reduce2(cpl_frameset    *   framelist,
00982                  dark_config     *   cfg,
00983                  cpl_table       *   qclog_tbl)
00984         {
00985             const char      *   fctid = "sinfoni_dark_ron_reduce" ;
00986             cpl_imagelist   *   iset =NULL;
00987             cpl_image       *   tmp_im =NULL;
00988             int                 zone[4] ;
00989             double              rms  =0;
00990             char            *   sval =NULL;
00991             double              ndit =0;
00992             cpl_frame       *   cur_frame =NULL;
00993             int                 i =0;
00994             double ron=0;
00995         int nraw=0;
00996             char key_name[FILE_NAME_SZ];
00997             char key_value[FILE_NAME_SZ];
00998             /* Test entries */
00999 
01000             if (framelist == NULL) return -1 ;
01001 
01002             /* Load the current set */
01003             if ((iset = sinfoni_frameset_to_iset(framelist)) == NULL) {
01004                 cpl_msg_error(fctid, "Cannot load the data") ;
01005                 return -1 ;
01006             }
01007 
01008             /* Initialise */
01009            zone[0]=cfg->qc_ron_xmin;
01010            zone[1]=cfg->qc_ron_xmax;
01011            zone[2]=cfg->qc_ron_ymin;
01012            zone[3]=cfg->qc_ron_ymax;
01013 
01014             /* Loop on all pairs */
01015             nraw = cpl_table_get_nrow(qclog_tbl);
01016             cpl_table_set_size(qclog_tbl,nraw+cpl_imagelist_get_size(iset)-1);
01017             for (i=0 ; i<cpl_imagelist_get_size(iset)-1 ; i++) {
01018 
01019                 /* Compute the current subtracted image */
01020                 if ((tmp_im = cpl_image_subtract_create(cpl_imagelist_get(iset, i),
01021                                 cpl_imagelist_get(iset, i+1))) == NULL) {
01022                     cpl_msg_error(fctid, "Cannot subtract the images") ;
01023                     cpl_imagelist_delete(iset) ;
01024                     return -1 ;
01025                 }
01026 
01027                 /* Compute the read-out noise */
01028                 if (cpl_flux_get_noise_window(tmp_im, zone, cfg->qc_ron_hsize,
01029                     cfg->qc_ron_nsamp, &rms, NULL) != CPL_ERROR_NONE) {
01030                     cpl_msg_error(fctid, "Cannot compute the RON") ;
01031                     cpl_image_delete(tmp_im) ;
01032                     cpl_imagelist_delete(iset) ;
01033                     return -1 ;
01034                 }
01035                 cpl_image_delete(tmp_im) ;
01036                /* Normalise the RON with NDIT */
01037                 cur_frame = cpl_frameset_get_frame(framelist, i) ;
01038                 if ((sval = sinfoni_pfits_get_ndit(
01039                                 (char*)cpl_frame_get_filename(cur_frame))) == NULL) {
01040                     cpl_msg_error(fctid, "Cannot get NDIT") ;
01041                     cpl_imagelist_delete(iset) ;
01042                     return -1 ;
01043                 }
01044                 ndit = (double)atof(sval) ;
01045                 ron = rms * sqrt(ndit/2.0) ;
01046 
01047 
01048                 /* Write the paf file on disk */
01049                 /* Write QC LOG */
01050 
01051                 sprintf(key_name,"%s%d","QC RON",i+1);
01052                 cpl_table_set_string(qclog_tbl,"key_name",nraw+i,key_name);
01053                 cpl_table_set_string(qclog_tbl,"key_type",nraw+i,"CPL_TYPE_DOUBLE");
01054 
01055                 sprintf(key_value,"%f",ron);
01056                 cpl_table_set_string(qclog_tbl,"key_value",nraw+i,key_value);
01057                 cpl_table_set_string(qclog_tbl,"key_help",nraw+i,"Read Out Noise");
01058 
01059             }
01060 
01061             /* Free and return */
01062             cpl_imagelist_delete(iset) ;
01063             return 0 ;
01064         }
01065 
01066 
01067 
01068 /*----------------------------------------------------------------------------*/
01075 /*----------------------------------------------------------------------------*/
01076 int sinfoni_mdark_compare(
01077         cpl_frame   *   frame1,
01078         cpl_frame   *   frame2)
01079 {
01080    int                 comparison=1 ;
01081    if (frame1==NULL || frame2==NULL) return -1 ;
01082    return comparison;
01083 }
01084 
01085 
01086 
01087 
01088 
01089 /*----------------------------------------------------------------------------*/
01096 /*----------------------------------------------------------------------------*/
01097 int sinfoni_dark_compare(
01098         cpl_frame   *   frame1,
01099         cpl_frame   *   frame2)
01100 {
01101     const char      *   fctid = "sinfoni_dark_compare" ;
01102     int                 comparison ;
01103     char            *   f1 ;
01104     char            *   f2 ;
01105     char            *   sval ;
01106     char                mode1[512] ;
01107     char                mode2[512] ;
01108     double              dval1, dval2 ;
01109 
01110     /* Test entries */
01111     if (frame1==NULL || frame2==NULL) return -1 ;
01112 
01113     /* Get filenames */
01114     f1 = (char *)cpl_frame_get_filename(frame1) ;
01115     f2 = (char *)cpl_frame_get_filename(frame2) ;
01116 
01117     /* Compare exposure time */
01118     comparison = 1 ;
01119     if ((sval = sinfoni_pfits_get_exptime(f1))==NULL) {
01120         cpl_msg_error(fctid, "cannot get exposure time from [%s]", f1);
01121         return -1 ;
01122     }
01123     dval1 = (double)atof(sval) ;
01124     if ((sval = sinfoni_pfits_get_exptime(f2))==NULL) {
01125         cpl_msg_error(fctid, "cannot get exposure time from [%s]", f2);
01126         return -1 ;
01127     }
01128     dval2 = (double)atof(sval) ;
01129     if (fabs(dval1-dval2) > 1e-5) comparison = 0 ;
01130 
01131     /* Compare the readout mode */
01132     if ((sval = sinfoni_pfits_get_rom(f1))==NULL) {
01133         cpl_msg_error(fctid, "cannot get read-out mode from [%s]", f1);
01134         return -1 ;
01135     }
01136     dval1 = (double)atof(sval) ;
01137     if ((sval = sinfoni_pfits_get_rom(f2))==NULL) {
01138         cpl_msg_error(fctid, "cannot get read-out mode from [%s]", f2);
01139         return -1 ;
01140     }
01141     dval2 = (double)atof(sval) ;
01142     if (fabs(dval1-dval2) > 1e-5) comparison = 0 ;
01143 
01144     /* Compare the detector mode */
01145     if ((sval = sinfoni_pfits_get_mode(f1))==NULL) {
01146         cpl_msg_error(fctid, "cannot get the detector mode from [%s]", f1);
01147         return -1 ;
01148                                                                    
01149   }
01150     strcpy(mode1, sval) ;
01151     if ((sval = sinfoni_pfits_get_mode(f2))==NULL) {
01152         cpl_msg_error(fctid, "cannot get the detector mode from [%s]", f2);
01153         return -1 ;
01154     }
01155     strcpy(mode2, sval) ;
01156     if (strcmp(mode1, mode2)) comparison = 0 ;
01157 
01158     /* Files have to be consequtive */
01159     /*
01160     if ((sval = sinfoni_pfits_get_expno(f1))==NULL) {
01161         cpl_msg_error(fctid, "cannot get exposure number from [%s]", f1);
01162         return -1 ;
01163     }
01164    
01165     dval1 = (double)atof(sval) ;
01166     if ((sval = sinfoni_pfits_get_expno(f2))==NULL) {
01167         cpl_msg_error(fctid, "cannot get exposure number from [%s]", f2);
01168         return -1 ;
01169     }
01170     dval2 = (double)atof(sval) ;
01171     if (fabs(dval1 - dval2) > 1.01) comparison = 0 ;
01172     */
01173 
01174     return comparison ;
01175 }
01176 
01177 
01178 
01179 int
01180 master_dark_qclog(cpl_frameset* raw, 
01181                    dark_config* cfg, OneImage** image_list,
01182                    OneImage* image)
01183 
01184 {
01185   const char* _id = "master_dark_qclog";
01186   char* key_value=NULL;
01187   int j=0;
01188   int i=0;
01189   int naxis1=0;
01190   int naxis2=0;
01191   int nsets=0;
01192   int zone_def[4];
01193   int* selection=NULL;
01194 
01195   double qc_darkmed_ave=0;
01196   double qc_darkmed_stdev=0;
01197   double qc_ron_val=0;
01198   double qc_ron_err=0;
01199   double qc_fpn_stdev=0;
01200 
01201 
01202   cpl_frame* first_frame=NULL;
01203   cpl_propertylist* rplist=NULL;
01204   cpl_table* qclog_tbl=NULL;
01205   cpl_frameset* f_one=NULL;
01206   cpl_vector* qc_dark_median=NULL;
01207   cpl_image* tmp_img=NULL;
01208   cpl_image* tmp_imgw=NULL;
01209 
01210   cpl_image* dark_img=NULL;
01211   cpl_image* dark_imgw=NULL;
01212 
01213   char* dark_name=NULL;
01214        qc_dark_median=cpl_vector_new(cfg->nframes);
01215        for ( j = 0 ; j < cfg->nframes ; j++ ) {
01216          tmp_imgw=cpl_image_wrap_float(image_list[j]->lx,
01217                                      image_list[j]->ly,
01218                                      image_list[j]->data);
01219          tmp_img=cpl_image_duplicate(tmp_imgw);
01220          cpl_image_unwrap(tmp_imgw);
01221      cpl_vector_set(qc_dark_median,j,cpl_image_get_median(tmp_img));
01222        }
01223        qc_darkmed_ave=cpl_vector_get_mean(qc_dark_median);
01224        qc_darkmed_stdev=cpl_vector_get_stdev(qc_dark_median);
01225        /* rms   = stdev * sqrt(1-1/(double)cpl_vector_get_size(myvector));  */
01226        /* qc_darkmed_stdev = qc_darkmed_stdev * sqrt(1-1/(double)cpl_vector_get_size(qc_dark_median)); */ 
01227        
01228        strcpy(dark_name,cfg->outName);
01229       
01230        cpl_msg_info(_id,"dark_name=%s\n",dark_name);
01231        dark_imgw=cpl_image_wrap_float(image->lx,image->ly,image->data);
01232        dark_img=cpl_image_duplicate(dark_imgw);
01233        cpl_image_unwrap(dark_imgw);    
01234 
01235 
01236        qc_darkmed_ave=cpl_vector_get_mean(qc_dark_median);
01237        qc_darkmed_stdev=cpl_vector_get_stdev(qc_dark_median);
01238 
01239  
01240        first_frame = cpl_frameset_get_frame(raw, 0) ;
01241        rplist = cpl_propertylist_new() ;
01242        (cpl_error_code)((
01243          rplist = cpl_propertylist_load(
01244                   cpl_strdup(cpl_frame_get_filename(first_frame) ), 0)) 
01245                 == NULL);
01246 
01247        naxis1=cpl_propertylist_get_int(rplist,"NAXIS1");
01248        naxis2=cpl_propertylist_get_int(rplist,"NAXIS1");
01249 
01250        if(cfg->qc_ron_xmin < 1) {
01251      cpl_msg_error(_id,"qc_ron_xmin %d < 1",cfg->qc_ron_xmin);
01252          return -1;
01253        }
01254        if(cfg->qc_ron_xmax > naxis1) {
01255      cpl_msg_error(_id,"qc_ron_xmax %d > %d",cfg->qc_ron_xmax,naxis1);
01256          return -1;
01257        }
01258 
01259        if(cfg->qc_ron_ymin < 1) {
01260      cpl_msg_error(_id,"qc_ron_ymin %d < 1",cfg->qc_ron_ymin);
01261          return -1;
01262        }
01263 
01264        if(cfg->qc_ron_ymax > naxis2) {
01265      cpl_msg_error(_id,"qc_ron_ymax %d > %d",cfg->qc_ron_ymax,naxis2);
01266          return -1;
01267        }
01268 
01269        zone_def[0]=cfg->qc_ron_xmin;
01270        zone_def[1]=cfg->qc_ron_xmax;
01271        zone_def[2]=cfg->qc_ron_ymin;
01272        zone_def[3]=cfg->qc_ron_ymax;
01273 
01274        if( CPL_ERROR_NONE != cpl_flux_get_noise_window(dark_img,
01275                                               zone_def,
01276                                               cfg->qc_ron_hsize,
01277                                               cfg->qc_ron_nsamp,
01278                                               &qc_ron_val,
01279                                               &qc_ron_err)) {
01280          cpl_msg_error(_id,"In computation RON on image %s",dark_name);
01281        }
01282 
01283 
01284 
01285        if(cfg->qc_fpn_xmin < 1) {
01286      cpl_msg_error(_id,"qc_ron_xmin %d < 1",cfg->qc_fpn_xmin );
01287          return -1;
01288        }
01289 
01290        if(cfg->qc_fpn_xmax > naxis1) {
01291      cpl_msg_error(_id,"qc_ron_xmax %d > %d",cfg->qc_fpn_xmax,naxis1);
01292          return -1;
01293        }
01294 
01295        if(cfg->qc_fpn_ymin < 1) {
01296      cpl_msg_error(_id,"qc_ron_ymin %d < 1",cfg->qc_fpn_ymin);
01297          return -1;
01298        }
01299 
01300        if(cfg->qc_fpn_ymax > naxis2) {
01301      cpl_msg_error(_id,"qc_ron_ymax %d > %d",cfg->qc_fpn_ymax,naxis2);
01302          return -1;
01303        }
01304 
01305  
01306        qc_fpn_stdev = cpl_image_get_stdev_window(dark_img,
01307                                         cfg->qc_fpn_xmin,
01308                                         cfg->qc_fpn_ymin,
01309                                         cfg->qc_fpn_xmax,
01310                                         cfg->qc_fpn_ymax);
01311 
01312   
01313 
01314        /* QC LOG */
01315 
01316        qclog_tbl = cpl_table_new(5);
01317        cpl_table_new_column(qclog_tbl,"key_name", CPL_TYPE_STRING);
01318        cpl_table_new_column(qclog_tbl,"key_type", CPL_TYPE_STRING);
01319        cpl_table_new_column(qclog_tbl,"key_value", CPL_TYPE_STRING);
01320        cpl_table_new_column(qclog_tbl,"key_help", CPL_TYPE_STRING);
01321 
01322        cpl_table_set_string(qclog_tbl,"key_name",0,"QC DARKMED AVE");
01323        cpl_table_set_string(qclog_tbl,"key_type",0,"CPL_TYPE_DOUBLE");
01324 
01325        key_value = cpl_calloc(FILE_NAME_SZ,sizeof(char));
01326        sprintf(key_value,"%f",qc_darkmed_ave);
01327        cpl_table_set_string(qclog_tbl,"key_value",0,key_value);
01328        cpl_table_set_string(qclog_tbl,"key_help",0,
01329                                 "Average of raw darks medians");
01330 
01331 
01332 
01333        cpl_table_set_string(qclog_tbl,"key_name",1,"QC DARKMED STDEV");
01334        cpl_table_set_string(qclog_tbl,"key_type",1,"CPL_TYPE_DOUBLE");
01335 
01336        sprintf(key_value,"%f",qc_darkmed_stdev);
01337        cpl_table_set_string(qclog_tbl,"key_value",1,key_value);
01338        cpl_table_set_string(qclog_tbl,"key_help",1,
01339                                 "STDEV of raw darks medians");
01340 
01341 
01342        cpl_table_set_string(qclog_tbl,"key_name",2,"QC RON");
01343        cpl_table_set_string(qclog_tbl,"key_type",2,"CPL_TYPE_DOUBLE");
01344 
01345        sprintf(key_value,"%f",qc_ron_val);
01346        cpl_table_set_string(qclog_tbl,"key_value",2,key_value);
01347        cpl_table_set_string(qclog_tbl,"key_help",2,"Read Out Noise");
01348 
01349 
01350 
01351        cpl_table_set_string(qclog_tbl,"key_name",3,"QC RONRMS");
01352        cpl_table_set_string(qclog_tbl,"key_type",3,"CPL_TYPE_DOUBLE");
01353 
01354        sprintf(key_value,"%f",qc_ron_err);
01355        cpl_table_set_string(qclog_tbl,"key_value",3,key_value);
01356        cpl_table_set_string(qclog_tbl,"key_help",3,
01357                                 "RMS on Read Out Noise");
01358 
01359 
01360        cpl_table_set_string(qclog_tbl,"key_name",4,"QC DARKFPN");
01361        cpl_table_set_string(qclog_tbl,"key_type",4,"CPL_TYPE_DOUBLE");
01362 
01363        sprintf(key_value,"%f",qc_fpn_stdev);
01364        cpl_table_set_string(qclog_tbl,"key_value",4,key_value);
01365        cpl_table_set_string(qclog_tbl,"key_help",4,
01366                                 "Fixed Patter Noise of combined frames");
01367 
01368 
01369        if(cpl_error_get_code() != CPL_ERROR_NONE) {
01370           cpl_msg_error(_id,"error adding qc info");
01371           cpl_msg_error(_id,(char* ) cpl_error_get_message());
01372           return -1;
01373        }
01374 
01375 
01376        /* special way to calculate RON: for each couple */
01377 
01378        selection = cpl_frameset_labelise(raw,sinfoni_dark_compare,&nsets);
01379        for ( i = 0 ; i < nsets ; i++ ) {
01380          /* reduce data set number nb i */
01381          cpl_msg_info(_id,"Reduce data set no %d out of %d", i+1, nsets);
01382          cpl_msg_indent_more();
01383      f_one = cpl_frameset_extract(raw,selection,i);
01384          /* At least 2 frames are required */
01385          if (cpl_frameset_get_size(f_one) < 2) {
01386 
01387            cpl_msg_warning(_id," Setting %d skipped (not enough frames)",i+1);
01388      } else {
01389 
01390        /* RON part */
01391            
01392            if (sinfoni_dark_ron_reduce(f_one,cfg,qclog_tbl) ) {
01393          cpl_msg_warning(_id, "Cannot reduce set number %d", i+1) ;
01394        }
01395 
01396      }
01397          cpl_frameset_delete(f_one);
01398          cpl_msg_indent_less();
01399        }
01400        cpl_free(key_value);
01401        return 0;
01402 }

Generated on Wed Oct 26 13:08:52 2005 for SINFONI Pipeline Reference Manual by doxygen1.2.13.1 written by Dimitri van Heesch, © 1997-2001