xsh_util_genconfig.c

Go to the documentation of this file.

/* $Id: xsh_util_genconfig.c,v 1.10 2011-12-02 14:15:46 amodigli Exp $
 *
 *   This file is part of the ESO X-shooter Pipeline                          
 *   Copyright (C) 2006 European Southern Observatory  
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
/*
 * $Author: amodigli $
 * $Date: 2011-12-02 14:15:46 $
 * $Revision: 1.10 $
 * $Name: not supported by cvs2svn $
 */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------
                                Includes
 -----------------------------------------------------------------------------*/
 
#include <cpl.h>
 
#include "xsh_utils.h"
#include "xsh_pfits.h"
#include "xsh_dfs.h"
 
/*-----------------------------------------------------------------------------
                            Functions prototypes
 -----------------------------------------------------------------------------*/
 
static int xsh_util_genconfig_create(cpl_plugin *);
static int xsh_util_genconfig_exec(cpl_plugin *);
static int xsh_util_genconfig_destroy(cpl_plugin *);
static int xsh_util_genconfig(cpl_parameterlist *, cpl_frameset *);
static int xsh_util_genconfig_save(cpl_table *, cpl_parameterlist *, 
        cpl_frameset *);
 
/*-----------------------------------------------------------------------------
                            Static variables
 -----------------------------------------------------------------------------*/
 
static char xsh_util_genconfig_description[] =
"This recipe is used to generate the model configuration file.\n"
"The sof file contains the names of the input ASCII file\n"
"tagged with "XSH_UTIL_GENCONFIG_RAW".\n"
"The ASCII file must contain five columns:\n"
"1st: The best guess value\n"
"2nd: The low limit\n"
"3th: The high limit\n"
"4th: The Flag to recompute or not\n"
"5th: Name of the Parameter\n"
"The ASCII files are in the catalogs/ directory of the XSH distribution.\n"
"This recipe produces 1 file:\n"
"First product:     the table with the configuration for the model.\n"
"                   (PRO CATG = XSH_MOD_CFG_TAB_ARM)\n" ;
 
/*-----------------------------------------------------------------------------
                                Functions code
 -----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
int cpl_plugin_get_info(cpl_pluginlist * list)
{
    cpl_recipe  *   recipe = cpl_calloc(1, sizeof(*recipe));
    cpl_plugin  *   plugin = &recipe->interface;
 
    cpl_plugin_init(plugin,
                    CPL_PLUGIN_API,
                    XSH_BINARY_VERSION,
                    CPL_PLUGIN_TYPE_RECIPE,
                    "xsh_util_genconfig",
                    "Generate spectrum calibration FITS tables",
                    xsh_util_genconfig_description,
                    "Yves Jung",
                    "yjung@eso.org",
                    xsh_get_license(),
                    xsh_util_genconfig_create,
                    xsh_util_genconfig_exec,
                    xsh_util_genconfig_destroy);
 
    cpl_pluginlist_append(list, plugin);
    
    return 0 ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
static int xsh_util_genconfig_create(cpl_plugin * plugin)
{
    cpl_recipe      * recipe ;
 
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
 
    /* Create the parameters list in the cpl_recipe object */
    recipe->parameters = cpl_parameterlist_new() ;
 
    return 0 ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
