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

Generated on Fri Apr 18 14:11:42 2008 for UVES Pipeline Reference Manual by  doxygen 1.5.1