cr2res_pfits.c

/*
 * This file is part of the CR2RES Pipeline
 * Copyright (C) 2002,2003 European Southern Observatory
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02111-1307  USA
 */
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
/*-----------------------------------------------------------------------------
                                   Includes
 -----------------------------------------------------------------------------*/
 
#include <cpl.h>
#include <math.h>
#include "cr2res_pfits.h"
#include "cr2res_utils.h"
#include "cr2res_io.h"
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
/*-----------------------------------------------------------------------------
                              Function codes
 -----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
cr2res_nodding_pos cr2res_pfits_get_nodding_pos(const cpl_propertylist * plist)
{
    const char  *   sval ;
    sval = cpl_propertylist_get_string(plist, CR2RES_HEADER_NODPOS);
 
    if (sval==NULL) {
        cpl_error_reset() ;
        return CR2RES_NODDING_NONE ;
    }
    if (sval[0] == 'A') return CR2RES_NODDING_A ;
    if (sval[0] == 'B') return CR2RES_NODDING_B ;
    return CR2RES_NODDING_NONE ; 
}
#ifdef CR2RES_UNUSED
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
const char * cr2res_pfits_get_procatg(const cpl_propertylist * plist)
{
    return (const char *) cpl_propertylist_get_string(plist, CPL_DFS_PRO_CATG);
}
#endif
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
const char * cr2res_pfits_get_drstype(const cpl_propertylist * plist)
{
    return (const char *) cpl_propertylist_get_string(plist, 
            CR2RES_HEADER_DRS_TYPE);
}
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
const char * cr2res_pfits_get_protype(const cpl_propertylist * plist)
{
    return (const char *) cpl_propertylist_get_string(plist, 
            CPL_DFS_PRO_TYPE);
}
#ifdef CR2RES_UNUSED
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
const char * cr2res_pfits_get_arcfile(const cpl_propertylist * plist)
{
    return (const char *) cpl_propertylist_get_string(plist, 
            CR2RES_HEADER_ARCFILE);
}
#endif
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
const char * cr2res_pfits_get_progid(const cpl_propertylist * plist)
{
    return (const char *) cpl_propertylist_get_string(plist,
            CR2RES_HEADER_PROG_ID);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
const char * cr2res_pfits_get_wlen_id(const cpl_propertylist * plist)
{
    return (const char *) cpl_propertylist_get_string(plist, 
            CR2RES_HEADER_WLEN_ID);
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_dec(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_double(plist, "DEC") ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_ra(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_double(plist, "RA") ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_drot_posang(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_double(plist, CR2RES_HEADER_DROT_POSANG)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_nodthrow(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_double(plist, CR2RES_HEADER_NODTHROW)  ;
}
 
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_dit(const cpl_propertylist * plist)
{
    double val;
    val = cpl_propertylist_get_double(plist, CR2RES_HEADER_DIT)  ;
    if (cpl_error_get_code() == CPL_ERROR_TYPE_MISMATCH){
        cpl_error_reset();
        val = (double) cpl_propertylist_get_int(plist, CR2RES_HEADER_DIT);
    }
    return val;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_mjd_obs(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_double(plist, CR2RES_HEADER_MJDOBS)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_cwlen(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_double(plist, CR2RES_HEADER_WLEN_CWLEN)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
const char * cr2res_pfits_get_poltype(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_string(plist, CR2RES_HEADER_POL_TYPE)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_wstrt(const cpl_propertylist * plist, int order_idx)
{
    char    *   key_name ;
    int         order_idxp ;
    double      val  ;
 
    /* Check entries */
    if (plist == NULL) return -1.0 ;
 
    /* Conversion order_idx -> order_idxp */
    if ((order_idxp = cr2res_io_convert_order_idx_to_idxp(order_idx)) < 0) 
        return -1.0 ;
 
    /* Create key name */
    key_name = cpl_sprintf(CR2RES_HEADER_WLEN_BEGIN, order_idxp) ;
 
    /* Get the value */
    val = cpl_propertylist_get_double(plist, key_name) ;
 
    cpl_free(key_name) ;
    return val ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
