xsh_model_anneal.c

Go to the documentation of this file.

/* $Id: xsh_model_anneal.c,v 1.20 2011-12-02 14:15:46 amodigli Exp $
 *
 * This file is part of the XSH Pipeline
 * Copyright (C) 2002,2003 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.20 $
 * $Name: not supported by cvs2svn $
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------
  Includes
  ---------------------------------------------------------------------------*/
 
#include <cpl.h>
#include <math.h>
 
#include <stdlib.h>
#include <stdio.h> 
#include <string.h> 
 
#include <xsh_model_anneal.h>
#include <xsh_dfs.h>
#include <xsh_utils.h>
#include <xsh_pfits.h>
#include <xsh_msg.h>
#include <xsh_error.h>
 
/*-----------------------------------------------------------------------------
  Functions prototypes
  ---------------------------------------------------------------------------*/
 
static int xsh_model_anneal_create(cpl_plugin *) ;
static int xsh_model_anneal_exec(cpl_plugin *) ;
static int xsh_model_anneal_destroy(cpl_plugin *) ;
static int xsh_model_anneal(cpl_parameterlist *, cpl_frameset *) ;
static int xsh_model_anneal_save(const cpl_table *, cpl_parameterlist *, 
                                 cpl_frameset *) ;
 
/*-----------------------------------------------------------------------------
  Static variables
  ---------------------------------------------------------------------------*/
 
static char xsh_model_anneal_description[] =
   "This recipe is for development use only.\n";
static char xsh_model_anneal_description_short[] =
"Compute optimum config given wavelengths and observed detected positions";
/*-----------------------------------------------------------------------------
  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_model_anneal",
                   xsh_model_anneal_description_short,
                   xsh_model_anneal_description,
                   "Paul Bristow",
                   "bristowp@eso.org",
                   xsh_get_license(),
                   xsh_model_anneal_create,
                   xsh_model_anneal_exec,
                   xsh_model_anneal_destroy) ;
 
   cpl_pluginlist_append(list, plugin) ;
    
   return 0;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_model_anneal_create(cpl_plugin * plugin)
{
   cpl_recipe      * recipe ;
   cpl_parameter * p=NULL;
 
   /* Reset library state */
   xsh_init();
 
  /* Check input */
  assure( plugin != NULL, CPL_ERROR_NULL_INPUT, "Null plugin");
 
 
   /* Check that the plugin is part of a valid recipe */
   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() ; 
 
   p = cpl_parameter_new_enum("xsh.xsh_model_compute.arm",
                              CPL_TYPE_STRING,
                              "Arm setting: ",
                              "xsh.xsh_model_compute",
                              "vis",
                              3,"uvb","vis","nir");
 
   cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI,"arm");
   cpl_parameterlist_append(recipe->parameters, p);
 
 cleanup:
 
   /* Return */
   return 0;
}
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_model_anneal_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_model_anneal(recipe->parameters, recipe->frames) ;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_model_anneal_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_model_anneal(
   cpl_parameterlist*   parlist, 
   cpl_frameset*   frameset)
{
   cpl_frame*   xs_config ;
   //cpl_frame*   resid_frame ;
   cpl_frame*   meas_coord ;
   //cpl_frame*   new_config_frame;
   cpl_table*   config_table ;
   cpl_parameter* param=NULL;
   xsh_instrument* instrument = NULL;
   const char* arm=NULL;
   int nraw=0;
 
   /* Identify the RAW and CALIB frames in the input frameset 
      if (xsh_dfs_set_groups(frameset)) {
      cpl_msg_error(__func__, "Cannot identify RAW and CALIB frames") ;
      return -1 ;
      }*/
 
   if( (nraw=cpl_frameset_get_size(frameset)) ==0) goto cleanup;
 
   param = cpl_parameterlist_find(parlist,"xsh.xsh_model_compute.arm");
 
   arm = cpl_parameter_get_string(param);
 
   instrument=xsh_instrument_new();
   if(strcmp(arm,"uvb") == 0) xsh_instrument_set_arm(instrument,XSH_ARM_UVB);
   if(strcmp(arm,"vis") == 0) xsh_instrument_set_arm(instrument,XSH_ARM_VIS);
   if(strcmp(arm,"nir") == 0) xsh_instrument_set_arm(instrument,XSH_ARM_NIR);
 
   /* Retrieve calibration data */
   check(xs_config  = xsh_find_calpro_model_config(frameset,instrument)) ;
   check(meas_coord  = xsh_find_calpro_model_meas_coord(frameset,instrument)) ;
 
 
/* /\*Test pipe anneal function BEGIN*\/ */
/* struct xs_3 xs_3_config; */
/* struct xs_3* p_xs_3_config; */
/* p_xs_3_config=&xs_3_config; */
/* resid_frame = cpl_frameset_find(frameset, XSH_MEASCOORD); */
/* if (xsh_model_config_load_best(xs_config, p_xs_3_config) == -1) { */
/*    cpl_msg_error(__func__, "Cannot load %s as a config", */
/*    cpl_frame_get_filename(xs_config)) ; */
/*    return -1 ; */
/* } */
 
/* new_config_frame = xsh_model_pipe_anneal(xs_config, */
/*                       resid_frame, */
/*                       200); */
/* double x,y; */
/* xsh_model_get_xy(p_xs_3_config,1,750.0,22,0.0,&x,&y); */
/* printf("750nm in order 22 on arm %d : x=%lf y=%lf \n",
   xsh_instrument_get_arm(1),x,y); */
 
/* xsh_msg("new config_frame %s %s", 
           cpl_frame_get_tag(new_config_frame),
           cpl_frame_get_filename(new_config_frame)); */
 
/* exit(-1); */
/* /\*Test pipe anneal function END*\/ */
 
   /* Apply the computation here */
   if ((config_table = xsh_model_anneal_reduce(
           cpl_frame_get_filename(xs_config),
           cpl_frame_get_tag(xs_config),
           cpl_frame_get_filename(meas_coord))) == NULL) {
      cpl_msg_error(__func__, "Failed computing the model") ;
      return -1 ;
   }
 
 
   /* Save the result */
   cpl_msg_info(__func__, "Save the products") ;
   cpl_msg_indent_more() ;
   if (xsh_model_anneal_save((const cpl_table*)config_table, parlist, 
                             frameset) == -1) {
      cpl_msg_error(__func__, "Cannot save products") ;
      cpl_msg_indent_less() ;
      cpl_table_delete(config_table) ;
      return -1 ;
   }
   cpl_table_delete(config_table) ;
   cpl_msg_indent_less() ;
 
  cleanup:
   xsh_instrument_free(&instrument);
 
   /* Return */
   if (cpl_error_get_code()) 
      return -1 ;
   else 
      return 0 ;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
static int xsh_model_anneal_save(
   const 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_model_anneal_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") ;
   cpl_propertylist_append_int(plist,"Num_pinh",9);
 
 
   /* 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_model_anneal", 
                                    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 ;
}