xsh_molecfit_telluric.c

Go to the documentation of this file.

/*
 * This file is part of the ESO X-Shooter Pipeline
 * Copyright (C) 2001-2018 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/* xshooter headers */
#include <xsh_error.h>
#include <xsh_utils.h>
 
/* Molecfit Model */
#include "xsh_molecfit_telluric.h"
#include <mf_wrap_config.h>
#include <telluriccorr.h>
//#include <mf_spectrum.h>
//#include <mf_wrap.h>
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------
                             Recipe Defines
 ---------------------------------------------------------------------------*/
 
#define RECIPE_ID "xsh_molecfit_telluric"
#define RECIPE_AUTHOR "N. Fernando, B. Miszalski"
#define RECIPE_CONTACT "nuwanthika.fernando@partner.eso.org"
 
/*---------------------------------------------------------------------------
                            Functions prototypes
 ---------------------------------------------------------------------------*/
 
/*
 *   Plugin initalization, execute and cleanup handlers
 */
 
int xsh_molecfit_telluric_create(cpl_plugin *);
int xsh_molecfit_telluric_exec(cpl_plugin *);
int xsh_molecfit_telluric_destroy(cpl_plugin *);
 
/* The actual executor function */
int xsh_molecfit_telluric(cpl_frameset *frameset, const cpl_parameterlist  *parlist);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
char xsh_molecfit_telluric_description_short[] =
"Normalize the reduced telluric spectrum by its continuum.";
 