double cr2res_pfits_get_wend(const cpl_propertylist * plist, int order_idx)
{
    char    *   key_name ;
    int         order_idxp ;
    double      val  ;
 
    /* Check entries */
    if (plist == NULL) return -1.0 ;
 
    /* Conversion order_idx -> order_idxp */
    if ((order_idxp = cr2res_io_convert_order_idx_to_idxp(order_idx)) < 0) 
        return -1.0 ;
 
    /* Create key name */
    key_name = cpl_sprintf(CR2RES_HEADER_WLEN_END, order_idxp) ;
 
    /* Get the value */
    val = cpl_propertylist_get_double(plist, key_name) ;
 
    cpl_free(key_name) ;
    return val ;
}
#ifdef CR2RES_UNUSED
/*----------------------------------------------------------------------------*/
  /*
  @brief    find out the NAXIS1 value
  @param    plist       property list to read from
  @return   the requested value
 */
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_naxis1(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_NAXIS1)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_naxis2(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_NAXIS2)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_nexp(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_NEXP)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_expno(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_EXPNO)  ;
}
#endif
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_ndit(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_NDIT)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_ndsamples(const cpl_propertylist * plist)
{
    if (plist == NULL || !cpl_propertylist_has(plist, CR2RES_HEADER_NDSAMPLES))
        return -1 ;
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_NDSAMPLES)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_obs_id(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_OBS_ID)  ;
}
 
/*----------------------------------------------------------------------------*/
  /*
  @brief    find out the ORDER value
  @param    plist       property list to read from
  @return   the requested value
 */
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_order(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_GRAT1_ORDER)  ;
}
 
/*----------------------------------------------------------------------------*/
  /*
  @brief    find out the ZP_ORD value
  @param    plist       property list to read from
  @return   the requested value
 */
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_order_zp(const cpl_propertylist * plist)
{
    return cpl_propertylist_get_int(plist, CR2RES_HEADER_GRAT1_ZPORD)  ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
int cr2res_pfits_get_order_idx(
        const cpl_propertylist  *   plist,
        double                      yposition)
{
    int         i;
    int         order_idx = -1000 ;
    int         min_order_idx = -49 ;
    int         max_order_idx =  50 ;
    double      curr_diff;
    double      best_diff = CR2RES_DETECTOR_SIZE;
 
    /* Check entries */
    if (plist == NULL) return -1 ;
    if (yposition < 1) return -1 ;
    if (cpl_error_get_code() != CPL_ERROR_NONE) {
        cpl_msg_error(__func__, "Error already set - abort") ;
        return -1 ;
    }
 
    for (i = min_order_idx; i <= max_order_idx; i++) {
        char *key_name;
        int order_idxp;
        double ycen;
        order_idxp = cr2res_io_convert_order_idx_to_idxp(i);
        key_name = cpl_sprintf(CR2RES_HEADER_WLEN_CENY, order_idxp) ;
        ycen = cpl_propertylist_get_double(plist, key_name);
        cpl_free(key_name) ;
        if (cpl_error_get_code() != CPL_ERROR_NONE) {
            cpl_error_reset();
            continue;
        }
        curr_diff = fabs(yposition - ycen );
        if (curr_diff < best_diff){
               best_diff = curr_diff;
               order_idx = i;
        }
    }
 
    cpl_msg_debug(__func__, 
        "Order %d identified with %.1f pix difference from expectation",
        order_idx, best_diff);
    if (best_diff > 100.0)
        cpl_msg_warning(__func__,
                "Order %d identified with large difference of %.1f pix",
                order_idx, best_diff);
    return order_idx ;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
cr2res_decker cr2res_pfits_get_decker_position(const cpl_propertylist * plist)
{
    int         decker_value ;
    decker_value = cpl_propertylist_get_int(plist, CR2RES_HEADER_DECKER_POS);
    if (cpl_error_get_code() != CPL_ERROR_NONE) {
        cpl_error_reset();
        return CR2RES_DECKER_INVALID ;
    }
    /* TODO: enter proper encoder values */
    if (decker_value == 3) return CR2RES_DECKER_NONE ;
    if (decker_value == 1) return CR2RES_DECKER_1_3 ;
    if (decker_value == 2) return CR2RES_DECKER_2_4 ;
    return CR2RES_DECKER_INVALID ;
}