uves_physmod_body.c

00001 /*                                                                              *
00002  *   This file is part of the ESO UVES Pipeline                                 *
00003  *   Copyright (C) 2004,2005 European Southern Observatory                      *
00004  *                                                                              *
00005  *   This library is free software; you can redistribute it and/or modify       *
00006  *   it under the terms of the GNU General Public License as published by       *
00007  *   the Free Software Foundation; either version 2 of the License, or          *
00008  *   (at your option) any later version.                                        *
00009  *                                                                              *
00010  *   This program is distributed in the hope that it will be useful,            *
00011  *   but WITHOUT ANY WARRANTY; without even the implied warranty of             *
00012  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
00013  *   GNU General Public License for more details.                               *
00014  *                                                                              *
00015  *   You should have received a copy of the GNU General Public License          *
00016  *   along with this program; if not, write to the Free Software                *
00017  *   Foundation, 51 Franklin St, Fifth Floor, Boston, MA  02111-1307  USA       *
00018  *                                                                              */
00019  
00020 /*
00021  * $Author: amodigli $
00022  * $Date: 2007/10/23 07:37:43 $
00023  * $Revision: 1.36 $
00024  * $Name: uves-3_4_5 $
00025  * $Log: uves_physmod_body.c,v $
00026  * Revision 1.36  2007/10/23 07:37:43  amodigli
00027  * if provided subtract MASTER_BIAS from input raw and reference formatchecks
00028  *
00029  * Revision 1.35  2007/10/05 16:01:45  amodigli
00030  * using proces_chip parameter to process or not a given RED chip
00031  *
00032  * Revision 1.34  2007/08/21 13:08:26  jmlarsen
00033  * Removed irplib_access module, largely deprecated by CPL-4
00034  *
00035  * Revision 1.33  2007/08/10 15:24:11  amodigli
00036  * fixed seg fault with flames-uves
00037  *
00038  * Revision 1.32  2007/06/26 15:08:17  amodigli
00039  * changes to make work flames and uves physmod in simple way
00040  *
00041  * Revision 1.31  2007/06/22 09:30:22  jmlarsen
00042  * Changed interface of uves_save_image
00043  *
00044  * Revision 1.30  2007/06/13 15:13:48  amodigli
00045  * fixed mem leaks in case of fiber mode data
00046  *
00047  * Revision 1.29  2007/06/06 08:17:33  amodigli
00048  * replace tab with 4 spaces
00049  *
00050  * Revision 1.28  2007/05/22 14:34:32  jmlarsen
00051  * Removed unnecessary includes
00052  *
00053  * Revision 1.27  2007/05/14 09:38:38  amodigli
00054  * removed call to irplib_error_dump
00055  *
00056  * Revision 1.26  2007/04/25 08:38:40  amodigli
00057  * chnaged interface uves_physmod_plotmod
00058  *
00059  * Revision 1.25  2007/04/24 14:08:53  jmlarsen
00060  * Log more QC parameters (DFS03805)
00061  *
00062  * Revision 1.24  2007/04/24 12:50:29  jmlarsen
00063  * Replaced cpl_propertylist -> uves_propertylist which is much faster
00064  *
00065  * Revision 1.23  2007/04/14 05:55:19  amodigli
00066  * warning of flames,iter demoted to debug message
00067  *
00068  * Revision 1.22  2007/04/12 12:03:10  jmlarsen
00069  * Fixed doc. typo
00070  *
00071  * Revision 1.21  2007/03/05 10:18:55  jmlarsen
00072  * Do QC-log INS.SLITi.WID
00073  *
00074  * Revision 1.20  2007/02/26 10:16:22  jmlarsen
00075  * Do not QC log slit width
00076  *
00077  * Revision 1.19  2007/01/15 14:28:44  jmlarsen
00078  * Write default stability QC-parameters, only when master frame is provided
00079  *
00080  * Revision 1.18  2007/01/15 08:43:15  jmlarsen
00081  * Fixed missing plots
00082  *
00083  * Revision 1.17  2007/01/13 09:52:22  amodigli
00084  * fixed some problems on flames QC log
00085  *
00086  * Revision 1.16  2007/01/09 17:46:03  amodigli
00087  * fixed a problem in echelle mode
00088  *
00089  * Revision 1.15  2007/01/08 16:59:18  amodigli
00090  * changes to make flames-uves iterations to recover physical model
00091  *
00092  * Revision 1.14  2006/12/07 08:26:04  jmlarsen
00093  * Added uves_pfits_get_readspeed
00094  *
00095  * Revision 1.13  2006/12/01 12:29:21  jmlarsen
00096  * Factored out FLAMES plate-id code
00097  *
00098  * Revision 1.12  2006/11/22 08:42:20  jmlarsen
00099  * Set traceid = 1, not 0 for UVES
00100  *
00101  * Revision 1.10  2006/11/22 08:22:29  jmlarsen
00102  * Set message level according to preprocessor symbol
00103  *
00104  * Revision 1.9  2006/11/16 14:12:21  jmlarsen
00105  * Changed undefined trace number from 0 to -1, to support zero as an actual trace number
00106  *
00107  * Revision 1.8  2006/11/16 09:49:25  jmlarsen
00108  * Fixed doxygen bug
00109  *
00110  * Revision 1.7  2006/11/15 15:02:14  jmlarsen
00111  * Implemented const safe workarounds for CPL functions
00112  *
00113  * Revision 1.5  2006/11/15 14:04:08  jmlarsen
00114  * Removed non-const version of parameterlist_get_first/last/next which is already
00115  * in CPL, added const-safe wrapper, unwrapper and deallocator functions
00116  *
00117  * Revision 1.4  2006/11/06 15:19:41  jmlarsen
00118  * Removed unused include directives
00119  *
00120  * Revision 1.3  2006/10/26 14:03:48  jmlarsen
00121  * Fixed position of const modifier
00122  *
00123  * Revision 1.2  2006/10/25 11:43:32  amodigli
00124  * fixed problem running physmod in debug mode
00125  *
00126  * Revision 1.1  2006/10/24 14:09:56  jmlarsen
00127  * Factored out common UVES/FLAMES code
00128  *
00129  * Revision 1.30  2006/10/19 13:53:25  jmlarsen
00130  * Changed guess line table tag to LINE_GUESS_TAB
00131  *
00132  * Revision 1.29  2006/10/17 12:33:02  jmlarsen
00133  * Added semicolon at UVES_RECIPE_DEFINE invocation
00134  *
00135  * Revision 1.28  2006/10/11 12:22:36  amodigli
00136  * now the stability check consist only i the msrawxy and the table comparison, as in MIDAS
00137  *
00138  * Revision 1.27  2006/10/09 13:01:13  jmlarsen
00139  * Use macro to define recipe interface functions
00140  *
00141  * Revision 1.26  2006/09/19 14:31:38  jmlarsen
00142  * uves_insert_frame(): use bitmap to specify which image statistics keywords must be computed
00143  *
00144  * Revision 1.25  2006/09/19 06:55:39  jmlarsen
00145  * Changed interface of uves_frameset to optionally write image statistics kewwords
00146  *
00147  * Revision 1.24  2006/08/24 11:36:37  jmlarsen
00148  * Write recipe start/stop time to header
00149  *
00150  * Revision 1.23  2006/08/18 13:35:42  jmlarsen
00151  * Fixed/changed QC parameter formats
00152  *
00153  * Revision 1.22  2006/08/17 13:56:53  jmlarsen
00154  * Reduced max line length
00155  *
00156  * Revision 1.21  2006/08/11 14:56:05  amodigli
00157  * removed Doxygen warnings
00158  *
00159  * Revision 1.20  2006/08/07 11:35:35  jmlarsen
00160  * Disabled parameter environment variable mode
00161  *
00162  * Revision 1.19  2006/08/01 14:42:34  amodigli
00163  * fixed bugs getting raw header from master formatcheck
00164  *
00165  * Revision 1.18  2006/07/31 06:29:26  amodigli
00166  * added QC on stability test
00167  *
00168  * Revision 1.17  2006/07/28 14:51:26  amodigli
00169  * fixed some bugs on improper table selection
00170  *
00171  * Revision 1.16  2006/07/14 12:19:28  jmlarsen
00172  * Support multiple QC tests per product
00173  *
00174  * Revision 1.15  2006/07/03 12:46:34  amodigli
00175  * updated description
00176  *
00177  * Revision 1.14  2006/06/28 13:28:29  amodigli
00178  * improved output
00179  *
00180  * Revision 1.13  2006/06/20 09:06:39  amodigli
00181  * correct input tag info in man page
00182  *
00183  * Revision 1.12  2006/06/16 08:25:45  jmlarsen
00184  * Manually propagate ESO.DET. keywords from 1st/2nd input header
00185  *
00186  * Revision 1.11  2006/06/13 11:57:02  jmlarsen
00187  * Check that calibration frames are from the same chip ID
00188  *
00189  * Revision 1.10  2006/06/07 13:06:28  jmlarsen
00190  * Changed doxygen tag addtogroup -> defgroup
00191  *
00192  * Revision 1.9  2006/06/07 09:01:28  amodigli
00193  * added some doc
00194  *
00195  * Revision 1.8  2006/05/08 15:42:16  amodigli
00196  * allow to specify order column label
00197  *
00198  * Revision 1.7  2006/04/20 10:47:39  amodigli
00199  * added qclog
00200  *
00201  * Revision 1.6  2006/04/07 07:11:12  jmlarsen
00202  * Minor doc. fix
00203  *
00204  * Revision 1.5  2006/04/06 09:48:15  amodigli
00205  * changed uves_frameset_insert interface to have QC log
00206  *
00207  * Revision 1.4  2006/04/06 08:42:19  jmlarsen
00208  * Changed indentation
00209  *
00210  * Revision 1.3  2006/03/03 13:54:11  jmlarsen
00211  * Changed syntax of check macro
00212  *
00213  * Revision 1.2  2006/02/28 09:15:22  jmlarsen
00214  * Minor update
00215  *
00216  * Revision 1.1  2006/02/03 07:46:30  jmlarsen
00217  * Moved recipe implementations to ./uves directory
00218  *
00219  * Revision 1.66  2006/01/25 10:09:18  jmlarsen
00220  * Added doxygen end marker
00221  *
00222  * Revision 1.65  2006/01/20 10:36:25  amodigli
00223  *
00224  * Fixed warings from doxigen
00225  *
00226  * Revision 1.64  2006/01/19 10:03:06  amodigli
00227  * Fixed leaks
00228  *
00229  * Revision 1.62  2006/01/16 13:52:58  jmlarsen
00230  * Removed memory leak
00231  *
00232  * Revision 1.61  2006/01/16 08:01:57  amodigli
00233  *
00234  * Added stability check
00235  *
00236  * Revision 1.60  2006/01/13 13:43:15  jmlarsen
00237  * Removed memory leak
00238  *
00239  * Revision 1.59  2006/01/13 09:54:42  amodigli
00240  * Fixed some bugs: improved agreement with MIDAS version
00241  *
00242  * Revision 1.58  2006/01/09 15:23:06  jmlarsen
00243  * Removed some warnings
00244  *
00245  * Revision 1.57  2006/01/09 14:05:42  amodigli
00246  * Fixed doxigen warnings
00247  *
00248  * Revision 1.56  2006/01/03 16:57:13  amodigli
00249  * Fixed bug
00250  *
00251  * Revision 1.55  2006/01/03 14:47:53  amodigli
00252  *
00253  * Added uves_physmod_chop_otab.h .c to match MIDAS
00254  *
00255  * Revision 1.54  2005/12/19 16:17:55  jmlarsen
00256  * Replaced bool -> int
00257  *
00258  */
00259 #ifdef HAVE_CONFIG_H
00260 #  include <config.h>
00261 #endif
00262 
00263 /*----------------------------------------------------------------------------*/
00267 /*----------------------------------------------------------------------------*/
00268 
00269 /*-----------------------------------------------------------------------------
00270                                 Includes
00271  -----------------------------------------------------------------------------*/
00272 
00273 /* Self */
00274 #include <uves_physmod_body.h>
00275 
00276 /* called related functions */
00277 #include <uves_physmod_plotmod.h>
00278 #include <uves_physmod_create_table.h>
00279 
00280 #include <uves_physmod_qc1pmtbl.h>
00281 #include <uves_physmod_calmap.h>
00282 #include <uves_physmod_msrawxy.h>
00283 #include <uves_physmod_chop_otab.h>
00284 #include <uves_physmod_stability_check.h>
00285 
00286 /* Utility functions */
00287 #include <uves_utils.h>
00288 #include <uves_utils_polynomial.h>
00289 #include <uves_utils_wrappers.h>
00290 #include <uves_pfits.h>
00291 #include <uves_dfs.h>
00292 #include <uves_parameters.h>
00293 #include <uves_qclog.h>
00294 #include <uves_recipe.h>
00295 #include <uves_error.h>
00296 #include <uves_msg.h>
00297 
00298 /* Library */
00299 #include <cpl.h>
00300 #include <math.h>
00301 #include <stdbool.h>
00302 
00303 /*-----------------------------------------------------------------------------
00304                                 Defines
00305  -----------------------------------------------------------------------------*/
00306 
00307 #define UVES_PHYSMOD_ITER_MAX 5
00308 /*-----------------------------------------------------------------------------
00309                             Functions prototypes
00310  ----------------------------------------------------------------------------*/
00311 
00312 static int 
00313 uves_physmod_qclog(cpl_table* line_table,
00314            cpl_table* order_table,
00315            cpl_table* qclog,
00316            const uves_propertylist *raw_header,
00317            enum uves_chip chip,
00318                    bool flames,
00319                    const int iter,
00320                    const int plate_no);
00321 
00322 static int 
00323 uves_physmod_qclog_sc(const double med_dx, 
00324               const double med_dy,
00325               const double avg_dx,
00326                       const double avg_dy,
00327                       const uves_propertylist *raw_header,
00328                       const uves_propertylist *ref_header,
00329                       enum  uves_chip chip,
00330               bool flames,
00331               const int iter,
00332               cpl_table* qclog);
00333 
00334 /*-----------------------------------------------------------------------------
00335                             Recipe standard code
00336  -----------------------------------------------------------------------------*/
00337 
00338 const char * const uves_physmod_desc_short = "Implements the UVES physical model";
00339 const char * const uves_physmod_desc =
00340 "This recipe implements the UVES physical model\n"
00341 "Input files are BLUE or RED arm formatcheck frames identified by the tag\n"
00342 "ARC_LAMP_FORM_xxxx, xxxx=BLUE or RED and a ThAr line reference table\n"
00343 "identified by the tag LINE_REFER_TABLE\n"
00344 "The recipe extracts from the input files FITS header data indicating the\n"
00345 "instrument setting and ambiental atmospheric conditions, then using the\n"
00346 "model predicts X,Y position of the lines listed in the LINE_REFER_TABLE\n"
00347 "table which are imaging on the detector and stores this information in an\n"
00348 "guess order and a guess line table.\n"
00349 "Output are a guess order table and a guess line table per chip.\n"
00350 "If the user provides in input also master format checks having tag\n"
00351 "MASTER_FORM_xxxx, xxxx=BLUE or REDL and REDU the recipe performs also a\n"
00352 "stability check\n";
00353 
00355 /*-----------------------------------------------------------------------------
00356                             Functions code
00357  -----------------------------------------------------------------------------*/
00358 
00359 /*----------------------------------------------------------------------------*/
00365 /*----------------------------------------------------------------------------*/
00366 int
00367 uves_physmod_define_parameters_body(cpl_parameterlist *parameters, 
00368                                     const char *recipe_id)
00369 {
00370     const char *subcontext = NULL;
00371 
00372     /*****************
00373      *    General    *
00374      *****************/
00375 
00376     if (uves_define_global_parameters(parameters) != CPL_ERROR_NONE)
00377     {
00378         return -1;
00379     }
00380     
00381     uves_par_new_range("mbox_x",
00382                  CPL_TYPE_INT,
00383                  "Match box X size",
00384                  40,1,100);
00385 
00386     uves_par_new_range("mbox_y",
00387                  CPL_TYPE_INT,
00388                  "Match box Y size",
00389                  40,1,100);
00390 
00391     uves_par_new_value("trans_x",
00392                  CPL_TYPE_DOUBLE,
00393                  "Detector translation along X",
00394                  0.);
00395 
00396     uves_par_new_value("trans_y",
00397                  CPL_TYPE_DOUBLE,
00398                  "Detector translation along Y",
00399                  0.);
00400 
00401     uves_par_new_value("ech_angle_off",
00402                  CPL_TYPE_DOUBLE,
00403                  "Offset on echelle angle",
00404                  0.);
00405 
00406     uves_par_new_value("cd_angle_off",
00407                  CPL_TYPE_DOUBLE,
00408                  "Offset on cross disperser angle",
00409                  0.);
00410 
00411     uves_par_new_value("ccd_rot_angle_off",
00412                  CPL_TYPE_DOUBLE,
00413                  "Offset on CCD rotation angle",
00414                  0.);
00415 
00416     uves_par_new_value("compute_regression_sw",
00417                  CPL_TYPE_BOOL,
00418                  "Compute regression?",
00419                  true);
00420 
00421     uves_par_new_value("x_axis_scale",
00422                  CPL_TYPE_DOUBLE,
00423                  "Scale X axis",
00424                  0.);
00425 
00426     uves_par_new_value("y_axis_scale",
00427                  CPL_TYPE_DOUBLE,
00428                  "Scale Y axis",
00429                  0.);
00430 
00431     uves_par_new_value("def_pol1",
00432                  CPL_TYPE_INT,
00433                  "Polynomial X deg",
00434                  4);
00435 
00436     uves_par_new_value("def_pol2",
00437                  CPL_TYPE_INT,
00438                  "Polynomial Y deg",
00439                  5);
00440 
00441     uves_par_new_value("kappa",
00442                  CPL_TYPE_DOUBLE,
00443                  "Kappa value in kappa sigma clipping "
00444                  "on RESIDUAL between YFIT and Y columns",
00445                  4.5);
00446 
00447     uves_par_new_value("tol",
00448                  CPL_TYPE_DOUBLE,
00449                  "Tolerance in kappa sigma clipping "
00450                  "on RESIDUAL between YFIT and Y columns",
00451                  2.0);
00452 
00453     return (int) cpl_error_get_code();
00454 }
00455 /*----------------------------------------------------------------------------*/
00483 /*----------------------------------------------------------------------------*/
00484 
00485 static cpl_table *
00486 uves_physmod_process_chip(const cpl_image *raw_image, 
00487                           const uves_propertylist *raw_header, 
00488                           const char *raw_filename, 
00489                           enum uves_chip chip,
00490                           const char *recipe_id,
00491                           const int DEBUG, 
00492                           const cpl_parameterlist* parameters, 
00493                           cpl_table* line_refer,
00494                           const double physmod_shift_x,
00495                           const double physmod_shift_y,
00496                           cpl_table** tmp_mod_tbl,
00497                           cpl_table** lin_tbl,
00498                           cpl_table** ord_tbl,
00499                           cpl_table**  mline_tbl,
00500                           int* abs_ord_min,
00501                           int* abs_ord_max,
00502                           polynomial** absolute_order_poly2d,
00503                           const int stability_cnt)
00504 {
00505 
00506     cpl_table *tmp_fsr_tbl = NULL;
00507     cpl_table *tmp_m_tbl = NULL;
00508     cpl_table *tmp_p_tbl = NULL;
00509     cpl_table *tmp_w_tbl = NULL;
00510     cpl_table *tmp_s_tbl = NULL;
00511     cpl_table *tmp_rline_tbl = NULL;
00512     cpl_table *tmp_npline_tbl = NULL;
00513 
00514 
00515     cpl_table * result=NULL;
00516 
00517     /* Start processing this chip */
00518     if(stability_cnt == 0) {
00519       check( uves_physmod_create_table(raw_header, 
00520                                        chip,
00521                                        recipe_id,
00522                                        parameters, 
00523                                        line_refer, 
00524                                        physmod_shift_x,
00525                                        physmod_shift_y,
00526                                        tmp_mod_tbl,
00527                                        &tmp_fsr_tbl), 
00528                     "Could not run UVES physical model on the raw image %s", 
00529                                        raw_filename);
00530     }
00531  
00532     uves_free_table(&tmp_rline_tbl);
00533     check( uves_physmod_msrawxy(raw_image, 
00534                 raw_header, 
00535                 recipe_id,
00536                 parameters, 
00537                 *tmp_mod_tbl,
00538                 lin_tbl,
00539                 &tmp_m_tbl,
00540                 &tmp_p_tbl,
00541                 &tmp_rline_tbl,
00542                 mline_tbl,
00543                 &tmp_npline_tbl), 
00544        "Could not run uves_msrawxy on raw image %s", 
00545        raw_filename);
00546 
00547 
00548     check(uves_physmod_plotmod(tmp_rline_tbl,raw_header,recipe_id,
00549                                parameters,chip),
00550           "Could not run uves_physmod_plotmod");
00551 
00552     if(stability_cnt == 0) {
00553       uves_free_table(&tmp_w_tbl);
00554       uves_free_table(&tmp_s_tbl);
00555       check(uves_physmod_calmap(raw_header,
00556                     chip,
00557                     recipe_id,
00558                     parameters, 
00559                     tmp_npline_tbl,
00560                     ord_tbl,
00561                     lin_tbl,
00562                     &tmp_w_tbl,
00563                     &tmp_s_tbl,
00564                     abs_ord_min,
00565                     abs_ord_max,
00566                     absolute_order_poly2d), 
00567         "Could not run uves_calmap on raw image %s", raw_filename);
00568 
00569       check(uves_physmod_qc1pmtbl(&tmp_rline_tbl,lin_tbl), 
00570        "Could not run uves_qc1pmtbl on raw image %s", raw_filename);
00571 
00572 
00573       check(uves_physmod_chop_otab(raw_header,chip,ord_tbl,"ORDER",
00574                    abs_ord_min,abs_ord_max),
00575             "Could not run uves_physmod_chop_otab on raw image %s",
00576             raw_filename);
00577     }
00578 
00579     if (DEBUG) {
00580     const char *product_filename = NULL;
00581         /* Temporary products (to DEBUG) */
00582 
00583     /* Basic info about orders */    
00584     product_filename = "arclampform";
00585         check( uves_save_image_local("Physical model table", 
00586                product_filename, raw_image, chip, -1, -1, raw_header, true),
00587               "Error saving arc lamp form image");
00588 
00589     product_filename = "pline";
00590         check( uves_save_table_local("Physical model table", 
00591                product_filename, *tmp_mod_tbl, chip, -1, -1, NULL, NULL),
00592               "Error saving physical model table");
00593 
00594       
00595     if(stability_cnt == 0) {
00596       product_filename = "free_spectral_range";
00597       check( uves_save_table_local("FSR table",
00598                        product_filename, tmp_fsr_tbl,
00599                                        chip, -1, -1, NULL, NULL),
00600          "Error saving free spectral range table");
00601 
00602     }
00603         
00604     product_filename = "midduml";
00605         check( uves_save_table_local("midduml table", 
00606                product_filename, *lin_tbl, chip, -1, -1, NULL, NULL),
00607               "Error saving midduml table");
00608 
00609 
00610  
00611     product_filename = "middumm";
00612         check( uves_save_table_local("middumm table", 
00613                product_filename, tmp_m_tbl, chip, -1, -1, NULL, NULL),
00614               "Error saving middumm table");
00615 
00616 
00617     
00618     product_filename = "middumrline";
00619         check( uves_save_table_local("middumrline table", 
00620                product_filename, tmp_rline_tbl, chip, -1, -1, NULL, NULL),
00621               "Error saving middumrline table");
00622 
00623 
00624     product_filename = "middummline";
00625         check( uves_save_table_local("middummline table", 
00626                product_filename, *mline_tbl, chip, -1, -1, NULL, NULL),
00627               "Error saving middummline table");
00628 
00629 
00630     product_filename = "middump";
00631         check( uves_save_table_local("middump table", 
00632                product_filename, tmp_p_tbl, chip, -1, -1, NULL, NULL),
00633               "Error saving middump table");
00634 
00635        
00636     product_filename = "middumnpline";
00637         check( uves_save_table_local("middumnpline table", 
00638                product_filename, tmp_npline_tbl, chip, -1, -1, NULL, NULL),
00639               "Error saving middumnpline table");
00640       
00641        
00642     /* Calmap */
00643     if(stability_cnt== 0) {
00644       product_filename = "middumw";
00645       check( uves_save_table_local("middumw table", 
00646                        product_filename, tmp_w_tbl, 
00647                                        chip, -1, -1, NULL, NULL),
00648          "Error saving middumw table");
00649      
00650       product_filename = "middums";
00651       check( uves_save_table_local("middums table", 
00652                        product_filename, tmp_s_tbl, 
00653                                        chip, -1, -1, NULL, NULL),
00654          "Error saving middums table");
00655      
00656        
00657       product_filename = "order";
00658       check( uves_save_table_local("order table", 
00659                        product_filename, *ord_tbl, 
00660                                        chip, -1, -1, NULL, NULL),
00661          "Error saving order table");
00662       uves_msg("Order table saved to file %s", 
00663            product_filename);
00664 
00665     }
00666     product_filename = "line";
00667         check( uves_save_table_local("line table", 
00668                product_filename, *lin_tbl, chip, -1, -1, NULL, NULL),
00669               "Error saving uves_line table");
00670         uves_msg("Line table saved to file %s", 
00671                                 product_filename);
00672     
00673      
00674     
00675     }
00676     
00677   cleanup:
00678     uves_free_table(&tmp_fsr_tbl);
00679     uves_free_table(&tmp_m_tbl);
00680     uves_free_table(&tmp_p_tbl);
00681     uves_free_table(&tmp_w_tbl);
00682     uves_free_table(&tmp_s_tbl);
00683     uves_free_table(&tmp_rline_tbl);
00684      uves_free_table(&tmp_npline_tbl);
00685      
00686     uves_msg_debug("end %s",__func__);
00687     return result;
00688 }
00689 
00690 /*----------------------------------------------------------------------------*/
00699 /*----------------------------------------------------------------------------*/
00700 void
00701 uves_physmod_exe_body(cpl_frameset *frames,
00702               bool flames,
00703               const char *recipe_id,
00704               const cpl_parameterlist *parameters,
00705               const char *starttime)
00706 {
00707     /* Input image */
00708     cpl_image        *raw_image[2]      = {NULL, NULL};
00709     uves_propertylist *raw_header[2]     = {NULL, NULL};
00710     uves_propertylist *rotated_header[2] = {NULL, NULL};
00711     uves_propertylist *master_formatcheck_header[2] = {NULL, NULL};
00712 
00713     /* Physical Model guess table products */
00714     cpl_table        *line_table     = NULL;
00715     cpl_table        *order_table     = NULL;
00716     cpl_table        *mline_table     = NULL;
00717     cpl_table        *m_mline_table     = NULL;
00718     cpl_table        *model_table = NULL;
00719 
00720     cpl_table        *r_mline_table     = NULL;
00721     cpl_table        *mst_line_table     = NULL;
00722     cpl_table        *mst_mline_table     = NULL;
00723     cpl_table        *mst_order_table     = NULL;
00724 
00725 
00726     uves_propertylist *product_header = NULL;
00727     uves_propertylist *table_header = NULL;
00728     cpl_table        *line_refer            = NULL;
00729     polynomial       *absolute_order_poly2d=NULL;      
00730     polynomial       *mst_absolute_order_poly2d=NULL;      
00731 
00732 
00733     /* Local variables */
00734     int      DEBUG=0;
00735     int abs_ord_min=0;
00736     int abs_ord_max=0;
00737     int mst_abs_ord_min=0;
00738     int mst_abs_ord_max=0;
00739     double avg_dx=0;
00740     double avg_dy=0;
00741 
00742     const char *raw_filename = "";
00743     char *product_filename = NULL;
00744     
00745     bool blue = false;
00746     enum uves_chip chip;    
00747     const char *line_refer_filename = "";
00748     const char *master_formatcheck_filename = "";
00749     cpl_image        *master_formatcheck    = NULL;
00750     int nordpred=0;
00751     int plate_no=0;
00752     int iter=1;
00753     int it=0;
00754 
00755     int iter_max=UVES_PHYSMOD_ITER_MAX;
00756     /* QC tables for iter_max*(TEST1+TEST2) and a NULL pointer */
00757     cpl_table* qclog[iter_max*2+1];
00758 
00759 
00760     double physmod_shift_x=0;
00761     double physmod_shift_y=0;
00762     const double max_shift_x=0.4;
00763     const double max_shift_y=0.2;
00764     double med_dx=2*max_shift_x;
00765     double med_dy=2*max_shift_y;
00766     const char* PROCESS_CHIP=NULL;
00767     /* Master bias */
00768     cpl_image *master_bias               = NULL;
00769     uves_propertylist *master_bias_header = NULL;
00770 
00771 
00772 
00773 
00774     for( iter=0 ; iter < 2*iter_max+1 ; iter++) {
00775       qclog[iter]=NULL;
00776     }
00777 
00778     if(flames) {
00779       iter_max=1;  //Temporally changed to 1
00780     } else {
00781       iter_max=1;
00782     }
00783     check( uves_get_parameter(parameters, NULL, "uves", "debug",  
00784                   CPL_TYPE_BOOL, &DEBUG),
00785        "Could not read parameter");
00786     check( uves_get_parameter(parameters, NULL, "uves", "process_chip", CPL_TYPE_STRING, &PROCESS_CHIP),
00787                "Could not read parameter");
00788 
00789     /* Load raw image and header, and identify input frame as red or blue */
00790     check( uves_load_formatcheck(frames, flames, &raw_filename, raw_image, 
00791                  raw_header, rotated_header, &blue), 
00792        "Error loading raw frame");
00793 
00794     /* Load reference line table */
00795     check( uves_load_linerefertable(frames, &line_refer_filename, 
00796            &line_refer, NULL), "Could not load line reference table");
00797     uves_msg("Using line reference table in '%s'", line_refer_filename);
00798 
00799 
00800 
00801 
00802     /* Loop over one or two chips */
00803     for (chip = uves_chip_get_first(blue); 
00804          chip != UVES_CHIP_INVALID; 
00805          chip = uves_chip_get_next(chip))
00806     {
00807  
00808       if(strcmp(PROCESS_CHIP,"redu") == 0) {
00809     chip = uves_chip_get_next(chip);
00810       }
00811 
00812         int stab_check=0;
00813         int stability_cnt=1;
00814         const char *chip_name = "";
00815         int raw_index = uves_chip_get_index(chip);
00816         const char *master_bias_filename = "";
00817         
00818         uves_msg("Processing %s chip in '%s'", 
00819              uves_chip_tostring_upper(chip), raw_filename);
00820 
00821         check_nomsg( chip_name = uves_pfits_get_chipid(raw_header[raw_index], chip));
00822 
00823 
00824 
00825         if(flames) {
00826          check(plate_no = uves_flames_pfits_get_plateid(raw_header[raw_index]),
00827            "Error reading plate id");
00828     }
00829 
00830 
00831         /* Check if a stability check can be done */
00832         if (cpl_frameset_find(frames, UVES_MASTER_ARC_FORM(chip)) != NULL) {
00833       
00834       uves_free_image (&master_formatcheck);
00835       uves_free_propertylist(&master_formatcheck_header[raw_index]);
00836       check( uves_load_master_formatcheck(frames, 
00837                           chip_name,
00838                           &master_formatcheck_filename, 
00839                           &master_formatcheck,
00840                           &master_formatcheck_header[raw_index],                  
00841                           chip),
00842          "Could not load master formatcheck frm");
00843             
00844 
00845           stab_check=1;
00846 
00847         } else {
00848           uves_msg_low("No master format check frm in SOF.");
00849           uves_msg_low("Stability check not done");
00850         }
00851 
00852         /* Load master bias, set pointer to NULL if not present */
00853         uves_free_image(&master_bias);
00854         uves_free_propertylist(&master_bias_header);
00855         if (cpl_frameset_find(frames, UVES_MASTER_BIAS(chip)) != NULL)
00856         {
00857             uves_free_image(&master_bias);
00858             uves_free_propertylist(&master_bias_header);
00859             check( uves_load_mbias(frames,
00860                        chip_name,
00861                        &master_bias_filename, &master_bias,
00862                        &master_bias_header, chip), 
00863                "Error loading master bias");
00864             
00865             uves_msg_low("Using master bias in '%s' and '%s'", 
00866              master_bias_filename,master_formatcheck_filename);
00867         check_nomsg(cpl_image_subtract(raw_image[raw_index],master_bias));
00868         if(stab_check==1) {
00869           check_nomsg(cpl_image_subtract(master_formatcheck,master_bias));
00870         }     
00871 
00872         }
00873         else
00874         {
00875             uves_msg_low("No master bias in SOF. Bias subtraction not done");
00876         }
00877 
00878         /* Init QC-Log: before starting the stability check as in 
00879                FLAMES-UVES one may have several iterations to be dumped 
00880                on the different tables
00881         */
00882         physmod_shift_x=0;
00883         physmod_shift_y=0;
00884     for(iter=1,it=0;
00885             iter<=iter_max &&
00886                 (fabs(med_dx) > max_shift_x || 
00887                  fabs(med_dy) > max_shift_y ) ;
00888             iter++,it+=2) {
00889       uves_msg("iter=%d it=%d",iter,it);
00890 
00891             uves_qclog_delete(&qclog[it]);
00892             uves_qclog_delete(&qclog[it+1]);
00893             qclog[it]   = uves_qclog_init(raw_header[raw_index], chip);
00894             qclog[it+1] = uves_qclog_init(raw_header[raw_index], chip);
00895 
00896   
00897         //Run the physical model on the raw frame
00898             uves_free_table(&model_table);
00899             uves_free_table(&line_table);
00900             uves_free_table(&order_table);
00901             uves_free_table(&mline_table);
00902 
00903             uves_polynomial_delete(&absolute_order_poly2d);
00904             uves_msg("Run the physical model on the raw frame");
00905             check( uves_physmod_process_chip(raw_image[raw_index], 
00906                      raw_header[raw_index],
00907                      raw_filename,
00908                      chip,
00909                      recipe_id,
00910                      DEBUG,
00911                      parameters,
00912                      line_refer,
00913                      physmod_shift_x,
00914                      physmod_shift_y,
00915                      &model_table,
00916                      &line_table,
00917                      &order_table,
00918                      &mline_table,
00919                      &abs_ord_min,
00920                      &abs_ord_max,
00921                      &absolute_order_poly2d,0),
00922            "Error processing chip");
00923 
00924         nordpred=abs_ord_max-abs_ord_min+1;
00925         uves_msg("No of predicted orders %d",nordpred);
00926 
00927 
00928             /* add QC log */
00929             uves_msg("add QC log on raw frame");
00930             ck0(uves_physmod_qclog(line_table,order_table,qclog[it],
00931                        raw_header[raw_index], chip,
00932                        flames,iter,plate_no),"qc-log dump");
00933 
00934 
00935 
00936         uves_msg("iter_max=%d",iter_max);
00937             if(stab_check) {
00938           uves_free_table(&mst_line_table);
00939           uves_free_table(&mst_order_table);
00940           uves_free_table(&mst_mline_table);
00941           uves_polynomial_delete(&mst_absolute_order_poly2d);
00942 
00943           uves_msg("Run the physical model on the Master formatcheck frame");
00944           check(uves_physmod_process_chip(master_formatcheck,
00945                           master_formatcheck_header[raw_index], 
00946                           master_formatcheck_filename,
00947                                               chip,
00948                                               recipe_id,
00949                                               DEBUG,
00950                                               parameters,
00951                                               line_refer,
00952                                               0,  //physmod_shift_x
00953                                               0,  //physmod_shift_y
00954                                               &model_table,
00955                                               &mst_line_table,
00956                                               &mst_order_table,
00957                                               &mst_mline_table,
00958                                               &mst_abs_ord_min,
00959                                               &mst_abs_ord_max,
00960                                               &mst_absolute_order_poly2d,
00961                           stability_cnt),
00962             "Error processing chip");
00963           stability_cnt+=1;            
00964           uves_msg("Stability check");
00965           uves_msg("Using master format check frm '%s'", 
00966                master_formatcheck_filename);
00967           check_nomsg( uves_physmod_stability_check(
00968                             mline_table,
00969                                                         mst_mline_table,
00970                             &med_dx,
00971                                                         &med_dy,
00972                                                         &avg_dx,
00973                                                         &avg_dy) );
00974 
00975 
00976             
00977           uves_physmod_qclog_sc(med_dx,med_dy,avg_dx,avg_dy, 
00978                     raw_header[raw_index],
00979                     master_formatcheck_header[raw_index],
00980                     chip,flames,iter,
00981                     qclog[it+1]);
00982               uves_msg("iter=%d med_dx=%g med_dy=%g",
00983                         iter,fabs(med_dx),fabs(med_dy));
00984               uves_msg("iter=%d max_shift_x=%g max_shift_y=%g",
00985                         iter,max_shift_x,max_shift_y);
00986 
00987 
00988           nordpred=abs_ord_max-abs_ord_min+1;
00989               physmod_shift_x+=med_dx;
00990               physmod_shift_y+=med_dy;
00991 
00992         } // end of stability check
00993       
00994         } // end of iterations
00995          
00996         
00997         /* Finished. Now save the products */
00998         uves_msg("Saving products...");
00999        
01000         
01001         /* QC parameters should go here.
01002            Other mandatory keywords (FITS + dfs) are
01003            automatically added. */
01004 
01005         uves_free_propertylist(&product_header);
01006         uves_free_propertylist(&table_header);
01007         product_header = uves_propertylist_new();
01008         table_header = uves_propertylist_new();
01009         check( uves_pfits_set_traceid     ( table_header, 0),
01010                "Error writing trace ID to product header");
01011         check( uves_pfits_set_windownumber( table_header, 2),
01012                "Error window number to product header");
01013 
01014         check( uves_pfits_set_firstabsorder(table_header, abs_ord_min),
01015                "Error window number to product header");
01016 
01017         check( uves_pfits_set_lastabsorder(table_header, abs_ord_max),
01018                "Error window number to product header");
01019 
01020         check_nomsg(uves_pfits_set_ordpred(product_header,nordpred));
01021 
01022 
01023         if (flames) {
01024             
01025             check_nomsg(uves_flames_pfits_set_newplateid(product_header, 
01026                                                          plate_no));
01027         }
01028 
01029         cpl_free(product_filename);
01030         check(( product_filename = uves_guess_line_table_filename(chip),
01031         uves_frameset_insert(frames,
01032                      line_table,
01033                                      CPL_FRAME_GROUP_PRODUCT,
01034                                      CPL_FRAME_TYPE_TABLE,
01035                                      CPL_FRAME_LEVEL_INTERMEDIATE,
01036                                      product_filename,
01037                                      UVES_GUESS_LINE_TABLE(flames, chip),
01038                                      raw_header[raw_index], 
01039                                      product_header,
01040                                      table_header,
01041                                      parameters,
01042                                      recipe_id,
01043                                      PACKAGE "/" PACKAGE_VERSION,
01044                                      qclog,
01045                                      starttime, 
01046                                      true, 
01047                      0)),
01048           "Could not add line guess table %s to frameset", 
01049           product_filename);
01050                 
01051     /* Save in next extension */
01052         
01053         check( uves_save_polynomial(absolute_order_poly2d, 
01054                     product_filename, table_header),
01055         "Could not write polynomial to file '%s'", product_filename);
01056                
01057         
01058         check( uves_save_polynomial(absolute_order_poly2d, 
01059                     product_filename, table_header), 
01060            "Could not write polynomial to file '%s'", product_filename);
01061             
01062 
01063 
01064         uves_msg("Line table %s added to frameset", product_filename);
01065         
01066         /* Save guess order table, re-use product header */
01067 
01068         cpl_free(product_filename);        
01069         check(( product_filename = uves_guess_order_table_filename(chip),
01070         uves_frameset_insert(frames,
01071                                      order_table,
01072                                      CPL_FRAME_GROUP_PRODUCT,
01073                                      CPL_FRAME_TYPE_TABLE,
01074                                      CPL_FRAME_LEVEL_INTERMEDIATE,
01075                                      product_filename,
01076                                      UVES_GUESS_ORDER_TABLE(flames, chip),
01077                                      raw_header[raw_index],
01078                                      product_header,
01079                                      NULL,
01080                                      parameters,
01081                                      recipe_id,
01082                                      PACKAGE "/" PACKAGE_VERSION,
01083                                      NULL,
01084                                      starttime, 
01085                                      false, 
01086                                      0)), 
01087               "Could not add order guess table %s to frameset", 
01088               product_filename);
01089         
01090         uves_msg("Order guess table %s added to frameset", 
01091                  product_filename);
01092 
01093     for(it=0;it<2*iter_max+1;it++) {
01094       uves_qclog_delete(&qclog[it]);
01095     }
01096 
01097       if(strcmp(PROCESS_CHIP,"redl") == 0) {
01098     chip = uves_chip_get_next(chip);
01099       }
01100 
01101     }/* For each chip */
01102 
01103   cleanup:
01104     for(it=0;it<2*iter_max+1;it++) {
01105       uves_qclog_delete(&qclog[it]);
01106     }
01107    
01108        /* Master bias */
01109     uves_free_image(&master_bias);
01110     uves_free_propertylist(&master_bias_header);
01111 
01112     uves_free_image (&raw_image[0]);
01113     uves_free_image (&raw_image[1]);
01114     uves_free_propertylist(&raw_header[0]);
01115     uves_free_propertylist(&raw_header[1]);
01116     uves_free_propertylist(&rotated_header[0]);
01117     uves_free_propertylist(&rotated_header[1]);
01118 
01119     uves_free_image (&master_formatcheck);
01120     uves_free_propertylist(&master_formatcheck_header[0]);
01121     uves_free_propertylist(&master_formatcheck_header[1]);
01122 
01123     uves_free_table(&model_table);
01124     uves_free_table(&line_table);
01125     uves_free_table(&mst_line_table);
01126     uves_free_table(&order_table);
01127     uves_free_table(&mst_order_table);
01128     uves_free_table(&line_refer);
01129 
01130     uves_free_table(&mline_table);
01131     uves_free_table(&m_mline_table);
01132     uves_free_table(&r_mline_table);
01133     uves_free_table(&mst_mline_table);
01134 
01135     uves_free_propertylist(&product_header);
01136     uves_free_propertylist(&table_header);
01137     uves_polynomial_delete(&absolute_order_poly2d);
01138     uves_polynomial_delete(&mst_absolute_order_poly2d);
01139     cpl_free(product_filename); 
01140           
01141     uves_msg_debug("end %s",__func__);
01142     return;
01143 }
01144 
01145 
01155 static int 
01156 uves_physmod_qclog(cpl_table* line_table,
01157                    cpl_table* order_table,
01158                    cpl_table* qclog,
01159                    const uves_propertylist *raw_header,
01160                    enum uves_chip chip,
01161                    bool flames,
01162                    const int iter,
01163                    const int plate_no)
01164 {
01165   int nlinsel=0;
01166   cpl_table *xline_table=NULL;
01167   char key_value[25];
01168 
01169 
01170   check_nomsg( uves_qclog_add_common_wave(raw_header,
01171                                           chip, qclog) );
01172 
01173 
01174   if(flames) {
01175      ck0_nomsg(uves_qclog_add_string(qclog,
01176                      "QC TEST1 ID",
01177                      "Fibre-Physical-Model-Prediction-Results",
01178                      "Name of QC test",
01179                      "%s"));
01180   } else {
01181      ck0_nomsg(uves_qclog_add_string(qclog,
01182                      "QC TEST1 ID",
01183                      "Physical-Model-Prediction-Results",
01184                      "Name of QC test",
01185                      "%s"));
01186   }
01187   ck0_nomsg(uves_qclog_add_string(qclog,
01188                   "QC MODEL ID",
01189                   "UVES_phys_mod/1.1.0",
01190                   "Physmod Model Id",
01191                   "%s"));
01192 
01193   ck0_nomsg(uves_qclog_add_string(qclog,
01194                   "QC MODEL DATE",
01195                   "2000:03:18T00:00:00.000",
01196                   "Physmod Model Parameters Last Change",
01197                   "%s"));
01198 
01199 
01200   if(flames) {
01201 
01202     sprintf(key_value,"%s%d","QC MODEL ITER",iter);
01203     ck0_nomsg(uves_qclog_add_int(qclog,
01204                  key_value,
01205                  iter,
01206                  "Model iteration",
01207                  "%d"));
01208 
01209     ck0_nomsg(uves_qclog_add_int(qclog,
01210                  "QC MODEL ORDMIN",
01211                  cpl_table_get_column_min(line_table,"Order"),
01212                  "minimum predicted order value",
01213                  "%d"));
01214 
01215     ck0_nomsg(uves_qclog_add_int(qclog,
01216                  "QC MODEL ORDMAX",
01217                  cpl_table_get_column_max(line_table,"Order"),
01218                  "maximum predicted order value",
01219                  "%d"));
01220 
01221 
01222     ck0_nomsg(uves_qclog_add_double(qclog,
01223                  "QC MODEL WLENMIN",
01224                  cpl_table_get_column_min(line_table,"WAVEC")/10.,
01225                  "minimum predicted order value",
01226                  "%f"));
01227 
01228     ck0_nomsg(uves_qclog_add_double(qclog,
01229                  "QC MODEL WLENMAX",
01230                  cpl_table_get_column_max(line_table,"WAVEC")/10.,
01231                  "maximum predicted order value",
01232                  "%f"));
01233 
01234 
01235   } /* in case of flames-uves */
01236 
01237 
01238   ck0_nomsg(uves_qclog_add_int(qclog,
01239                    "QC MODEL NLINALL",
01240                    cpl_table_get_nrow(line_table),
01241                    "Number of predicted lines",
01242                    "%d"));
01243 
01244   check_nomsg(nlinsel=cpl_table_and_selected_int(line_table,"SELPLOT",
01245                                                  CPL_EQUAL_TO,1));
01246   check_nomsg(xline_table=cpl_table_extract_selected(line_table));
01247 
01248   ck0_nomsg(uves_qclog_add_int(qclog,
01249                    "QC MODEL NLINSEL",
01250                    nlinsel,
01251                    "Number of lines selected",
01252                    "%d"));
01253 
01254   if(iter == 1) {
01255      ck0_nomsg(uves_qclog_add_double(qclog,
01256                      "QC MODEL DIFFXRMS",
01257                      cpl_table_get_column_stdev(xline_table,"XDIF"),
01258                      "Std dev of X difference to physical model",
01259                      "%8.4f"));
01260 
01261      ck0_nomsg(uves_qclog_add_double(qclog,
01262                      "QC MODEL DIFFXAVG",
01263                      cpl_table_get_column_mean(xline_table,"XDIF"),
01264                      "Average of X difference to physical model",
01265                      "%8.4f"));
01266 
01267      ck0_nomsg(uves_qclog_add_double(qclog,"QC MODEL DIFFXMED",
01268                      cpl_table_get_column_median(xline_table,"XDIF"),
01269                      "Median of X difference to physical model",
01270                      "%8.4f"));
01271 
01272      ck0_nomsg(uves_qclog_add_double(qclog,
01273                      "QC MODEL DIFFYRMS",
01274                      cpl_table_get_column_stdev(xline_table,"YDIF"),
01275                      "Std dev of Y difference to physical model",
01276                      "%8.4f"));
01277 
01278      ck0_nomsg(uves_qclog_add_double(qclog,
01279                      "QC MODEL DIFFYAVG",
01280                      cpl_table_get_column_mean(xline_table,"YDIF"),
01281                      "Average of Y difference to physical model",
01282                      "%8.4f"));
01283 
01284      ck0_nomsg(uves_qclog_add_double(qclog,"QC MODEL DIFFYMED",
01285                      cpl_table_get_column_median(xline_table,"YDIF"),
01286                      "Median of Y difference to physical model",
01287                      "%8.4f"));
01288   }
01289 
01290   if ( flames == 1 ) {
01291 
01292 
01293        sprintf(key_value,"%s%d","QC MODEL RESXRMS",iter);
01294        ck0_nomsg(uves_qclog_add_double(qclog,
01295                     key_value,
01296                     cpl_table_get_column_stdev(xline_table,"XDIF"),
01297                     "Std dev of X difference to physical model",
01298                     "%8.4f"));
01299 
01300 
01301        sprintf(key_value,"%s%d","QC MODEL RESXAVG",iter);
01302        ck0_nomsg(uves_qclog_add_double(qclog,
01303                     key_value,
01304                     cpl_table_get_column_mean(xline_table,"XDIF"),
01305                     "Average of X difference to physical model",
01306                     "%8.4f"));
01307 
01308        sprintf(key_value,"%s%d","QC MODEL RESXMED",iter);
01309        ck0_nomsg(uves_qclog_add_double(qclog,
01310                     key_value,
01311                     cpl_table_get_column_median(xline_table,"XDIF"),
01312                     "Median of X difference to physical model",
01313                     "%8.4f"));
01314 
01315 
01316 
01317        sprintf(key_value,"%s%d","QC MODEL RESYRMS",iter);
01318        ck0_nomsg(uves_qclog_add_double(qclog,
01319                     key_value,
01320                     cpl_table_get_column_stdev(xline_table,"YDIF"),
01321                     "Std dev of Y difference to physical model",
01322                     "%8.4f"));
01323 
01324 
01325        sprintf(key_value,"%s%d","QC MODEL RESYAVG",iter);
01326        ck0_nomsg(uves_qclog_add_double(qclog,
01327                     key_value,
01328                     cpl_table_get_column_mean(xline_table,"YDIF"),
01329                     "Average of Y difference to physical model",
01330                     "%8.4f"));
01331 
01332        sprintf(key_value,"%s%d","QC MODEL RESYMED",iter);
01333        ck0_nomsg(uves_qclog_add_double(qclog,
01334                     key_value,
01335                     cpl_table_get_column_median(xline_table,"YDIF"),
01336                     "Median of Y difference to physical model",
01337                     "%8.4f"));
01338 
01339 
01340   }
01341 
01342 
01343 
01344 
01345 
01346   cpl_table_unselect_all(line_table);
01347 
01348   /* we divide by 10 as line_table contains values in Angstrom and we want
01349      nanometers */
01350   ck0_nomsg(uves_qclog_add_double(qclog,
01351                   "QC MODEL WLENMIN",
01352                   cpl_table_get_column_min(xline_table,"WAVEC")/10.,
01353                   "minimum predicted wavelength value",
01354                   "%8.4f"));
01355 
01356  ck0_nomsg(uves_qclog_add_double(qclog,
01357                  "QC MODEL WLENMAX",
01358                  cpl_table_get_column_max(xline_table,"WAVEC")/10.,
01359                  "maximum predicted wavelength value",
01360                  "%8.4f"));
01361 
01362 
01363   ck0_nomsg(uves_qclog_add_int(qclog,
01364                    "QC MODEL ORDMIN",
01365                    (int)cpl_table_get_column_min(xline_table,"Order"),
01366                    "minimum predicted order value",
01367                    "%d"));
01368 
01369   ck0_nomsg(uves_qclog_add_int(qclog,
01370                    "QC MODEL ORDMAX",
01371                    (int)cpl_table_get_column_max(xline_table,"Order"),
01372                    "maximum predicted order value",
01373                    "%d"));
01374 
01375 
01376  
01377   /* we divide by 10 as line_table contains values in Angstrom and we want
01378      nanometers */
01379   ck0_nomsg(uves_qclog_add_double(qclog,
01380                   "QC WLENMIN",
01381                   cpl_table_get_column_min(line_table,"WAVEC")/10.,
01382                   "minimum wavelength",
01383                   "%8.4f"));
01384 
01385   ck0_nomsg(uves_qclog_add_double(qclog,
01386                   "QC WLENMAX",
01387                   cpl_table_get_column_max(line_table,"WAVEC")/10.,
01388                   "maximum wavelength",
01389                   "%8.4f"));
01390   
01391   ck0_nomsg(uves_qclog_add_int(qclog,
01392                    "QC ORDMIN",
01393                    cpl_table_get_column_min(order_table,"ORDER"),
01394                    "minimum order number",
01395                    "%d"));
01396 
01397   ck0_nomsg(uves_qclog_add_int(qclog,
01398                    "QC ORDMAX",
01399                    cpl_table_get_column_max(order_table,"ORDER"),
01400                    "maximum order number",
01401                    "%d"));
01402   
01403 
01404   if (flames) {
01405     /*
01406 stat/ima {wlc} {SESSOUTV}
01407 tot_int = outputr(7)
01408 exp_time = {{wlc},{h_dit1}}
01409 rel_int = tot_int / exp_time
01410     */
01411 
01412      ck0_nomsg(uves_qclog_add_double(qclog,
01413                   "QC FIB1 ABSTRANS",
01414                   cpl_table_get_column_max(order_table,"ORDER"),
01415                   "abs. trans. countrate",
01416                   "%f"));
01417      /*
01418 @p flames_check_sat_lev {wlc} {DRS_PTHRE_MIN} {DRS_PTHRE_MAX}
01419 sat_lev = {q1}
01420 n_hpix  = {q2}
01421      */
01422 
01423     ck0_nomsg(uves_qclog_add_int(qclog,
01424                  "QC NHOTPIX",
01425                  cpl_table_get_column_max(order_table,"ORDER"),
01426                  "no. of hot pixels",
01427                  "%d"));
01428 
01429 
01430     ck0_nomsg(uves_qclog_add_int(qclog,
01431                  "QC PLATENO",
01432                  plate_no,
01433                  "Plate Id.",
01434                  "%d"));
01435   }
01436 
01437   /* The number of orders predicted is already written to another
01438      keyword, and this is not need for QC logging, so it is commented out
01439   uves_qclog_add_int(qclog,"QC NORDGUE",???,"No of predicted orders","%d");
01440   */
01441 
01442  cleanup:
01443   uves_free_table(&xline_table);
01444 
01445   if (cpl_error_get_code() != CPL_ERROR_NONE) {
01446     return -1;
01447   } else {
01448     return 0;
01449   }
01450 
01451 
01452 
01453 }
01454 
01455 
01456 
01457 
01467 static int 
01468 uves_physmod_qclog_sc(const double med_dx, 
01469                       const double med_dy,
01470                       const double avg_dx,
01471                       const double avg_dy,
01472                       const uves_propertylist *raw_header,
01473                       const uves_propertylist *ref_header,
01474                       enum  uves_chip chip,
01475                       bool flames,
01476                       const int iter,
01477                       cpl_table* qclog)
01478 {
01479 
01480   char key_value[25];
01481 
01482     if(flames) {
01483         ck0_nomsg(uves_qclog_add_string(qclog,
01484                     "QC TEST2 ID",
01485                     "Fibre-Stability-Check-Results",
01486                     "Name of QC test",
01487                         "%s"));
01488     } else {
01489         ck0_nomsg(uves_qclog_add_string(qclog,
01490                     "QC TEST2 ID",
01491                     "Stability-Check-Results",
01492                     "Name of QC test",
01493                     "%s"));
01494     }
01495     
01496     ck0_nomsg(uves_qclog_add_string(qclog,
01497               "QC MODEL ID",
01498               "UVES_phys_mod/1.1.0",
01499               "Physmod Model Id",
01500               "%s"));
01501     
01502     ck0_nomsg(uves_qclog_add_string(qclog,
01503               "QC MODEL DATE",
01504               "2000:03:18T00:00:00.000",
01505               "Physmod Model Parameters Last Change",
01506               "%s"));
01507 
01508     check_nomsg( uves_qclog_add_common_wave(raw_header,
01509                                             chip, qclog) );
01510     
01511 
01512     ck0_nomsg(uves_qclog_add_string(qclog,
01513               "QC REF PNAME",
01514               uves_pfits_get_arcfile(ref_header),
01515               "Reference file name",
01516               "%s"));
01517 
01518     ck0_nomsg(uves_qclog_add_double(qclog,
01519               "QC AMBI PRES",
01520               uves_pfits_get_ambipress(raw_header),
01521               "Ambient pressure [mm] Hg.",
01522               "%8.4f"));
01523 
01524 
01525     if(flames) {
01526 
01527        sprintf(key_value,"%s%d","QC MODEL ITER",iter);
01528        ck0_nomsg(uves_qclog_add_int(qclog,
01529                  key_value,
01530                  iter,
01531                  "Model iteration",
01532                  "%d"));
01533 
01534 
01535     }
01536 
01537   if(iter == 1) {
01538     ck0_nomsg(uves_qclog_add_double(qclog,
01539               "QC SHFTXAVG",
01540               avg_dx,
01541               "mean shift in x",
01542               "%8.4f"));
01543 
01544     ck0_nomsg(uves_qclog_add_double(qclog,
01545               "QC SHFTXMED",
01546               med_dx,
01547               "median shift in x",
01548               "%8.4f"));
01549 
01550     ck0_nomsg(uves_qclog_add_double(qclog,
01551               "QC SHFTYAVG",
01552               avg_dy,
01553               "mean shift in y",
01554               "%8.4f"));
01555 
01556     ck0_nomsg(uves_qclog_add_double(qclog,
01557               "QC SHFTYMED",
01558               med_dy,
01559               "median shift in y",
01560               "%8.4f"));
01561 
01562   }
01563  cleanup:
01564 
01565   if (cpl_error_get_code() != CPL_ERROR_NONE) {
01566     return -1;
01567   } else {
01568     return 0;
01569   }
01570 }
01571 
01572 

Generated on Thu Nov 15 14:32:29 2007 for UVES Pipeline Reference Manual by  doxygen 1.5.1