char xsh_molecfit_telluric_description[] =
"Normalize the reduced telluric 1D spectrum by its continuum to compute the atmosperic telluric correction to feed to xshooter_molecfit_correct.";
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
int cpl_plugin_get_info(cpl_pluginlist *list) {
  cpl_recipe *recipe = NULL;
  cpl_plugin *plugin = NULL;
 
  recipe = cpl_calloc(1, sizeof(*recipe));
  if ( recipe == NULL ){
    return -1;
  }
 
  plugin = &recipe->interface ;
 
  cpl_plugin_init(plugin,
                  CPL_PLUGIN_API,                   /* Plugin API */
                  XSH_BINARY_VERSION,            /* Plugin version */
                  CPL_PLUGIN_TYPE_RECIPE,           /* Plugin type */
                  RECIPE_ID,                        /* Plugin name */
                  xsh_molecfit_telluric_description_short, /* Short help */
                  xsh_molecfit_telluric_description,   /* Detailed help */
                  RECIPE_AUTHOR,                    /* Author name */
                  RECIPE_CONTACT,                   /* Contact address */
                  xsh_get_license(),                /* Copyright */
                  xsh_molecfit_telluric_create,
                  xsh_molecfit_telluric_exec,
                  xsh_molecfit_telluric_destroy);
 
  cpl_pluginlist_append(list, plugin);
 
  return (cpl_error_get_code() != CPL_ERROR_NONE);
 }
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
int xsh_molecfit_telluric_create(cpl_plugin *plugin){
  cpl_recipe *recipe = NULL;
  /*xsh_clipping_param detarc_clip_param =  {2.0, 0, 0.7, 0, 0.3};
  xsh_detect_arclines_param detarc_param =
  {6, 3, 0, 5, 4, 1, 5, 5.0,
    XSH_GAUSSIAN_METHOD, FALSE};
  xsh_dispersol_param dispsol_param = { 4, 5 } ; 
  char paramname[256];
  cpl_parameter* p=NULL;
  int ival=DECODE_BP_FLAG_DEF;
  */
 
  /* Reset library state */
  xsh_init();
 
  /* Check input */
  assure( plugin != NULL, CPL_ERROR_NULL_INPUT, "Null plugin");
 
  /* Get the recipe out of the plugin */
  assure( cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE,
          CPL_ERROR_TYPE_MISMATCH,
          "Plugin is not a recipe");
 
  recipe = (cpl_recipe *)plugin;
 
  /* Create the parameter list in the cpl_recipe object */
  recipe->parameters = cpl_parameterlist_new();
  assure( recipe->parameters != NULL,
          CPL_ERROR_ILLEGAL_OUTPUT,
          "Memory allocation failed!");
 
  //xsh_molecfit_telluric parameters
 
  //column_wave
  check(xsh_parameters_new_string(recipe->parameters,RECIPE_ID,
  "COLUMN_WAVE","WAVE",
  "Name of the column in the input that identifies the wavelength. This parameter has effect only for inputs in binary table format."));
   
  //column_flux
  check(xsh_parameters_new_string(recipe->parameters,RECIPE_ID,
  "COLUMN_FLUX","FLUX",
  "Name of the column in the input that identifies the flux. This parameter has effect only for inputs in binary table format."));
 
  //column_dflux
  check(xsh_parameters_new_string(recipe->parameters,RECIPE_ID,
  "COLUMN_DFLUX","ERR",
  "Name of the column in the input that identifies the flux errors. This parameter has effect only for inputs in binary table format."));
 
  //nodes
  check(xsh_parameters_new_string(recipe->parameters,RECIPE_ID,
  "NODES","30",
  "If a list of entries, it specifies the position (in microns) of the nodes to be used to compute the continuum. If a single entry, it specifies the number of equispaced nodes to be calculated."));
 
  //method 
  check(xsh_parameters_new_string(recipe->parameters,RECIPE_ID,
  "METHOD","spline",
  "Specifies the method to determine the continuum. Valid entries are `spline' (cubic spline), or `poly' (polynomial fit)."));
 
  //degree
  check(xsh_parameters_new_int(recipe->parameters,RECIPE_ID,
  "DEGREE",2,
  "Degree of polynomium to fit the continuum in the case --method=poly"));
 
  //half_width
  check(xsh_parameters_new_double(recipe->parameters,RECIPE_ID,
  "HALF_WIDTH",10.0,
  "Semi-width of the nodes in pixels."));
 
  cleanup:
    if ( cpl_error_get_code() != CPL_ERROR_NONE ){
      xsh_error_dump(CPL_MSG_ERROR);
      return 1;
    }
    else {
      return 0;
    }
}
 
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
int xsh_molecfit_telluric_exec(cpl_plugin *plugin) {
  cpl_recipe *recipe = NULL;
 
  /* Check parameter */
  assure( plugin != NULL, CPL_ERROR_NULL_INPUT, "Null plugin" );
 
  /* Get the recipe out of the plugin */
  assure( cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE,
          CPL_ERROR_TYPE_MISMATCH, "Plugin is not a recipe");
 
  recipe = (cpl_recipe *)plugin;
  /* Check recipe */
  xsh_molecfit_telluric( recipe->frames, recipe->parameters);
 
  cleanup:
    if ( cpl_error_get_code() != CPL_ERROR_NONE ) {
      xsh_error_dump(CPL_MSG_ERROR);
      cpl_error_reset();
      return 1;
    }
    else {
      return 0;
    }
}
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
int xsh_molecfit_telluric_destroy(cpl_plugin *plugin)
{
    cpl_recipe *recipe = NULL;
 
    /* Check parameter */
    assure( plugin != NULL, CPL_ERROR_NULL_INPUT, "Null plugin" );
 
    /* Get the recipe out of the plugin */
    assure( cpl_plugin_get_type(plugin) == CPL_PLUGIN_TYPE_RECIPE,
            CPL_ERROR_TYPE_MISMATCH, "Plugin is not a recipe");
 
    recipe = (cpl_recipe *)plugin;
 
    xsh_free_parameterlist(&recipe->parameters);
 
  cleanup:
    if (cpl_error_get_code() != CPL_ERROR_NONE)
        {
            return 1;
        }
    else
        {
            return 0;
        }
}
 
