moons_science_starenod.c

/*
 * This file is part of the MOONS Pipeline
 * Copyright (C) 2002-2016 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
 
/*-----------------------------------------------------------------------------
                                Includes
 -----------------------------------------------------------------------------*/
 
#include "moo_utils.h"
#include "moo_pfits.h"
#include "moo_dfs.h"
#include "moo_params.h"
#include "moo_drl.h"
#include "moo_badpix.h"
#include "moo_extlist.h"
#include "moo_correct_tell.h"
#include "moo_subtract_nod.h"
#include "moo_combine_pair.h"
#include "moo_products.h"
#include <cpl.h>
 
#include <string.h>
 
/*-----------------------------------------------------------------------------
                              Plugin registration
 -----------------------------------------------------------------------------*/
 
int cpl_plugin_get_info(cpl_pluginlist *list);
 
/*-----------------------------------------------------------------------------
                            Private function prototypes
 -----------------------------------------------------------------------------*/
 
static int _moons_science_starenod_create(cpl_plugin *plugin);
static int _moons_science_starenod_exec(cpl_plugin *plugin);
static int _moons_science_starenod_destroy(cpl_plugin *plugin);
static int _moons_science_starenod(cpl_frameset *frameset,
                                   const cpl_parameterlist *parlist);
 
/*-----------------------------------------------------------------------------
                            Static variables
 -----------------------------------------------------------------------------*/
static const char *const _moons_science_starenod_description =
    "From an observation sequence in StareNod mode, this recipe removes the"
    " instrumental signature and provides calibrated science products. During "
    "the"
    " sequence, the telescope nods from one position on targets (labeled as T "
    "in "
    "Fig. 5-12) to a blank sky position (S). In the sequence, different slit "
    "offset"
    " positions can be used: as represented in Fig. 5-12, the combination is "
    "done "
    "with 1D wavelength calibrated sky subtracted spectra. Using different "
    "slit "
    "offset positions implies that different sets of calibration (FF, wave "
    "maps) "
    "are given as inputs.\n"
    "INPUT FRAMES\n"
    "  * science exposure frames n>=1 file(s)               (RAW) with tag "
    "OBJECT_STARENOD : "
    "science frame in stare+nod mode file\n"
    "  * sky exposure frames n file(s)                      (RAW) with tag "
    "SKY_STARENOD : "
    "Sky Frames illuminated by blank sky only, obtained in the Stare+Nod"
    " observation mode. The amount of exposure time (or DIT × NDIT for NIR), "
    "as "
    "well as the number of exposures, can be less than for the corresponding "
    "OBJECT_STARENOD frames.\n"
    "  * [OPTIONAL] ReferenceBadPixMask 1 file              (QUA) with tag "
    "BP_MAP_RP : "
    "cosmetic bad pixel map\n"
    "  * [OPTIONAL] NonLinearityBadPixMask 1 file           (QUA) with tag "
    "BP_MAP_NL : "
    "cosmetic bad pixel map coming from linearity recipe\n"
    "  * MasterBias 1 file                                  (DET) with tag "
    "MASTER_BIAS : "
    "master bias file\n"
    "  * MasterDarkNir 1 file                               (DET) with tag "
    "MASTER_DARK_NIR : "
    "master dark nir for object\n"
    "  * [OPTIONAL] MasterDarkNir 1 file                    (DET) with tag "
    "MASTER_DARK_NIR : "
    "master dark nir file for sky (if exposure time is different from object)\n"
    "  * [OPTIONAL] MasterDarkVis 1 file                    (DET) with tag "
    "MASTER_DARK_VIS : "
    "master dark vis file\n"
    "  * [OPTIONAL] CoeffsCube 1 or 2 file(s) one by offset (3D) with tag "
    "LINEARITY_COEFF_CUBE : "
    "coefficients to correct pixels detector linearity\n"
    "  * [OPTIONAL] P2pMap 1 file                           (DET) with tag "
    "P2P_MAP : "
    "pixel to pixel map\n"
    "  * Fftrace 1 or 2 file(s) one by offset               (LOC) with tag "
    "FF_TRACE :"
    "the localisation table\n"
    "  * [OPTIONAL] MasterFlat 1 or 2 file(s) one by offset (PSF) with tag "
    "MASTER_FLAT : "
    "the master flat used for optimal extraction\n"
    "  * Ffext  1 or 2 file(s) one by offset                (EXT) with tag "
    "FF_EXTSPECTRA : "
    "the extracted flat field\n"
    "  * F2f [OPTIONAL] 1 or 2 file(s) one by offset        (F2F) with tag "
    "F2F_TABLE :"
    "the fibre-to-fibre relative response\n"
    "  * SFormat 1 file                                     (FMT) with tag "
    "SPECTRAL_FORMAT : "
    "the spectral format table\n"
    "  * WaveMap 1 or 2 file(s) one by offset               (WMAP) with tag "
    "WAVE_MAP : "
    "the wavelength map\n"
    "  * SkyLines 1 file                                    (CAT) with tag "
    "SKY_LINE_LIST : "
    "the sky lines list table\n"
    "  * [OPTIONAL] response 1 file                         (RESPONSE) with "
    "tag RESPONSE : "
    "the response spectra in the extracted pixel space\n"
    "  * [OPTIONAL] TellCorr 1 file                         (TELLURIC_CORR) "
    "with tag TELLURIC_CORR : "
    "the telluric correction spectra\n"
    "  * [OPTIONAL] atmosExt 1 file                         (ATMO) with tag "
    "ATMOS_EXT : "
    "the atmospheric extinction table\n"
    "PRODUCTS\n"
    "  * STARENOD_RBNSPECTRA_OFFSET[offset]_[insmode]_i.fits (RBN) with tag "
    "STARENOD_RBNSPECTRA : "
    "Science product individual calibrated frames\n"
    "  * STARENOD_RBNFLXSPECTRA_OFFSET[offset]_[insmode]_i.fits (RBN) with tag "
    "STARENOD_RBNFLXSPECTRA : "
    "Science product individual flux calibrated frames\n"
    "  * STARENOD_SKSSPECTRA_OFFSET[offset]_[insmode]_i.fits (SCI) with tag "
    "STARENOD_SKSSPECTRA : "
    "Science product individual sky subtracted frames\n"
    "  * STARENOD_SKSSPECTRA_[insmode].fits                  (SCI) with tag "
    "STARENOD_SKSSPECTRA : "
    "Science product coadd calibrated frame\n"
    "\n";
 