static int xsh_util_genconfig_exec(cpl_plugin * plugin)
{
    cpl_recipe  *   recipe ;
 
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
 
    return xsh_util_genconfig(recipe->parameters, recipe->frames) ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
static int xsh_util_genconfig_destroy(cpl_plugin * plugin)
{
    cpl_recipe  *   recipe ;
 
    /* Get the recipe out of the plugin */
    if (cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE)
        recipe = (cpl_recipe *)plugin ;
    else return -1 ;
 
    cpl_parameterlist_delete(recipe->parameters) ;
    return 0 ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
static int xsh_util_genconfig(
        cpl_parameterlist   *   parlist,
        cpl_frameset        *   framelist)
{
    FILE            *   in ;
    char                line[1024];
    cpl_frame       *   cur_frame ;
    const char      *   cur_fname ;
    int                 nentries ;
    char                name[1024] ;
    double              best, low, high ;
    int                 flag ;
    cpl_table       *   tab ;
    int                 i ;
 
    /* Identify the RAW and CALIB frames in the input frameset 
    if (xsh_dfs_set_groups(framelist)) {
        cpl_msg_error(__func__, "Cannot identify RAW and CALIB frames") ;
        return -1 ;
    }*/
  
    /* Get the config file name */
    cur_frame = cpl_frameset_get_frame(framelist, 0) ;
    cur_fname = cpl_frame_get_filename(cur_frame) ;
 
    /* Open the file */
    if ((in = fopen(cur_fname, "r")) == NULL) {
        cpl_msg_error(__func__, "Could not open %s", cur_fname) ;
        return -1 ;
    }
 
    /* Count number of entries */
    nentries = 0 ;
    while (fgets(line, 1024, in) != NULL) {
        /* Note: update the string format (the %__s) if name changes size.
         * Remember: field width must equal 1 less than sizeof(name). */
        if (line[0] != '#' && sscanf(line, "%64lg %64lg %64lg %64d %1023s", 
                    &best, &low, &high, &flag, name) == 5)  nentries++ ;
    }
    if (nentries == 0) {
        cpl_msg_error(__func__, "No valid entry in the file") ;
        fclose(in) ;
        return -1 ;
    }
        
    /* Create the output table */
    tab = cpl_table_new(nentries) ;
    cpl_table_new_column(tab, XSH_COL_MODEL_CONF_BEST, CPL_TYPE_DOUBLE) ;
    cpl_table_new_column(tab, XSH_COL_MODEL_CONF_LOW, CPL_TYPE_DOUBLE) ;
    cpl_table_new_column(tab, XSH_COL_MODEL_CONF_HIGH, CPL_TYPE_DOUBLE) ;
    cpl_table_new_column(tab, XSH_COL_MODEL_CONF_FLAG, CPL_TYPE_INT) ;
    cpl_table_new_column(tab, XSH_COL_MODEL_CONF_NAME, CPL_TYPE_STRING) ;
    
    /* Fill the table */
    i = 0 ;
    rewind(in) ;
    while (fgets(line, 1024, in) != NULL) {
        if (line[0] != '#' && sscanf(line, "%64lg %64lg %64lg %64d %1023s", 
                    &best, &low, &high, &flag, name) == 5) {
            cpl_table_set_string(tab, XSH_COL_MODEL_CONF_NAME, i, name) ;
            cpl_table_set_double(tab, XSH_COL_MODEL_CONF_BEST, i, best) ;
            cpl_table_set_double(tab, XSH_COL_MODEL_CONF_LOW, i, low) ;
            cpl_table_set_double(tab, XSH_COL_MODEL_CONF_HIGH, i, high) ;
            cpl_table_set_int(tab, XSH_COL_MODEL_CONF_FLAG, i, flag) ;
            i++ ;
        }
    }
    fclose(in) ;
   
    /* Save the table */
    cpl_msg_info(__func__, "Saving the table with %d rows", nentries) ;
    if (xsh_util_genconfig_save(tab, parlist, framelist) == -1) {
        cpl_msg_error(__func__, "Cannot write the table") ;
        cpl_table_delete(tab) ;
        return -1 ;
    }
    cpl_table_delete(tab) ;
    return 0 ;
}
 
/*----------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_util_genconfig_save(
        cpl_table           *   out_table,
        cpl_parameterlist   *   parlist,
        cpl_frameset        *   set)
{
    char                    name_o[512] ;
    cpl_propertylist    *   plist ;
    cpl_frame           *   product_frame ;
 
    /* Get the reference frame 
       ref_frame = irplib_frameset_get_first_from_group(set, 
                                                        CPL_FRAME_GROUP_RAW) ;
     */
 
    /* Set the file name */
    sprintf(name_o, "xsh_util_genconfig_save.fits") ;
    cpl_msg_info(__func__, "Writing %s" , name_o) ;
 
    /* Get FITS header from reference file */
    plist = cpl_propertylist_new();
    cpl_propertylist_append_string(plist, "INSTRUME", "XSH") ;
            
    /* Create product frame */
    product_frame = cpl_frame_new() ;
    cpl_frame_set_filename(product_frame, name_o) ;
    cpl_frame_set_tag(product_frame, XSH_MOD_CFG) ;
    cpl_frame_set_type(product_frame, CPL_FRAME_TYPE_TABLE);
    cpl_frame_set_group(product_frame, CPL_FRAME_GROUP_PRODUCT);
    cpl_frame_set_level(product_frame, CPL_FRAME_LEVEL_FINAL);
 
    /* Add DataFlow keywords */
    if (cpl_dfs_setup_product_header(plist, product_frame, set, parlist,
            "xsh_util_genconfig", PACKAGE "/" PACKAGE_VERSION,
                                     "PRO-1.15",NULL)!=CPL_ERROR_NONE) {
        cpl_msg_warning(__func__, "Problem in the product DFS-compliance") ;
        cpl_error_reset() ;
    }
 
    /* Save the file */
    if (cpl_table_save(out_table, plist, NULL, name_o,
                CPL_IO_DEFAULT) != CPL_ERROR_NONE) {
        cpl_msg_error(__func__, "Cannot save the product");
        cpl_frame_delete(product_frame) ;
        cpl_propertylist_delete(plist) ;
        return -1 ;
    }
    cpl_propertylist_delete(plist) ;
 
    /* Log the saved file in the input frameset */
    cpl_frameset_insert(set, product_frame);
    /* Return */
    return 0 ;
}