/*cpl_error_code xsh_molecfit_setup_frameset(cpl_frameset* frameset,cpl_parameterlist* list,const char* arm,const char* input_name){
 
      const char* tag;
      //check the input frame (SCIENCE); we know the tag already thanks to the input_name parameter
      //so no need to search frameset for it
      //input_name may be one of the following:
      //SCI_SLIT_FLUX_IDP_XXX 
      //SCI_SLIT_FLUX_MERGE1D_XXX
      //TELL_SLIT_MERGE1D_XXX
      //TELL_SLIT_FLUX_MERGE1D_XXX
      //STD_SLIT_FLUX_IDP_YYY_XXX
      //where XXX is the arm and YYY is NOD, STARE or OFFSET
 
      tag = input_name;
      cpl_frame* f = cpl_frameset_find(frameset,input_name);
      cpl_frame_set_group(f,CPL_FRAME_GROUP_RAW);
 
      //cpl_frame_set_type(f,CPL_FRAME_TYPE_NONE);
      //cpl_frame_set_tag(f,"SCIENCE");
      //cpl_frame_set_level(f,CPL_FRAME_LEVEL_NONE);
 
      //other inputs 
 
      //KERNEL_LIBRARY_XXX
      tag = cpl_sprintf("%s_%s",MOLECFIT_KERNEL_LIBRARY,arm);
      f = cpl_frameset_find(frameset,tag);
      if(f){
            cpl_frame_set_group(f, CPL_FRAME_GROUP_CALIB);
      }
      //GDAS_XXX
      tag = cpl_sprintf("%s_%s",MOLECFIT_GDAS,arm);
      f = cpl_frameset_find(frameset,tag);
      if(f){
            cpl_frame_set_group(f, CPL_FRAME_GROUP_CALIB);
      } 
      //WAVE_INCLUDE_XXX
      tag = cpl_sprintf("%s_%s",MOLECFIT_WAVE_INCLUDE,arm);
      f = cpl_frameset_find(frameset,tag);
      if(f){
            cpl_frame_set_group(f, CPL_FRAME_GROUP_CALIB);
      } 
      //WAVE_EXCLUDE_XXX
      tag = cpl_sprintf("%s_%s",MOLECFIT_WAVE_EXCLUDE,arm);
      f = cpl_frameset_find(frameset,tag);
      if(f){
            cpl_frame_set_group(f, CPL_FRAME_GROUP_CALIB);
      }
      //PIX_EXCLUDE_XXX
      tag = cpl_sprintf("%s_%s",MOLECFIT_PIXEL_EXCLUDE,arm);
      f = cpl_frameset_find(frameset,tag);
      if(f){
            cpl_frame_set_group(f, CPL_FRAME_GROUP_CALIB);
      }
      //MOLECULES_XXX
      tag = cpl_sprintf("%s_%s",MOLECFIT_MOLECULES,arm);
      f = cpl_frameset_find(frameset,tag);
      if(f){
            cpl_frame_set_group(f, CPL_FRAME_GROUP_CALIB);
      }
      //ATM_PROFILE_STANDARD_XXX
      tag = cpl_sprintf("%s_%s",MOLECFIT_ATM_PROFILE_STANDARD,arm);
      f = cpl_frameset_find(frameset,tag);
      if(f){
            cpl_frame_set_group(f, CPL_FRAME_GROUP_CALIB);
      }
      //ATM_PROFILE_COMBINED_XXX
      tag = cpl_sprintf("%s_%s",MOLECFIT_ATM_PROFILE_COMBINED,arm);
      f = cpl_frameset_find(frameset,tag);
      if(f){
            cpl_frame_set_group(f, CPL_FRAME_GROUP_CALIB);
      }
}
*/
 
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
/*Instrument sid- example instrument - XSHOOTER?*/
int xsh_molecfit_telluric(cpl_frameset *frameset, const cpl_parameterlist  *parlist)
{
    cpl_msg_info(cpl_func,"xsh_molecfit_telluric");
    //TODO: cpl_errorstate_ensure NOT DEFINED???
 
    //cpl_errorstate_ensure(frameset && parlist, CPL_ERROR_NULL_INPUT, return, CPL_ERROR_NULL_INPUT, 'NULL input: framset and/or parlist');
    cpl_error_code err= CPL_ERROR_NONE;
    cpl_errorstate initial_errorstate = cpl_errorstate_get();
 
    //INPUT FRAMES WILL BE NAMED DIFFERENT TO MOLECFIT_SCIENCE, MOLECFIT_STD* etc.
    //TODO: implement xsh_check_and_set_input_tags (if needed?)
    //err = xsh_check_and_set_input_tags(frameset); //INSTRUMENT_SPECIFIC
    //cpl_boolean* science_data_is_table;
 
    //err = mf_wrap_preconfig_check(frameset, parlist,science_data_is_table);/*Check parameters and frameset for correct inputs - returns CPL_ERROR*/
 
    //cpl_parameterlist* ilist = cpl_parameterlist_new();
    //cpl_parameterlist* iframelist = cpl_parameterlist_new();
    //cpl_parameterlist_dump(parlist,stdout);
    //since this is a relatively simple recipe, get the parameters from the parlist...
    const char* col_wave = cpl_parameter_get_string(cpl_parameterlist_find(parlist,"COLUMN_WAVE"));
    const char* col_flux = cpl_parameter_get_string(cpl_parameterlist_find(parlist,"COLUMN_FLUX"));
    const char* col_dflux = cpl_parameter_get_string(cpl_parameterlist_find(parlist,"COLUMN_DFLUX"));
    const char* nodes = cpl_parameter_get_string(cpl_parameterlist_find(parlist,"NODES"));
    const char* method= cpl_parameter_get_string(cpl_parameterlist_find(parlist,"METHOD"));
    int degree_poly = cpl_parameter_get_int(cpl_parameterlist_find(parlist,"DEGREE"));
    double half_width = cpl_parameter_get_double(cpl_parameterlist_find(parlist,"HALF_WIDTH"));
    
    cpl_msg_info(cpl_func,"loaded params");
    //do error checking on params
    //if(degree_poly < 0) raise error 
    //if(method != spline or poly ; raise error)
 
    cpl_parameterlist* iframe = cpl_parameterlist_new();
    err=xsh_molecfit_utils_find_input_frame(frameset, iframe);
    cpl_msg_info(cpl_func,"finished xsh_molecfit_utils_find_input_frame");
 
    const char* input_name = cpl_parameter_get_string(cpl_parameterlist_find(iframe,"INPUTNAME"));
    const char* arm = cpl_parameter_get_string(cpl_parameterlist_find(iframe,"ARM"));
    //const char* obsmode = cpl_parameter_get_string(cpl_parameterlist_find(iframe,"OBSMODE"));
    const char* is_idp = cpl_parameter_get_string(cpl_parameterlist_find(iframe,"IDP"));
    const char* fname = cpl_parameter_get_string(cpl_parameterlist_find(iframe,"INPUTFILENAME"));
 
    //if not IDP, this is TRUE
    cpl_boolean USE_ONLY_INPUT_PRIMARY_DATA = CPL_TRUE;
    int ext = 1;
    if(!strcmp(is_idp,"TRUE")){
        USE_ONLY_INPUT_PRIMARY_DATA = CPL_FALSE;
        ext = 0;
    }
    cpl_table* table = NULL;
    cpl_msg_info(cpl_func,"loading input table %s",fname); 
    table = cpl_table_load(fname,1,0);
    cpl_msg_info(cpl_func,"loaded input table"); 
    if(table){
        cpl_msg_info(cpl_func,"loading columns"); 
        //cpl_table_dump(table,0,cpl_table_get_nrow(table),stdout);
        //cpl_type t = cpl_table_get_column_type(table,col_wave);
        //cpl_msg_info(cpl_func,"%s",cpl_type_get_name(t));
        cpl_array* wave = cpl_table_get_array(table,col_wave,0);
        cpl_array* flux = cpl_table_get_array(table,col_flux,0);
        cpl_array* dflux = cpl_table_get_array(table,col_dflux,0);
        
        cpl_msg_info(cpl_func,"loading data");
 
        //xshooter functions use cpl_vectors instead?
        double wmin, wmax;
        int wn = cpl_array_get_size(wave);
        double* wave_data = cpl_array_get_data_double(wave);
        wmin = wave_data[0];
        wmax = wave_data[wn-1];
        cpl_msg_info(cpl_func,"wmin %.2f wmax %.2f",wmin,wmax);
 
        //xsh_extract_points_to_fit
 
        //cpl_array_dump(a,0,cpl_array_get_size(a),stdout);
        //double* wave=cpl_table_get_data_double(table,col_wave);
        //if(wave){
        //    cpl_msg_info(cpl_func,"wave[0] %.2f",wave[0]);
        //}/
    }
 
    return err;
 
}
 
 
cpl_error_code xsh_molecfit_telluric_spec_data_calcs(mf_wrap_fits* data, const char* is_idp, cpl_parameterlist* ilist,mf_wrap_model_parameter* parameters){
    //work out which extension to access for the spectrum
 
    cpl_error_code err = CPL_ERROR_NONE;
    cpl_boolean USE_ONLY_INPUT_PRIMARY_DATA = CPL_TRUE;
    if(!strcmp(is_idp,"TRUE")){
        USE_ONLY_INPUT_PRIMARY_DATA = CPL_FALSE;
    }
    
 
    //code from molecfit_model - to work out which is which...
    //unused //cpl_size n_ext;
    int spec_ext = 0;
    //TO LATER TEST/CUSTOMISE PER XSHOOTER DATA FORMATS...
    if(USE_ONLY_INPUT_PRIMARY_DATA){
        spec_ext = 0;
    } else {
        spec_ext = 1;
    }
    cpl_msg_info(cpl_func,"spec_ext: %d",spec_ext);
    //cpl_msg_info(cpl_func,"flux column: %s",MF_PARAMETERS_COLUMN_FLUX);
    //cpl_table* spectrum = data->v_ext[spec_ext].spectrum_data;
    //algorithm to work out the median continuum flux (perhaps RETURN LATER to do some sigma clipping)
    //median of flux - XSHOOTER_INPUT_DATA_FLUX_COLUMN is defined in xsh_molecfit_telluric.h
    //TODO: check input data and see what it uses
    //if(data == NULL){
    //    cpl_msg_info(cpl_func,"mf_wrap_fits* data == NULL");
   // }
 
    cpl_size nrows = cpl_table_get_nrow(data->v_ext[spec_ext].spectrum_data);
    cpl_msg_info(cpl_func,"nrows: %lld",nrows); 
    //cpl_table_dump(data->v_ext[spec_ext].spectrum_data,0,nrows,stdout);
 
    const char* FLUX_COLUMN = cpl_parameter_get_string(cpl_parameterlist_find(ilist,MF_PARAMETERS_COLUMN_FLUX));
    cpl_msg_info(cpl_func,"flux column: %s",FLUX_COLUMN);
 
    //TODO: MUST REMOVE NANs HERE...HOW TO DO THAT?
 
    double median = cpl_table_get_column_median(data->v_ext[spec_ext].spectrum_data,FLUX_COLUMN);
    cpl_msg_info(cpl_func,"spectrum median: %.4e",median); 
 
    //cpl_propertylist_update_string(ilist,"CONTINUUM_CONST",cpl_sprintf("%.4e",median));
    cpl_parameterlist_append(ilist,cpl_parameter_new_value(MF_PARAMETERS_CONTINUUM_CONST,CPL_TYPE_DOUBLE,NULL,NULL,median));
    //because we are setting up CONTINUUM_CONST **AFTER** mf_wrap_config_model_init, it will be missing from the parameters...
    //update that here...(could also be done in xsh_molecfit_telluric(), but it's neater and more self-contained to have it here 
    mf_parameters_fitting      *fitting = &(parameters->mf_config->parameters->fitting);
    fitting->fit_continuum.const_val = median;
    cpl_propertylist_update_double(parameters->pl, MF_PARAMETERS_CONTEX_DEFAULT" "MF_PARAMETERS_CONTINUUM_CONST, fitting->fit_continuum.const_val);
    parameters->mf_config->parameters->fitting = *fitting;
 
    return err;
}
 
 
cpl_error_code xsh_molecfit_telluric_spec_header_calcs(const char* fname,const char* arm, cpl_parameterlist* ilist){
 
    cpl_msg_info(cpl_func,"xsh_molecfit_telluric_spec_header_calcs");
    //const char* fname =  cpl_frame_get_filename(f);
    cpl_msg_info(cpl_func,"reading in %s",fname);
    //assume header info is in first extension 
    cpl_size ext = 0;
    //cpl_size n_ext = cpl_frame_get_nextensions(f);
    //Is this always in the first extension????
    //for (cpl_size ext=0;ext< n_ext;ext++){
    cpl_propertylist* hdr= cpl_propertylist_load(fname, ext);
    if(hdr){
        //SLIT_WIDTH_VALUE
        const char* slit_width_kw;
        if(!strcmp(arm,"UVB")){
            slit_width_kw = "ESO INS OPTI3 NAME";
        } else if(!strcmp(arm,"VIS")){
            slit_width_kw = "ESO INS OPTI4 NAME";
        } else if(!strcmp(arm,"NIR")){
            slit_width_kw = "ESO INS OPTI5 NAME";
        }
        cpl_msg_info(cpl_func,"to read in %s value",slit_width_kw);
        cpl_property *prop_hval = cpl_propertylist_get_property(hdr, slit_width_kw);
        if(prop_hval){
            const char* hval = cpl_property_get_string(prop_hval);
            if(hval){
                cpl_msg_info(cpl_func,"SLIT_WIDTH_VALUE: %s (read from %s)",strtok(hval,"x"),slit_width_kw);
                //if the keyword value is 0.5x11, return 0.5 as slit width
                //write to SLIT_WIDTH_VALUE parameter
                //set to NONE to ensure the SLIT_WIDTH_VALUE parameter value is utilised
                //cpl_propertylist_update_string(ilist,"SLIT_WIDTH_KEYWORD","NONE");
                //cpl_propertylist_update_string(ilist,"SLIT_WIDTH_VALUE",strtok(hval,"x"));
                cpl_parameterlist_append(ilist,cpl_parameter_new_value("SLIT_WIDTH_KEYWORD",CPL_TYPE_STRING,NULL,NULL,"NONE"));
                cpl_parameterlist_append(ilist,cpl_parameter_new_value("SLIT_WIDTH_VALUE",CPL_TYPE_DOUBLE,NULL,NULL,atof(strtok(hval,"x"))));
            }
        }
        //WAVELENGTH_FRAME *AND* OBS_ERF_RV_KEY
        const char* WAVELENGTH_FRAME;
        const char* OBS_ERF_RV_KEY;
 
        cpl_property *prop_tu = cpl_propertylist_get_property(hdr,"TUCD1");
        cpl_property *prop_ss = cpl_propertylist_get_property(hdr,"SPECSYS");
        cpl_property *prop_hb = cpl_propertylist_get_property(hdr,"ESO QC VRAD BARYCOR");
        cpl_property *prop_hh = cpl_propertylist_get_property(hdr,"ESO QC VRAD HELICOR");
        //cpl_msg_info(cpl_func,"HDR values: TUCD1: %s; SPECSYS: %s; ESO QC VRAD BARYCOR: %s; ESO QC VRAD HELICOR: %s;",
        //cpl_property_get_string(prop_tu),cpl_property_get_string(prop_ss),cpl_property_get_string(prop_hb),cpl_property_get_string(prop_hh));
 
 
        if(prop_tu){
            const char* val = cpl_property_get_string(prop_tu);
            cpl_msg_info(cpl_func,"TUCD1 found: %s",val);
            if(!strcmp(val,"em.wl;obs.atmos")){
                WAVELENGTH_FRAME="AIR";
            } else if(!strcmp(val,"em.wl")){
                WAVELENGTH_FRAME="VAC";
            }
        } else {
            //if TUCD1 not found, set to AIR (i.e. same as TUCD1 = em.wl;obs.atmos)
            WAVELENGTH_FRAME="AIR";
        }
 
        if(prop_ss){
            const char* val = cpl_property_get_string(prop_ss);
            cpl_msg_info(cpl_func,"SPECSYS found: %s",val);
            if(!strcmp(val,"TOPOCENT")){
                OBS_ERF_RV_KEY = "NONE";
            } else if(!strcmp(val,"BARYCENT")){
                OBS_ERF_RV_KEY = "ESO QC VRAD BARYCOR";
                sprintf(WAVELENGTH_FRAME,"%s_RV",WAVELENGTH_FRAME);
            } else if(!strcmp(val,"HELIOCENT")){
                OBS_ERF_RV_KEY = "ESO QC VRAD HELICOR";
                sprintf(WAVELENGTH_FRAME,"%s_RV",WAVELENGTH_FRAME);
            }
        } else {
            //if SPECSYS not found, set to NONE (i.e. same as SPECSYS = TOPOCENT)
            OBS_ERF_RV_KEY = "NONE";
        }
        /*if(prop_hb){
            double val = cpl_property_get_double(prop_hb);
            cpl_msg_info(cpl_func,"ESO QC VRAD BARYCOR found: %.2f",val);
        }
        if(prop_hh){
            double val = cpl_property_get_double(prop_hh);
            cpl_msg_info(cpl_func,"ESO QC VRAD HELICOR found: %.2f",val);
        }*/
 
        if(!prop_hb || !prop_hh){
            OBS_ERF_RV_KEY = "NONE";
        }
 
        if(WAVELENGTH_FRAME){
            //cpl_propertylist_update_string(ilist,"WAVELENGTH_FRAME",WAVELENGTH_FRAME);
            cpl_msg_info(cpl_func,"WAVELENGTH_FRAME: %s",WAVELENGTH_FRAME);
            cpl_parameterlist_append(ilist,cpl_parameter_new_value("WAVELENGTH_FRAME",CPL_TYPE_STRING,NULL,NULL,WAVELENGTH_FRAME));
 
        }
        if(OBS_ERF_RV_KEY){
            cpl_msg_info(cpl_func,"OBS_ERF_RV_KEY: %s",OBS_ERF_RV_KEY);
            //cpl_propertylist_update_string(ilist,"OBS_ERF_RV_KEY",OBS_ERF_RV_KEY);
            cpl_parameterlist_append(ilist,cpl_parameter_new_value("OBS_ERF_RV_KEY",CPL_TYPE_STRING,NULL,NULL,OBS_ERF_RV_KEY));
        }
    }
 
    //CONTINUUM_CONST
    //calculate median of spectrum FLUX values...
    //this is handled in xsh_molecfit_telluric_spec_data_calcs()
 
    //cleanup - cleanup cpl_property variables too?
    if (hdr) {
        cpl_propertylist_delete(hdr);
    }
 
 
    return CPL_ERROR_NONE;
 
}
 
 
 
/* -----------------------------------------------------------------------------------------------------/
 *
 * OVERVIEW OF STEPS
 *      1. DO SOME ERROR CHECKING ON FRAMESET? (may be done later in setup config, but just being thorough)
 *          1.5 GET *TAG* OF INPUT SCIENCE from FRAMSET using either MOLECFIT_STD_MODEL, MOLECFIT_SCIENCE_CALCTRANS or MOLECFIT_SCIENCE
 *              1.55 (Check for YYY in this FILENAME, in case we need it later...)
 *      2. DETERMINE IF SUFFIX NEEDED FROM DATASET (e.g. UVB/VIS/NIR for xshooter)
 *      3. SETUP INPUT FILE NAME TAGS
 *      4. SETUP OUTPUT FILE NAME TAGS
 *      5. SETUP PARAMETERS (e.g. --list_molec, etc.)
 *          N.B. We expect to be provided a FITS binary table of WAVE_INCLUDE & MOLECULES params,
 *          but FOR NOW, we setup these values internally via the string parameter versions.
 *          6. SETUP *EXTRA* PARAMETERS
 *
 *
-------------------------------------------------------------------------------------------------------*/