/*-----------------------------------------------------------------------------
                                Function code
 -----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cpl_plugin_get_info(cpl_pluginlist *list)
{
    cpl_recipe *recipe = cpl_calloc(1, sizeof *recipe);
    cpl_plugin *plugin = &recipe->interface;
    if (cpl_plugin_init(plugin, CPL_PLUGIN_API, MOONS_BINARY_VERSION,
                        CPL_PLUGIN_TYPE_RECIPE, "moons_science_starenod",
                        "Reduces science exposure in stare and stare+nod modes",
                        _moons_science_starenod_description, "Regis Haigron",
                        PACKAGE_BUGREPORT, moo_get_license(),
                        _moons_science_starenod_create,
                        _moons_science_starenod_exec,
                        _moons_science_starenod_destroy)) {
        cpl_msg_error(cpl_func, "Plugin initialization failed");
        (void)cpl_error_set_where(cpl_func);
        return 1;
    }
    if (cpl_pluginlist_append(list, plugin)) {
        cpl_msg_error(cpl_func, "Error adding plugin to list");
        (void)cpl_error_set_where(cpl_func);
        return 1;
    }
    return 0;
}
 
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static int
_moons_science_starenod_create(cpl_plugin *plugin)
{
    cpl_recipe *recipe;
    /* Do not create the recipe if an error code is already set */
    if (cpl_error_get_code() != CPL_ERROR_NONE) {
        cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
                      cpl_func, __LINE__, cpl_error_get_where());
        return (int)cpl_error_get_code();
    }
    if (plugin == NULL) {
        cpl_msg_error(cpl_func, "Null plugin");
        cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
    }
    /* Verify plugin type */
    if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
        cpl_msg_error(cpl_func, "Plugin is not a recipe");
        cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
    }
    /* Get the recipe */
    recipe = (cpl_recipe *)plugin;
    /* Create the parameters list in the cpl_recipe object */
    recipe->parameters = cpl_parameterlist_new();
    if (recipe->parameters == NULL) {
        cpl_msg_error(cpl_func, "Parameter list allocation failed");
        cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
    }
    moo_params *params = moo_params_new("moons", "moons_science_starenod");
    /* Fill the parameters list */
    moo_params_add_keep_temp(params, recipe->parameters);
    moo_params_add_prepare(params, recipe->parameters);
    moo_params_add_correct_bias(params, recipe->parameters,
                                MOO_CORRECT_BIAS_METHOD_MASTER);
    moo_params_add_extract(params, recipe->parameters);
    moo_params_add_science_wavesol(params, recipe->parameters);
    moo_params_add_rebin(params, recipe->parameters);
    moo_params_add_combine_pair(params, recipe->parameters, CPL_FALSE);
    moo_params_add_target_table(params, recipe->parameters, CPL_FALSE);
    moo_params_add_sub_sky_stare_wnone(params, recipe->parameters);
    moo_params_add_coadd(params, recipe->parameters);
    moo_params_add_create_s1d(params, recipe->parameters);
    moo_params_delete(params);
    return 0;
}
 
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static int
_moons_science_starenod_exec(cpl_plugin *plugin)
{
    cpl_recipe *recipe;
    int recipe_status;
    cpl_errorstate initial_errorstate = cpl_errorstate_get();
    /* Return immediately if an error code is already set */
    if (cpl_error_get_code() != CPL_ERROR_NONE) {
        cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
                      cpl_func, __LINE__, cpl_error_get_where());
        return (int)cpl_error_get_code();
    }
    if (plugin == NULL) {
        cpl_msg_error(cpl_func, "Null plugin");
        cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
    }
    /* Verify plugin type */
    if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
        cpl_msg_error(cpl_func, "Plugin is not a recipe");
        cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
    }
    /* Get the recipe */
    recipe = (cpl_recipe *)plugin;
    /* Verify parameter and frame lists */
    if (recipe->parameters == NULL) {
        cpl_msg_error(cpl_func, "Recipe invoked with NULL parameter list");
        cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
    }
    if (recipe->frames == NULL) {
        cpl_msg_error(cpl_func, "Recipe invoked with NULL frame set");
        cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
    }
    /* Invoke the recipe */
    recipe_status = _moons_science_starenod(recipe->frames, recipe->parameters);
    /* Ensure DFS-compliance of the products */
    if (cpl_dfs_update_product_header(recipe->frames)) {
        if (!recipe_status)
            recipe_status = (int)cpl_error_get_code();
    }
    if (!cpl_errorstate_is_equal(initial_errorstate)) {
        /* Dump the error history since recipe execution start.
         At this point the recipe cannot recover from the error */
        cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
    }
    return recipe_status;
}
 
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static int
_moons_science_starenod_destroy(cpl_plugin *plugin)
{
    cpl_recipe *recipe;
    if (plugin == NULL) {
        cpl_msg_error(cpl_func, "Null plugin");
        cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
    }
    /* Verify plugin type */
    if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
        cpl_msg_error(cpl_func, "Plugin is not a recipe");
        cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
    }
    /* Get the recipe */
    recipe = (cpl_recipe *)plugin;
    cpl_parameterlist_delete(recipe->parameters);
    return 0;
}
 
static cpl_error_code
_moons_science_starenod_check_sof(cpl_frameset *frameset,
                                  cpl_frameset *offset_frameset,
                                  const char **bpmap_rp_name,
                                  const char **bpmap_nl_name,
                                  const cpl_frame **masterbias,
                                  const cpl_frame **masterdark_vis,
                                  cpl_frameset *masterdark_nir,
                                  const cpl_frame **p2pmap,
                                  const cpl_frame **sformat,
                                  const cpl_frame **sky_lines,
                                  const cpl_frame **atmo,
                                  const cpl_frame **resp,
                                  const cpl_frame **tell,
                                  const cpl_frame **airglow_group,
                                  const cpl_frame **airglow_var,
                                  const cpl_frame **solflux,
                                  const moo_sub_sky_stare_params *subsky_params)
{
    cpl_ensure_code(moo_dfs_set_groups(frameset) == CPL_ERROR_NONE,
                    cpl_error_get_code());
    int i;
    int nb_sky = 0;
    int nb_stare = 0;
    int nb_starenod = 0;
 
    for (i = 0; i < cpl_frameset_get_size(frameset); ++i) {
        cpl_frame *current_frame = cpl_frameset_get_position(frameset, i);
        if (!strcmp(cpl_frame_get_tag(current_frame),
                    MOONS_TAG_OBJECT_STARENOD)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
            nb_starenod++;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_OBJECT_STARE)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
            nb_stare++;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_SKY_STARENOD)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
            nb_sky++;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_BP_MAP_RP)) {
            *bpmap_rp_name = cpl_frame_get_filename(current_frame);
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_BP_MAP_NL)) {
            *bpmap_nl_name = cpl_frame_get_filename(current_frame);
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_MASTER_BIAS)) {
            *masterbias = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_MASTER_DARK_VIS)) {
            *masterdark_vis = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_MASTER_DARK_NIR)) {
            cpl_frameset_insert(masterdark_nir,
                                cpl_frame_duplicate(current_frame));
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_MASTER_FLAT)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame), MOONS_TAG_P2P_MAP)) {
            *p2pmap = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_FF_TRACE)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_LINEARITY_COEFF_CUBE)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_SPECTRAL_FORMAT)) {
            *sformat = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame), MOONS_TAG_WAVEMAP)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_SKY_LINE_LIST)) {
            *sky_lines = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_FF_EXTSPECTRA)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_F2F_TABLE)) {
            cpl_frameset_insert(offset_frameset,
                                cpl_frame_duplicate(current_frame));
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_ATMOS_EXT)) {
            *atmo = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_RESPONSE)) {
            *resp = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_TELLURIC_CORR)) {
            *tell = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_AIRGLOW_GROUP)) {
            *airglow_group = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_AIRGLOW_VAR)) {
            *airglow_var = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame), MOONS_TAG_SOLFLUX)) {
            *solflux = current_frame;
        }
    }
    if (nb_stare > 0 && nb_starenod > 0) {
        return (int)cpl_error_set_message(
            cpl_func, CPL_ERROR_DATA_NOT_FOUND,
            "SOF have mixed file tags STARE and STARENOD");
    }
    if (nb_stare > 0 && nb_sky > 0) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "remove SKY from sof");
    }
    if (nb_starenod > 0 && nb_sky <= 0) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_SKY_STARENOD);
    }
    if (*sformat == NULL) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_SPECTRAL_FORMAT);
    }
    if (*sky_lines == NULL) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_SKY_LINE_LIST);
    }
    if (*airglow_group == NULL &&
        strcmp(subsky_params->method, MOO_SUB_SKY_STARE_METHOD_SKYCORR) == 0) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_AIRGLOW_GROUP);
    }
    if (*airglow_var == NULL &&
        strcmp(subsky_params->method, MOO_SUB_SKY_STARE_METHOD_SKYCORR) == 0) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_AIRGLOW_VAR);
    }
    if (*solflux == NULL &&
        strcmp(subsky_params->method, MOO_SUB_SKY_STARE_METHOD_SKYCORR) == 0) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_SOLFLUX);
    }
    return CPL_ERROR_NONE;
}
 
static cpl_error_code
_moons_science_starenod_check_sof_byoffset(cpl_frameset *frameset,
                                           cpl_frameset *object_frameset,
                                           cpl_frameset *sky_frameset,
                                           const cpl_frame **master_flat,
                                           const cpl_frame **fftrace,
                                           const cpl_frame **coeffs_cube,
                                           const cpl_frame **wmap,
                                           const cpl_frame **flat,
                                           const cpl_frame **f2f,
                                           moo_extract_params *ext_params,
                                           moo_sub_sky_stare_params *sky_params,
                                           moo_target_table_mode *mode)
{
    cpl_ensure_code(moo_dfs_set_groups(frameset) == CPL_ERROR_NONE,
                    cpl_error_get_code());
    int nb_object = 0;
    int nb_stare = 0;
    int nb_sky = 0;
    int i;
    for (i = 0; i < cpl_frameset_get_size(frameset); ++i) {
        cpl_frame *current_frame = cpl_frameset_get_position(frameset, i);
        if (!strcmp(cpl_frame_get_tag(current_frame),
                    MOONS_TAG_OBJECT_STARENOD)) {
            cpl_frameset_insert(object_frameset,
                                cpl_frame_duplicate(current_frame));
            nb_object++;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_OBJECT_STARE)) {
            cpl_frameset_insert(object_frameset,
                                cpl_frame_duplicate(current_frame));
            nb_stare++;
            nb_object++;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_SKY_STARENOD)) {
            cpl_frameset_insert(sky_frameset,
                                cpl_frame_duplicate(current_frame));
            nb_sky++;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_MASTER_FLAT)) {
            *master_flat = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_FF_TRACE)) {
            *fftrace = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_LINEARITY_COEFF_CUBE)) {
            *coeffs_cube = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame), MOONS_TAG_WAVEMAP)) {
            *wmap = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_FF_EXTSPECTRA)) {
            *flat = current_frame;
        }
        else if (!strcmp(cpl_frame_get_tag(current_frame),
                         MOONS_TAG_F2F_TABLE)) {
            *f2f = current_frame;
        }
    }
 
    if (nb_object <= 0) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_OBJECT_STARENOD);
    }
 
    if (nb_stare > 0) {
        *mode = MOO_MODE_STARE;
        cpl_msg_info("test", "Recipe running in STARE mode");
    }
    else {
        *mode = MOO_MODE_STARENOD;
        cpl_msg_info("test", "Recipe running in STARENOD mode");
    }
 
    if (*mode == MOO_MODE_STARENOD) {
        if (nb_sky == 0) {
            return (int)cpl_error_set_message(
                cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                "SOF (filter by offset) does not have any file tagged "
                "with %s",
                MOONS_TAG_SKY_STARENOD);
        }
        if (strcmp(sky_params->method, MOO_SUB_SKY_STARE_METHOD_NONE) == 0) {
            return (int)cpl_error_set_message(
                cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                "sky subtraction NONE method not allowed in STARENOD");
        }
    }
 
    if (*fftrace == NULL) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_FF_TRACE);
    }
    if (*wmap == NULL) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_WAVEMAP);
    }
    if (*flat == NULL) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_FF_EXTSPECTRA);
    }
    if (*master_flat == NULL &&
        strcmp(ext_params->method, MOO_EXTRACT_METHOD_OPTIMAL) == 0) {
        return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
                                          "SOF does not have any file tagged "
                                          "with %s",
                                          MOONS_TAG_MASTER_FLAT);
    }
 
    return CPL_ERROR_NONE;
}
 
 
static cpl_error_code
_moons_p2pmap(moo_det *arc, const cpl_frame *p2pmap)
{
    cpl_error_code status = CPL_ERROR_NONE;
    moo_det *p2p = NULL;
    if (p2pmap != NULL) {
        moo_try_check(p2p = moo_det_create(p2pmap), " ");
        moo_try_check(moo_apply_p2p(arc, p2p), " ");
    }
moo_try_cleanup:
    moo_det_delete(p2p);
    return status;
}
 
static cpl_error_code
_moons_apply_flat(moo_ext *ext,
                  const cpl_frame *flat_frame,
                  const cpl_frame *f2f_frame)
{
    cpl_error_code status = CPL_ERROR_NONE;
    moo_ext *flat = NULL;
    moo_f2f *f2f = NULL;
    moo_try_check(flat = moo_ext_create(flat_frame), " ");
    if (f2f_frame != NULL) {
        f2f = moo_f2f_load(f2f_frame);
    }
    moo_try_check(moo_apply_flat(ext, flat, f2f), " ");
moo_try_cleanup:
    moo_ext_delete(flat);
    moo_f2f_delete(f2f);
    return status;
}
 
static moo_sci *
_moons_combine_pair(moo_rbn *rbn,
                    moo_rbn *sky_rbn,
                    moo_rbn *obj_rbn,
                    moo_target_table *target_table,
                    const cpl_frame *f2f_frame,
                    const cpl_frame *solflux_frame,
                    const cpl_frame *airglow_group_frame,
                    const cpl_frame *airglow_var_frame,
                    moo_combine_pair_params *combine_pair_params,
                    moo_sub_sky_stare_params *sky_params,
                    const char *sci_filename,
                    moo_products *products,
                    const cpl_frame *ref_frame)
{
    moo_sci *result = NULL;
    moo_f2f *f2f = NULL;
    if (f2f_frame != NULL) {
        f2f = moo_f2f_load(f2f_frame);
    }
    moo_try_check(result =
                      moo_combine_pair(rbn, sky_rbn, obj_rbn, target_table, f2f,
                                       solflux_frame, airglow_group_frame,
                                       airglow_var_frame, combine_pair_params,
                                       sky_params, sci_filename, products,
                                       ref_frame),
                  " ");
moo_try_cleanup:
    moo_f2f_delete(f2f);
    return result;
}
 
 
static cpl_frame *
_moons_starenod_rebin(int inum,
                      const char *mode,
                      int offset,
                      moo_ext *ext,
                      const cpl_frame *ref_frame,
                      moo_spectral_format *sformat,
                      moo_sky_lines_list *sky_lines,
                      moo_map *wmap,
                      const cpl_frame *atmo_frame,
                      const cpl_frame *resp_frame,
                      const cpl_frame *tell_frame,
                      moo_rebin_params *rbn_params,
                      moo_products *products,
                      const char *prefix)
{
    cpl_frame *rbn_frame = NULL;
    moo_atm *atm = NULL;
    moo_resp *resp = NULL;
    moo_telluric *telluric = NULL;
    moo_rbn *rbn = NULL;
 
    char *rbn_filename = NULL;
    char *calibflux_filename = NULL;
    char *tellcorr_filename = NULL;
 
    cpl_ensure(ext != NULL, CPL_ERROR_NULL_INPUT, NULL);
    cpl_ensure(ref_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
 
    rbn_filename = cpl_sprintf("%s_RBNSPECTRA_OFFSET%d_%s_%d.fits", prefix,
                               offset, mode, inum);
    moo_try_check(rbn = moo_rebin(ext, wmap, sformat, rbn_params, rbn_filename),
                  " ");
 
    moo_try_check(moo_rbn_compute_snr(rbn, sky_lines), " ");
 
    moo_try_check(
        rbn_frame = moo_products_add_rbn(products, rbn, CPL_FRAME_LEVEL_FINAL,
                                         MOONS_TAG_SCIENCE_STARENOD_RBNSPECTRA,
                                         rbn_filename, ref_frame),
        " ");
 
    if (atmo_frame != NULL && resp_frame != NULL) {
        moo_try_check(atm = moo_atm_load(atmo_frame), " ");
        moo_try_check(resp = moo_resp_load(resp_frame), " ");
 
        calibflux_filename = cpl_sprintf("%s_RBNFLXSPECTRA_OFFSET%d_%s_%d.fits",
                                         prefix, offset, mode, inum);
        moo_try_check(moo_calib_flux(rbn, atm, resp), " ");
        moo_try_check(rbn_frame = moo_products_add_rbn(
                          products, rbn, CPL_FRAME_LEVEL_FINAL,
                          MOONS_TAG_SCIENCE_STARENOD_RBNFLXSPECTRA,
                          calibflux_filename, ref_frame),
                      " ");
    }
    else {
        cpl_msg_info(__func__, "No flux calibration");
    }
 
    if (tell_frame != NULL) {
        moo_try_check(telluric = moo_telluric_load(tell_frame), " ");
 
        tellcorr_filename =
            cpl_sprintf("%s_RBNTELLCORRSPECTRA_OFFSET%d_%s_%d.fits", prefix,
                        offset, mode, inum);
        moo_try_check(moo_correct_tell(rbn, telluric), " ");
        moo_try_check(rbn_frame = moo_products_add_rbn(
                          products, rbn, CPL_FRAME_LEVEL_FINAL,
                          MOONS_TAG_SCIENCE_STARENOD_RBNTELLCORRSPECTRA,
                          tellcorr_filename, ref_frame),
                      " ");
    }
    else {
        cpl_msg_info(__func__, "No telluric correction");
    }
 
moo_try_cleanup:
    cpl_free(tellcorr_filename);
    cpl_free(calibflux_filename);
    cpl_free(rbn_filename);
    moo_atm_delete(atm);
    moo_resp_delete(resp);
    moo_telluric_delete(telluric);
    moo_rbn_delete(rbn);
    return rbn_frame;
}
 
static moo_sci *
_moons_sub_sky_stare(moo_rbn *rbn,
                     moo_target_table *target_table,
                     const cpl_frame *f2f_frame,
                     const cpl_frame *solflux_frame,
                     const cpl_frame *airglow_group_frame,
                     const cpl_frame *airglow_var_frame,
                     moo_sub_sky_stare_params *sky_params,
                     const char *sci_filename)
{
    moo_sci *result = NULL;
    moo_f2f *f2f = NULL;
 
    if (f2f_frame != NULL) {
        f2f = moo_f2f_load(f2f_frame);
    }
    moo_try_check(result =
                      moo_sub_sky_stare(rbn, target_table, rbn, f2f,
                                        solflux_frame, airglow_group_frame,
                                        airglow_var_frame, sky_params,
                                        sci_filename, MOO_SCI1D_NOT_PAIRED),
                  " ");
 
moo_try_cleanup:
    moo_f2f_delete(f2f);
    return result;
}
 
static cpl_frame *
_moons_stare_sci(int inum,
                 const char *mode,
                 int offset,
                 const cpl_frame *ref_frame,
                 const cpl_frame *rbn_frame,
                 moo_sky_lines_list *sky_lines,
                 const cpl_frame *f2f_frame,
                 const cpl_frame *airglow_group_frame,
                 const cpl_frame *airglow_var_frame,
                 const cpl_frame *solflux_frame,
                 moo_target_table_params *target_table_params,
                 moo_sub_sky_stare_params *sky_params,
                 moo_products *products,
                 const char *prefix)
{
    cpl_frame *sci_frame = NULL;
    moo_rbn *rbn = NULL;
    moo_target_table *target_table = NULL;
    moo_sci *sci = NULL;
 
    char *ttable_filename = NULL;
    char *sci_filename = NULL;
 
    cpl_ensure(rbn_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
    cpl_ensure(ref_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
    rbn = moo_rbn_create(rbn_frame);
 
    moo_try_check(target_table =
                      moo_create_target_table(rbn, NULL, MOO_MODE_STARE,
                                              target_table_params),
                  " ");
    ttable_filename = cpl_sprintf("%s_TARGET_TABLE_OFFSET%d_%s_%d.fits", prefix,
                                  offset, mode, inum);
    moo_try_check(moo_products_add_target_table(
                      products, target_table, CPL_FRAME_LEVEL_INTERMEDIATE,
                      MOONS_TAG_SCIENCE_STARENOD_TARGET_TABLE, ttable_filename,
                      ref_frame),
                  " ");
 
    sci_filename =
        cpl_sprintf("%s_SCI_OFFSET%d_%s_%d.fits", prefix, offset, mode, inum);
 
    moo_try_check(sci = _moons_sub_sky_stare(rbn, target_table, f2f_frame,
                                             solflux_frame, airglow_group_frame,
                                             airglow_var_frame, sky_params,
                                             sci_filename),
                  " ");
    moo_try_check(moo_sci_compute_snr(sci, sky_lines), " ");
 
    moo_try_check(
        sci_frame = moo_products_add_sci(products, sci, CPL_FRAME_LEVEL_FINAL,
                                         MOONS_TAG_SCIENCE_STARENOD_SKSSPECTRA,
                                         sci_filename, ref_frame),
        " ");
 
moo_try_cleanup:
    cpl_free(ttable_filename);
    cpl_free(sci_filename);
    moo_target_table_delete(target_table);
    moo_sci_delete(sci);
    moo_rbn_delete(rbn);
    return sci_frame;
}
 
static cpl_frame *
_moons_starenod_sci(int inum,
                    const char *mode,
                    int offset,
                    const cpl_frame *obj_frame,
                    const cpl_frame *obj_rbn_frame,
                    const cpl_frame *sky_rbn_frame,
                    const cpl_frame *nod_rbn_frame,
                    moo_sky_lines_list *sky_lines,
                    const cpl_frame *f2f_frame,
                    const cpl_frame *airglow_group_frame,
                    const cpl_frame *airglow_var_frame,
                    const cpl_frame *solflux_frame,
                    moo_target_table_params *target_table_params,
                    moo_combine_pair_params *combine_pair_params,
                    moo_sub_sky_stare_params *sky_params,
                    moo_products *products,
                    const char *prefix)
{
    cpl_frame *sci_frame = NULL;
    moo_rbn *nod_rbn = NULL;
    moo_rbn *sky_rbn = NULL;
    moo_rbn *obj_rbn = NULL;
    moo_target_table *target_table = NULL;
    moo_sci *sci = NULL;
 
    char *ttable_filename = NULL;
    char *sci_filename = NULL;
 
    cpl_ensure(nod_rbn_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
    cpl_ensure(obj_rbn_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
    cpl_ensure(sky_rbn_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
 
    moo_try_check(nod_rbn = moo_rbn_create(nod_rbn_frame), " ");
    moo_try_check(obj_rbn = moo_rbn_create(obj_rbn_frame), " ");
    moo_try_check(sky_rbn = moo_rbn_create(sky_rbn_frame), " ");
 
    moo_try_check(target_table = moo_create_target_table(obj_rbn, sky_rbn,
                                                         MOO_MODE_STARENOD,
                                                         target_table_params),
                  " ");
    ttable_filename = cpl_sprintf("%s_TARGET_TABLE_OFFSET%d_%s_%d.fits", prefix,
                                  offset, mode, inum);
    moo_try_check(moo_products_add_target_table(
                      products, target_table, CPL_FRAME_LEVEL_INTERMEDIATE,
                      MOONS_TAG_SCIENCE_STARENOD_TARGET_TABLE, ttable_filename,
                      obj_frame),
                  " ");
 
    sci_filename =
        cpl_sprintf("%s_SCI_OFFSET%d_%s_%d.fits", prefix, offset, mode, inum);
    moo_try_check(sci = _moons_combine_pair(nod_rbn, sky_rbn, obj_rbn,
                                            target_table, f2f_frame,
                                            solflux_frame, airglow_group_frame,
                                            airglow_var_frame,
                                            combine_pair_params, sky_params,
                                            sci_filename, products, obj_frame),
                  " ");
 
    moo_try_check(moo_sci_compute_snr(sci, sky_lines), " ");
 
    moo_try_check(
        sci_frame = moo_products_add_sci(products, sci, CPL_FRAME_LEVEL_FINAL,
                                         MOONS_TAG_SCIENCE_STARENOD_SKSSPECTRA,
                                         sci_filename, obj_frame),
        " ");
 
moo_try_cleanup:
    cpl_free(ttable_filename);
    cpl_free(sci_filename);
    moo_target_table_delete(target_table);
    moo_sci_delete(sci);
    moo_rbn_delete(nod_rbn);
    moo_rbn_delete(sky_rbn);
    moo_rbn_delete(obj_rbn);
 
    return sci_frame;
}
 
static const cpl_frame *
find_masterdark_nir(moo_det *det, cpl_frameset *set)
{
    const cpl_frame *result = NULL;
    double dit = 0.0;
    int ndit = 0;
    double exptime = 0.0;
    int num;
    int type;
    int find = 0;
    moo_det *current_det = NULL;
 
    cpl_ensure(det != NULL, CPL_ERROR_NULL_INPUT, NULL);
 
    for (num = 1; num <= 2; num++) {
        for (type = 1; type <= 2; type++) {
            moo_single *single = moo_det_get_single(det, type, num);
            if (single != NULL) {
                moo_try_check(ndit = moo_pfits_get_ndit(single->header), " ");
                moo_try_check(dit = moo_pfits_get_dit(single->header), " ");
                exptime = dit * ndit;
                find = 1;
                break;
            }
        }
        if (find) {
            break;
        }
    }
 
    if (find && set != NULL) {
        int size = cpl_frameset_get_size(set);
        for (int i = 0; i < size; i++) {
            const cpl_frame *current = cpl_frameset_get_position_const(set, i);
            current_det = moo_det_create(current);
            moo_single *current_single =
                moo_det_get_single(current_det, type, num);
            moo_try_check(ndit = moo_pfits_get_ndit(current_single->header),
                          " ");
            moo_try_check(dit = moo_pfits_get_dit(current_single->header), " ");
            double current_exptime = dit * ndit;
            if (fabs(exptime - current_exptime) <= 1E-9) {
                result = current;
                break;
            }
            moo_det_delete(current_det);
            current_det = NULL;
        }
    }
moo_try_cleanup:
    moo_det_delete(current_det);
    return result;
}
 
static cpl_frame *
_moons_starenod_subtractnod(int inum,
                            const char *mode,
                            int offset,
                            const cpl_frame *obj_frame,
                            const cpl_frame *obj_det_frame,
                            const cpl_frame *sky_det_frame,
                            moo_products *products)
{
    cpl_frame *result = NULL;
    char *nod_det_filename = NULL;
    moo_det *nod_det = NULL;
    unsigned int badpix_level = MOO_BADPIX_GOOD;
 
    moo_det *obj_det = moo_det_create(obj_det_frame);
    moo_det *sky_det = moo_det_create(sky_det_frame);
    moo_try_check(moo_det_load(obj_det, badpix_level), " ");
    moo_try_check(moo_det_load(sky_det, badpix_level), " ");
 
    nod_det_filename =
        cpl_sprintf("%s_OFFSET%d_%s_%d.fits", MOONS_TAG_STARENOD_SUBTRACTNOD,
                    offset, mode, inum);
 
    moo_try_check(nod_det =
                      moo_subtract_nod(obj_det, sky_det, nod_det_filename),
                  " ");
    moo_try_check(result = moo_products_add(products, nod_det,
                                            CPL_FRAME_LEVEL_INTERMEDIATE,
                                            MOONS_TAG_STARENOD_SUBTRACTNOD,
                                            nod_det_filename, obj_frame),
                  " ");
 
moo_try_cleanup:
    cpl_free(nod_det_filename);
    moo_det_delete(obj_det);
    moo_det_delete(sky_det);
    moo_det_delete(nod_det);
 
    return result;
}
 
static cpl_frame *
_moons_starenod_prepare(int inum,
                        const char *mode,
                        int offset,
                        const cpl_frame *frame,
                        const char *bpmap_rp_name,
                        const char *bpmap_nl_name,
                        const cpl_frame *masterbias,
                        const cpl_frame *masterdark_vis,
                        cpl_frameset *masterdark_nir_frameset,
                        const cpl_frame *p2pmap,
                        const cpl_frame *coeffs_cube,
                        moo_prepare_params *prepare_params,
                        moo_correct_bias_params *cbias_params,
                        moo_products *products,
                        int objtype)
{
    cpl_frame *result = NULL;
    const cpl_frame *masterdark_nir = NULL;
    moo_det *det = NULL;
    char *det_filename = NULL;
    char *det_p2p_filename = NULL;
    const char *det_tags[] = { MOONS_TAG_STARENOD_OBJ_CORRECTDARK,
                               MOONS_TAG_STARENOD_SKY_CORRECTDARK };
    const char *detp2p_tags[] = { MOONS_TAG_STARENOD_OBJ_APPLYP2P,
                                  MOONS_TAG_STARENOD_SKY_APPLYP2P };
 
 
    cpl_ensure(frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
 
    moo_try_check(det = moo_prepare(frame, bpmap_rp_name, bpmap_nl_name,
                                    masterbias, coeffs_cube, prepare_params),
                  " ");
    moo_try_check(moo_correct_bias(det, masterbias, cbias_params), " ");
 
    masterdark_nir = find_masterdark_nir(det, masterdark_nir_frameset);
 
    moo_try_check(moo_correct_dark(det, NULL, masterdark_vis, masterdark_nir),
                  " ");
    det_filename = cpl_sprintf("%s_OFFSET%d_%s_%d.fits", det_tags[objtype],
                               offset, mode, inum);
    moo_try_check(moo_products_add(products, det, CPL_FRAME_LEVEL_INTERMEDIATE,
                                   det_tags[objtype], det_filename, frame),
                  " ");
    moo_try_check(_moons_p2pmap(det, p2pmap), " ");
    det_p2p_filename = cpl_sprintf("%s_OFFSET%d_%s_%d.fits",
                                   detp2p_tags[objtype], offset, mode, inum);
    moo_try_check(result = moo_products_add(products, det,
                                            CPL_FRAME_LEVEL_INTERMEDIATE,
                                            detp2p_tags[objtype],
                                            det_p2p_filename, frame),
                  " ");
 
moo_try_cleanup:
    cpl_free(det_filename);
    cpl_free(det_p2p_filename);
    moo_det_delete(det);
    return result;
}
 
static cpl_frame *
_moons_starenod_extract(int inum,
                        const char *mode,
                        int offset,
                        const cpl_frame *ref_frame,
                        const cpl_frame *det_frame,
                        moo_loc *loc,
                        moo_map *wmap,
                        moo_spectral_format *sformat,
                        moo_sky_lines_list *skylines,
                        const cpl_frame *masterflat_frame,
                        const cpl_frame *flat_frame,
                        const cpl_frame *f2f_frame,
                        moo_extract_params *extract_params,
                        moo_products *products,
                        const char *prefix)
{
    cpl_frame *ext_frame = NULL;
    moo_det *det = NULL;
    moo_psf *psf = NULL;
    moo_ext *ext = NULL;
 
    char *ext_filename = NULL;
    char *extff_filename = NULL;
 
    cpl_ensure(det_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
    det = moo_det_create(det_frame);
    ext_filename = cpl_sprintf("%s_EXTSPECTRA_OFFSET%d_%s_%d.fits", prefix,
                               offset, mode, inum);
    if (masterflat_frame != NULL) {
        psf = moo_psf_load(masterflat_frame);
    }
    moo_try_check(ext =
                      moo_extract(det, loc, psf, extract_params, ext_filename),
                  " ");
    moo_try_check(ext_frame = moo_products_add_ext(
                      products, ext, CPL_FRAME_LEVEL_INTERMEDIATE,
                      MOONS_TAG_SCIENCE_STARENOD_EXTSPECTRA, ext_filename,
                      ref_frame),
                  " ");
    moo_try_check(_moons_apply_flat(ext, flat_frame, f2f_frame), " ");
    moo_try_check(moo_ext_compute_snr(ext, wmap, sformat, skylines), " ");
 
    extff_filename = cpl_sprintf("%s_EXTFFSPECTRA_OFFSET%d_%s_%d.fits", prefix,
                                 offset, mode, inum);
 
    moo_try_check(ext_frame = moo_products_add_ext(
                      products, ext, CPL_FRAME_LEVEL_INTERMEDIATE,
                      MOONS_TAG_SCIENCE_STARENOD_EXTSPECTRA, extff_filename,
                      ref_frame),
                  " ");
 
moo_try_cleanup:
    cpl_free(ext_filename);
    cpl_free(extff_filename);
    moo_det_delete(det);
    moo_ext_delete(ext);
    moo_psf_delete(psf);
    return ext_frame;
}
 
static int
_moons_sort_mjdobs(const cpl_frame *a, const cpl_frame *b)
{
    int res = 0;
 
    const char *filenameA = cpl_frame_get_filename(a);
    const char *filenameB = cpl_frame_get_filename(b);
 
    cpl_propertylist *lista = cpl_propertylist_load(filenameA, 0);
    cpl_propertylist *listb = cpl_propertylist_load(filenameB, 0);
 
    if (cpl_propertylist_has(lista, MOO_PFITS_MJDOBS) &&
        cpl_propertylist_has(listb, MOO_PFITS_MJDOBS)) {
        double mjdA = moo_pfits_get_mjdobs(lista);
        double mjdB = moo_pfits_get_mjdobs(listb);
        if (mjdA < mjdB) {
            res = -1;
        }
        else if (mjdA > mjdB) {
            res = 1;
        }
        else {
            res = 0;
        }
    }
    cpl_propertylist_delete(listb);
    cpl_propertylist_delete(lista);
    return res;
}
 
static int
_moons_compare_offset(const cpl_frame *a, const cpl_frame *b)
{
    int res = 0;
    double oA, oB;
    cpl_propertylist *lista = NULL;
    cpl_propertylist *listb = NULL;
    const char *filenameA = cpl_frame_get_filename(a);
    lista = cpl_propertylist_load(filenameA, 0);
 
    moo_try_check(oA = moo_pfits_get_slit_offset(lista), "in filename :%s",
                  filenameA);
    const char *filenameB = cpl_frame_get_filename(b);
    listb = cpl_propertylist_load(filenameB, 0);
 
    moo_try_check(oB = moo_pfits_get_slit_offset(listb), "in filename :%s",
                  filenameB);
    if (fabs(oA - oB) < 1E-12) {
        res = 1;
    }
moo_try_cleanup:
    cpl_propertylist_delete(lista);
    cpl_propertylist_delete(listb);
    return res;
}
 
static int
_starenod_getsky_index(const cpl_frame *obj_frame,
                       const cpl_frameset *sky_frameset)
{
    int result = 0;
 
    cpl_ensure(obj_frame != NULL, CPL_ERROR_NULL_INPUT, 0);
    cpl_ensure(sky_frameset != NULL, CPL_ERROR_NULL_INPUT, 0);
 
    const char *obj_filename = cpl_frame_get_filename(obj_frame);
    cpl_propertylist *obj_list = cpl_propertylist_load(obj_filename, 0);
    double obj_mjd = moo_pfits_get_mjdobs(obj_list);
    double odiff = -1;
    int size = cpl_frameset_get_size(sky_frameset);
    for (int i = 0; i < size; i++) {
        const cpl_frame *sky_frame =
            cpl_frameset_get_position_const(sky_frameset, i);
        const char *sky_filename = cpl_frame_get_filename(sky_frame);
        cpl_propertylist *sky_list = cpl_propertylist_load(sky_filename, 0);
        double sky_mjd = moo_pfits_get_mjdobs(sky_list);
        double diff = fabs(sky_mjd - obj_mjd);
        if (odiff < 0) {
            odiff = diff;
        }
        else if (odiff > diff) {
            odiff = diff;
            result = i;
        }
        cpl_propertylist_delete(sky_list);
    }
    cpl_propertylist_delete(obj_list);
    return result;
}
 
static int
_moons_science_starenod_byoffset(cpl_frameset *frameset,
                                 cpl_frameset *sci_frameset,
                                 cpl_frameset *ref_frameset,
                                 const char *bpmap_rp_name,
                                 const char *bpmap_nl_name,
                                 const cpl_frame *masterbias,
                                 const cpl_frame *masterdark_vis,
                                 cpl_frameset *masterdark_nir,
                                 const cpl_frame *p2pmap,
                                 const cpl_frame *sformat_frame,
                                 moo_sky_lines_list *sky_lines,
                                 const cpl_frame *airglow_group_frame,
                                 const cpl_frame *solflux_frame,
                                 const cpl_frame *airglow_var_frame,
                                 const cpl_frame *atmo_frame,
                                 const cpl_frame *resp_frame,
                                 const cpl_frame *tell_frame,
                                 moo_prepare_params *prepare_params,
                                 moo_correct_bias_params *correct_bias_params,
                                 moo_extract_params *extract_params,
                                 moo_wavesol_params *wavesol_params,
                                 moo_rebin_params *rbn_params,
                                 moo_target_table_params *target_table_params,
                                 moo_combine_pair_params *combine_pair_params,
                                 moo_sub_sky_stare_params *sky_params,
                                 moo_products *products)
{
    /* parameters */
    int *skyindex = NULL;
    moo_loc *loc = NULL;
    moo_spectral_format *sformat = NULL;
    moo_map *wmap = NULL;
    moo_map *wmap_tuned = NULL;
    moo_extlist *obj_extlist = NULL;
    moo_extlist *sky_extlist = NULL;
    moo_extlist *nod_extlist = NULL;
    moo_extlist *wavemap_extlist = NULL;
    moo_ext *sum_ext = NULL;
    cpl_frameset *obj_frameset = NULL;
    cpl_frameset *sky_frameset = NULL;
    cpl_frameset *sky_det_frameset = NULL;
    cpl_frameset *obj_det_frameset = NULL;
    cpl_frameset *nod_det_frameset = NULL;
 
    cpl_frameset *nod_ext_frameset = NULL;
    cpl_frameset *sky_ext_frameset = NULL;
    cpl_frameset *obj_ext_frameset = NULL;
 
    cpl_frameset *obj_rbn_frameset = NULL;
    cpl_frameset *sky_rbn_frameset = NULL;
    cpl_frameset *nod_rbn_frameset = NULL;
 
    const cpl_frame *master_flat = NULL;
    const cpl_frame *fftrace = NULL;
    const cpl_frame *coeffs_cube = NULL;
    const cpl_frame *wmap_frame = NULL;
    const cpl_frame *flat_frame = NULL;
    const cpl_frame *f2f_frame = NULL;
    char *sum_ext_filename = NULL;
    const char *ref_filename = NULL;
    cpl_propertylist *ref_header = NULL;
    moo_mode_type mode;
    const char *mode_name = NULL;
    int offset;
    int wavemap_extlist_size = 0;
 
    char *wmap_tuned_filename = NULL;
    moo_target_table_mode target_mode = MOO_MODE_STARENOD;
 
    cpl_errorstate prestate = cpl_errorstate_get();
    obj_frameset = cpl_frameset_new();
    sky_frameset = cpl_frameset_new();
 
    sky_det_frameset = cpl_frameset_new();
    obj_det_frameset = cpl_frameset_new();
    nod_det_frameset = cpl_frameset_new();
 
    nod_ext_frameset = cpl_frameset_new();
    sky_ext_frameset = cpl_frameset_new();
    obj_ext_frameset = cpl_frameset_new();
 
    obj_rbn_frameset = cpl_frameset_new();
    sky_rbn_frameset = cpl_frameset_new();
    nod_rbn_frameset = cpl_frameset_new();
 
    moo_try_check(_moons_science_starenod_check_sof_byoffset(
                      frameset, obj_frameset, sky_frameset, &master_flat,
                      &fftrace, &coeffs_cube, &wmap_frame, &flat_frame,
                      &f2f_frame, extract_params, sky_params, &target_mode),
                  " ");
    cpl_frameset_join(ref_frameset, obj_frameset);
    int nb_sky = cpl_frameset_get_size(sky_frameset);
    int nb_obj = cpl_frameset_get_size(obj_frameset);
 
    cpl_frame *frame = cpl_frameset_get_position(obj_frameset, 0);
    ref_filename = cpl_frame_get_filename(frame);
    moo_try_check(mode = moo_mode_get(frame), " ");
    mode_name = moo_mode_get_name(mode);
    moo_try_check(ref_header = cpl_propertylist_load(ref_filename, 0), " ");
    moo_try_check(offset = moo_pfits_get_slit_offset(ref_header), " ");
    cpl_propertylist_delete(ref_header);
    ref_header = NULL;
    cpl_msg_info(__func__, "Do offset %d Use mode %s", offset, mode_name);
 
    for (int i = 0; i < nb_sky; i++) {
        cpl_msg_info(__func__, "---Prepare sky: %d/%d", i + 1, nb_sky);
        cpl_frame *sky_frame = NULL;
        moo_try_check(sky_frame = cpl_frameset_get_position(sky_frameset, i),
                      " ");
        cpl_frame *result =
            _moons_starenod_prepare(i, mode_name, offset, sky_frame,
                                    bpmap_rp_name, bpmap_nl_name, masterbias,
                                    masterdark_vis, masterdark_nir, p2pmap,
                                    coeffs_cube, prepare_params,
                                    correct_bias_params, products, 1);
        cpl_frameset_insert(sky_det_frameset, cpl_frame_duplicate(result));
    }
 
    for (int i = 0; i < nb_obj; i++) {
        cpl_msg_info(__func__, "---Prepare objects: %d/%d", i + 1, nb_obj);
        cpl_frame *obj_frame = NULL;
        moo_try_check(obj_frame = cpl_frameset_get_position(obj_frameset, i),
                      " ");
        cpl_frame *result =
            _moons_starenod_prepare(i, mode_name, offset, obj_frame,
                                    bpmap_rp_name, bpmap_nl_name, masterbias,
                                    masterdark_vis, masterdark_nir, p2pmap,
                                    coeffs_cube, prepare_params,
                                    correct_bias_params, products, 0);
        cpl_frameset_insert(obj_det_frameset, cpl_frame_duplicate(result));
    }
 
    if (nb_sky > 0) {
        skyindex = cpl_calloc(nb_obj, sizeof(int));
        for (int i = 0; i < nb_obj; i++) {
            cpl_frame *obj_frame = NULL;
            cpl_frame *obj_det_frame = NULL;
            cpl_frame *sky_det_frame = NULL;
            moo_try_check(obj_frame =
                              cpl_frameset_get_position(obj_frameset, i),
                          " ");
            skyindex[i] = _starenod_getsky_index(obj_frame, sky_frameset);
            moo_try_check(obj_det_frame =
                              cpl_frameset_get_position(obj_det_frameset, i),
                          " ");
            moo_try_check(sky_det_frame =
                              cpl_frameset_get_position(sky_det_frameset,
                                                        skyindex[i]),
                          " ");
            cpl_msg_info(__func__,
                         "---Prepare nod %d/%d using object:%s sky: %s", i + 1,
                         nb_obj, cpl_frame_get_filename(obj_det_frame),
                         cpl_frame_get_filename(sky_det_frame));
            cpl_frame *result =
                _moons_starenod_subtractnod(i, mode_name, offset, obj_frame,
                                            obj_det_frame, sky_det_frame,
                                            products);
            cpl_frameset_insert(nod_det_frameset, cpl_frame_duplicate(result));
        }
    }
    int nb_nod = cpl_frameset_get_size(nod_det_frameset);
    moo_try_check(wmap = moo_map_load(wmap_frame), " ");
    moo_try_check(loc = moo_loc_load(fftrace), " ");
    moo_try_check(sformat = moo_spectral_format_load(sformat_frame, mode), " ");
 
    for (int i = 0; i < nb_sky; i++) {
        cpl_frame *sky_frame = NULL;
        cpl_frame *sky_det_frame = NULL;
        cpl_msg_info(__func__, "---Extract sky: %d/%d", i + 1, nb_sky);
        moo_try_check(sky_frame = cpl_frameset_get_position(sky_frameset, i),
                      " ");
        moo_try_check(sky_det_frame =
                          cpl_frameset_get_position(sky_det_frameset, i),
                      " ");
        cpl_frame *result =
            _moons_starenod_extract(i, mode_name, offset, sky_frame,
                                    sky_det_frame, loc, wmap, sformat,
                                    sky_lines, master_flat, flat_frame,
                                    f2f_frame, extract_params, products,
                                    "STARENOD_SKY");
        cpl_frameset_insert(sky_ext_frameset, cpl_frame_duplicate(result));
    }
 
    for (int i = 0; i < nb_obj; i++) {
        cpl_frame *obj_frame = NULL;
        cpl_frame *obj_det_frame = NULL;
        cpl_msg_info(__func__, "---Extract objects: %d/%d", i + 1, nb_obj);
        moo_try_check(obj_frame = cpl_frameset_get_position(obj_frameset, i),
                      " ");
        moo_try_check(obj_det_frame =
                          cpl_frameset_get_position(obj_det_frameset, i),
                      " ");
        cpl_frame *result =
            _moons_starenod_extract(i, mode_name, offset, obj_frame,
                                    obj_det_frame, loc, wmap, sformat,
                                    sky_lines, master_flat, flat_frame,
                                    f2f_frame, extract_params, products,
                                    "STARENOD_OBJ");
        cpl_frameset_insert(obj_ext_frameset, cpl_frame_duplicate(result));
    }
 
    for (int i = 0; i < nb_nod; i++) {
        cpl_frame *obj_frame = NULL;
        cpl_frame *nod_det_frame = NULL;
        cpl_msg_info(__func__, "---Extract nod: %d/%d", i + 1, nb_nod);
        moo_try_check(obj_frame = cpl_frameset_get_position(obj_frameset, i),
                      " ");
        moo_try_check(nod_det_frame =
                          cpl_frameset_get_position(nod_det_frameset, i),
                      " ");
        cpl_frame *result =
            _moons_starenod_extract(i, mode_name, offset, obj_frame,
                                    nod_det_frame, loc, wmap, sformat,
                                    sky_lines, master_flat, flat_frame,
                                    f2f_frame, extract_params, products,
                                    "STARENOD_NOD");
        cpl_frameset_insert(nod_ext_frameset, cpl_frame_duplicate(result));
    }
 
    obj_extlist = moo_extlist_create(obj_ext_frameset);
    sky_extlist = moo_extlist_create(sky_ext_frameset);
    nod_extlist = moo_extlist_create(nod_ext_frameset);
    wavemap_extlist = moo_extlist_new();
 
    for (int i = 0; i < nb_obj; i++) {
        moo_ext *ext = moo_extlist_get(obj_extlist, i);
        moo_extlist_set(wavemap_extlist, ext, wavemap_extlist_size);
        wavemap_extlist_size++;
    }
    for (int i = 0; i < nb_sky; i++) {
        moo_ext *ext = moo_extlist_get(sky_extlist, i);
        moo_extlist_set(wavemap_extlist, ext, wavemap_extlist_size);
        wavemap_extlist_size++;
    }
 
    sum_ext_filename =
        cpl_sprintf("STARENOD_EXT_SUM_OFFSET%d_%s.fits", offset, mode_name);
    sum_ext = moo_extlist_sum(wavemap_extlist, sum_ext_filename);
    cpl_frame *ref_frame = cpl_frameset_get_position(obj_frameset, 0);
    moo_try_check(moo_products_add_ext(products, sum_ext,
                                       CPL_FRAME_LEVEL_TEMPORARY,
                                       MOONS_TAG_SCIENCE_STARENOD_EXTSPECTRA,
                                       sum_ext_filename, ref_frame),
                  " ");
    moo_map *used_wmap = NULL;
    const char *wavesol_control = wavesol_params->control;
    if ((strcmp(wavesol_control, MOO_WAVESOL_CONTROL_CHECK) == 0) ||
        (strcmp(wavesol_control, MOO_WAVESOL_CONTROL_UPDATE) == 0)) {
        const char *sky_lines_name = sky_lines->filename;
        moo_try_check(wmap_tuned = moo_wavesol(sum_ext, sky_lines_name, sformat,
                                               loc, wmap, wavesol_params),
                      " ");
        if (strcmp(wavesol_control, MOO_WAVESOL_CONTROL_UPDATE) == 0) {
            used_wmap = wmap_tuned;
            wmap_tuned_filename =
                cpl_sprintf("STARENOD_WMAP_TUNED_OFFSET%d_%s.fits", offset,
                            mode_name);
            moo_map_save(wmap_tuned, wmap_tuned_filename);
        }
    }
    else {
        used_wmap = wmap;
    }
 
    for (int i = 0; i < nb_obj; i++) {
        cpl_frame *obj_frame = NULL;
        moo_ext *obj_ext = moo_extlist_get(obj_extlist, i);
        cpl_msg_info(__func__, "---Rebin objects: %d/%d", i + 1, nb_obj);
 
        moo_try_check(obj_frame = cpl_frameset_get_position(obj_frameset, i),
                      " ");
        cpl_frame *result =
            _moons_starenod_rebin(i, mode_name, offset, obj_ext, obj_frame,
                                  sformat, sky_lines, used_wmap, atmo_frame,
                                  resp_frame, tell_frame, rbn_params, products,
                                  "STARENOD_OBJ");
 
        cpl_frameset_insert(obj_rbn_frameset, cpl_frame_duplicate(result));
    }
 
    for (int i = 0; i < nb_sky; i++) {
        cpl_frame *sky_frame = NULL;
        moo_ext *sky_ext = moo_extlist_get(sky_extlist, i);
        cpl_msg_info(__func__, "---Rebin sky: %d/%d", i + 1, nb_sky);
        moo_try_check(sky_frame = cpl_frameset_get_position(sky_frameset, i),
                      " ");
        cpl_frame *result =
            _moons_starenod_rebin(i, mode_name, offset, sky_ext, sky_frame,
                                  sformat, sky_lines, used_wmap, atmo_frame,
                                  resp_frame, tell_frame, rbn_params, products,
                                  "STARENOD_SKY");
        cpl_frameset_insert(sky_rbn_frameset, cpl_frame_duplicate(result));
    }
 
    for (int i = 0; i < nb_nod; i++) {
        cpl_frame *nod_frame = NULL;
        moo_ext *nod_ext = moo_extlist_get(nod_extlist, i);
        cpl_msg_info(__func__, "---Rebin nod: %d/%d", i + 1, nb_nod);
        moo_try_check(nod_frame = cpl_frameset_get_position(obj_frameset, i),
                      " ");
        cpl_frame *result =
            _moons_starenod_rebin(i, mode_name, offset, nod_ext, nod_frame,
                                  sformat, sky_lines, used_wmap, atmo_frame,
                                  resp_frame, tell_frame, rbn_params, products,
                                  "STARENOD_NOD");
        cpl_frameset_insert(nod_rbn_frameset, cpl_frame_duplicate(result));
    }
 
    if (nb_sky == 0) {
        for (int i = 0; i < nb_obj; i++) {
            cpl_frame *obj_frame = NULL;
            cpl_frame *obj_rbn_frame = NULL;
            cpl_msg_info(__func__, "---Create sci: %d/%d", i + 1, nb_obj);
            moo_try_check(obj_frame =
                              cpl_frameset_get_position(obj_frameset, i),
                          " ");
            moo_try_check(obj_rbn_frame =
                              cpl_frameset_get_position(obj_rbn_frameset, i),
                          " ");
            cpl_frame *result =
                _moons_stare_sci(i, mode_name, offset, obj_frame, obj_rbn_frame,
                                 sky_lines, f2f_frame, airglow_group_frame,
                                 airglow_var_frame, solflux_frame,
                                 target_table_params, sky_params, products,
                                 "STARENOD_OBJ");
            cpl_frameset_insert(sci_frameset, cpl_frame_duplicate(result));
        }
    }
    else {
        for (int i = 0; i < nb_nod; i++) {
            cpl_frame *obj_frame = NULL;
            cpl_frame *obj_rbn_frame = NULL;
            cpl_frame *sky_rbn_frame = NULL;
            cpl_frame *nod_rbn_frame = NULL;
            cpl_frame *sci_frame = NULL;
            moo_try_check(obj_frame =
                              cpl_frameset_get_position(obj_frameset, i),
                          " ");
            moo_try_check(obj_rbn_frame =
                              cpl_frameset_get_position(obj_rbn_frameset, i),
                          " ");
            moo_try_check(sky_rbn_frame =
                              cpl_frameset_get_position(sky_rbn_frameset,
                                                        skyindex[i]),
                          " ");
            moo_try_check(nod_rbn_frame =
                              cpl_frameset_get_position(nod_rbn_frameset, i),
                          " ");
            cpl_msg_info(__func__,
                         "---Create sci: %d/%d using nod %s object:%s sky: %s",
                         i + 1, nb_nod, cpl_frame_get_filename(nod_rbn_frame),
                         cpl_frame_get_filename(obj_rbn_frame),
                         cpl_frame_get_filename(sky_rbn_frame));
 
            moo_try_check(sci_frame = _moons_starenod_sci(
                              i, mode_name, offset, obj_frame, obj_rbn_frame,
                              sky_rbn_frame, nod_rbn_frame, sky_lines,
                              f2f_frame, airglow_group_frame, airglow_var_frame,
                              solflux_frame, target_table_params,
                              combine_pair_params, sky_params, products,
                              "STARENOD_NOD"),
                          " ");
            cpl_frameset_insert(sci_frameset, cpl_frame_duplicate(sci_frame));
        }
    }
 
moo_try_cleanup:
    if (!cpl_errorstate_is_equal(prestate)) {
        cpl_propertylist_delete(ref_header);
    }
    moo_extlist_delete(obj_extlist);
    moo_extlist_delete(sky_extlist);
    moo_extlist_delete(nod_extlist);
    if (wavemap_extlist != NULL) {
        for (int i = 0; i < wavemap_extlist_size; i++) {
            moo_extlist_unset(wavemap_extlist, 0);
        }
    }
    moo_extlist_delete(wavemap_extlist);
    moo_ext_delete(sum_ext);
    moo_loc_delete(loc);
    moo_map_delete(wmap);
    moo_map_delete(wmap_tuned);
    cpl_free(sum_ext_filename);
    cpl_free(wmap_tuned_filename);
    moo_spectral_format_delete(sformat);
 
    cpl_frameset_delete(obj_rbn_frameset);
    cpl_frameset_delete(sky_rbn_frameset);
    cpl_frameset_delete(nod_rbn_frameset);
 
    cpl_frameset_delete(sky_det_frameset);
    cpl_frameset_delete(obj_det_frameset);
    cpl_frameset_delete(nod_det_frameset);
 
    cpl_frameset_delete(obj_frameset);
    cpl_frameset_delete(sky_frameset);
    cpl_frameset_delete(nod_ext_frameset);
    cpl_frameset_delete(sky_ext_frameset);
    cpl_frameset_delete(obj_ext_frameset);
 
    cpl_free(skyindex);
 
    return (int)cpl_error_get_code();
}
 
static int
_moons_science_starenod(cpl_frameset *frameset,
                        const cpl_parameterlist *parlist)
{
    /* parameters */
    moo_prepare_params *prepare_params = NULL;
    moo_correct_bias_params *correct_bias_params = NULL;
    moo_extract_params *extract_params = NULL;
    moo_wavesol_params *wavesol_params = NULL;
    moo_rebin_params *rbn_params = NULL;
    moo_target_table_params *target_table_params = NULL;
    moo_combine_pair_params *combine_pair_params = NULL;
    moo_sub_sky_stare_params *sky_params = NULL;
    moo_coadd_params *coadd_params = NULL;
    moo_create_s1d_params *s1d_params = NULL;
 
    moo_scilist *sci_list = NULL;
    moo_sci *sci_coadd = NULL;
 
    cpl_frameset *offset_frameset = NULL;
    cpl_frameset *set = NULL;
    cpl_frameset *sci_set = NULL;
    cpl_frameset *ref_frameset = NULL;
 
    const char *bpmap_rp_name = NULL;
    const char *bpmap_nl_name = NULL;
    const cpl_frame *masterbias = NULL;
    const cpl_frame *masterdark_vis = NULL;
    cpl_frameset *masterdark_nir = NULL;
    const cpl_frame *p2pmap = NULL;
    const cpl_frame *sformat_frame = NULL;
    const cpl_frame *sky_lines_frame = NULL;
    const cpl_frame *atmo_frame = NULL;
    const cpl_frame *resp_frame = NULL;
    const cpl_frame *tell_frame = NULL;
    const cpl_frame *airglow_group_frame = NULL;
    const cpl_frame *solflux_frame = NULL;
    const cpl_frame *airglow_var_frame = NULL;
    const cpl_frame *ref_frame = NULL;
    cpl_size nsel = 0;
    cpl_size *selection = NULL;
    moo_sky_lines_list *skylines = NULL;
    char *coadd_filename = NULL;
    char *calibflux_filename = NULL;
 
    cpl_errorstate prestate = cpl_errorstate_get();
 
    moo_products *products =
        moo_products_new(frameset, parlist, "moons_science_starenod",
                         PACKAGE "/" PACKAGE_VERSION);
    const moo_params *params = moo_products_get_params(products);
    moo_try_check(prepare_params = moo_params_get_prepare(params, parlist),
                  " ");
 
    moo_try_check(correct_bias_params =
                      moo_params_get_correct_bias(params, parlist),
                  " ");
    moo_try_check(extract_params = moo_params_get_extract(params, parlist),
                  " ");
    moo_try_check(rbn_params = moo_params_get_rebin(params, parlist), " ");
    moo_try_check(target_table_params =
                      moo_params_get_target_table(params, parlist),
                  " ");
    moo_try_check(combine_pair_params =
                      moo_params_get_combine_pair(params, parlist),
                  " ");
    moo_try_check(sky_params = moo_params_get_sub_sky_stare(params, parlist),
                  " ");
    moo_try_check(coadd_params = moo_params_get_coadd(params, parlist), " ");
    moo_try_check(wavesol_params =
                      moo_params_get_science_wavesol(params, parlist),
                  " ");
    moo_try_check(s1d_params = moo_params_get_create_s1d(params, parlist), " ");
 
    /* SOF file */
    offset_frameset = cpl_frameset_new();
    sci_set = cpl_frameset_new();
    ref_frameset = cpl_frameset_new();
    masterdark_nir = cpl_frameset_new();
 
    moo_try_check(_moons_science_starenod_check_sof(
                      frameset, offset_frameset, &bpmap_rp_name, &bpmap_nl_name,
                      &masterbias, &masterdark_vis, masterdark_nir, &p2pmap,
                      &sformat_frame, &sky_lines_frame, &atmo_frame,
                      &resp_frame, &tell_frame, &airglow_group_frame,
                      &airglow_var_frame, &solflux_frame, sky_params),
                  " ");
 
    cpl_frameset_sort(offset_frameset, _moons_sort_mjdobs);
 
    moo_try_check(selection =
                      cpl_frameset_labelise(offset_frameset,
                                            &_moons_compare_offset, &nsel),
                  " ");
 
    moo_try_check(skylines = moo_sky_lines_list_load(sky_lines_frame), " ");
 
    for (int i = 0; i < nsel; i++) {
        moo_try_check(set = cpl_frameset_extract(offset_frameset, selection, i),
                      " ");
        moo_try_check(_moons_science_starenod_byoffset(
                          set, sci_set, ref_frameset, bpmap_rp_name,
                          bpmap_nl_name, masterbias, masterdark_vis,
                          masterdark_nir, p2pmap, sformat_frame, skylines,
                          airglow_group_frame, solflux_frame, airglow_var_frame,
                          atmo_frame, resp_frame, tell_frame, prepare_params,
                          correct_bias_params, extract_params, wavesol_params,
                          rbn_params, target_table_params, combine_pair_params,
                          sky_params, products),
                      " ");
 
        cpl_frameset_delete(set);
        set = NULL;
    }
 
    moo_try_check(ref_frame = cpl_frameset_get_position_const(ref_frameset, 0),
                  " ");
    moo_mode_type mode = moo_mode_get(ref_frame);
 
    sci_list = moo_scilist_create(sci_set);
    coadd_filename =
        cpl_sprintf("%s_%s.fits", MOONS_TAG_STARENOD_COMBINED_SPECTRA,
                    moo_mode_get_name(mode));
 
    sci_coadd = moo_coadd(sci_list, coadd_params, coadd_filename);
 
    moo_try_check(moo_sci_compute_snr(sci_coadd, skylines), " ");
    cpl_frame *sci_final = NULL;
    moo_try_check(sci_final =
                      moo_products_add_sci(products, sci_coadd,
                                           CPL_FRAME_LEVEL_FINAL,
                                           MOONS_TAG_STARENOD_COMBINED_SPECTRA,
                                           coadd_filename, ref_frame),
                  " ");
    moo_create_s1d(sci_final, s1d_params, MOONS_TAG_SCIENCE_STARENOD_1DSPECTRUM,
                   products);
 
moo_try_cleanup:
    if (!cpl_errorstate_is_equal(prestate)) {
        cpl_frameset_delete(set);
    }
    cpl_free(coadd_filename);
    cpl_free(calibflux_filename);
    cpl_free(selection);
    moo_sci_delete(sci_coadd);
    moo_scilist_delete(sci_list);
    moo_sky_lines_list_delete(skylines);
 
    cpl_frameset_delete(sci_set);
    cpl_frameset_delete(ref_frameset);
    cpl_frameset_delete(offset_frameset);
    cpl_frameset_delete(masterdark_nir);
 
    moo_extract_params_delete(extract_params);
    moo_wavesol_params_delete(wavesol_params);
    moo_rebin_params_delete(rbn_params);
    moo_target_table_params_delete(target_table_params);
 
    moo_combine_pair_params_delete(combine_pair_params);
    moo_sub_sky_stare_params_delete(sky_params);
    moo_coadd_params_delete(coadd_params);
    moo_correct_bias_params_delete(correct_bias_params);
    moo_create_s1d_params_delete(s1d_params);
    moo_prepare_params_delete(prepare_params);
 
    moo_products_delete(products);
    return (int)cpl_error_get_code();
}