/*---------------------------------------------------------------------------
   
   File name 	: 	dicbkeys.c 
   Author 		:	Y. Jung
   Created on	:	July 2000
   Language		:	ANSI C
   Description	:   CONICA functions using DFS FITS header keywords 

 *--------------------------------------------------------------------------*/

/*
	$Id: dicbkeys.c,v 1.10 2002/01/29 04:30:51 yjung Exp $
	$Author: yjung $
	$Date: 2002/01/29 04:30:51 $
	$Revision: 1.10 $
*/

/*---------------------------------------------------------------------------
   								Includes
 ---------------------------------------------------------------------------*/

#include <math.h>
#include <ctype.h>
#include <unistd.h>

#include "conicap_lib.h"
#include "dicbkeys.h"

/*---------------------------------------------------------------------------
  							Function codes
 ---------------------------------------------------------------------------*/


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_arcfile
  @memo     find out the arcfile   
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
 */
/*--------------------------------------------------------------------------*/
char * conica_get_arcfile(char * filename)
{
    char    *   val ;

    if (is_paf_file(filename)) {
        val = paf_query(filename, "ARCFILE");
    } else {
        val = qfits_query_hdr(filename, "ARCFILE");
    }
    return qfits_pretty_string(val);
}

/*-------------------------------------------------------------------------*/
/**     
  @brief    find out the date of observation  
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
 */ 
/*--------------------------------------------------------------------------*/
char * conica_get_date_obs(char * filename)
{
    char    *   val ;

    if (is_paf_file(filename)) {
        val = paf_query(filename, "DATE-OBS");
    } else {
        val = qfits_query_hdr(filename, "DATE-OBS");
    }
    val = qfits_pretty_string(val);
    return val ;
}   


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_frame_type
  @memo     find out the frame type   
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
 */
/*--------------------------------------------------------------------------*/
char * conica_get_frame_type(char * filename)
{
	char	*	val ;

	val = qfits_query_hdr(filename, "HIERARCH ESO DET FRAME TYPE") ;
	if (val == NULL) {
		/* DET.FRAME moved to DET.FRAM in DICB on 28-07-2001 */
		val = qfits_query_hdr(filename, "HIERARCH ESO DET FRAM TYPE") ;
		if (val == NULL) return NULL ;
	}
	val = qfits_pretty_string(val);
	return val ;
}

/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_opti4_id
  @memo     find out the OPTI4 ID    
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
 */
/*--------------------------------------------------------------------------*/
char * conica_get_opti4_id(char * filename)
{
    char    *   val ;

	val = qfits_query_hdr(filename, "HIERARCH ESO INS OPTI4 ID");
	if (val == NULL) return NULL ;
    return qfits_pretty_string(val);
}


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_templateid        
  @memo     find out the template id    
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
*/
/*--------------------------------------------------------------------------*/

char * conica_get_templateid(char * filename)
{
    char    *   val ;

    val = qfits_query_hdr(filename, "HIERARCH ESO TPL ID") ;
    if (val == NULL) return NULL ;
    val = qfits_pretty_string(val);
    return val ;
}


/*-------------------------------------------------------------------------*/
/**
  @brief    find out the number of the current exposition  
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
 */
/*--------------------------------------------------------------------------*/
char * conica_get_expno(char * filename)
{
    char    *   val ;

    val = qfits_query_hdr(filename, "HIERARCH ESO TPL EXPNO") ;
    if (val == NULL) return NULL ;
    val = qfits_pretty_string(val);
    return val ;
}


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_numbexp       
  @memo     find out the number of expositions  
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
 */
/*--------------------------------------------------------------------------*/

char * conica_get_numbexp(char * filename)
{
    char    *   val ;

    val = qfits_query_hdr(filename, "HIERARCH ESO TPL NEXP") ;
    if (val == NULL) return NULL ;
    val = qfits_pretty_string(val);
    return val ;
}


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_mjdobs
  @memo     find out the mjd-obs keyword 
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc

 */
/*--------------------------------------------------------------------------*/

char * conica_get_mjdobs(char * filename)
{
    char        *   val ;

    val = qfits_query_hdr(filename, "MJD-OBS");
    if (val==NULL) return NULL ;
    val = qfits_pretty_string(val);
    return val ;
}

/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_ndit
  @memo     find out the character string associated to the NDIT keyword
            in an conica header
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
    History support for various conventions
    The returned string is statically allocated, no
    need to free() it!
 */
/*--------------------------------------------------------------------------*/
char * conica_get_ndit(char * filename)
{
    /* So far, only one convention used for DIT */
    return qfits_query_hdr(filename, "HIERARCH ESO DET NDIT");
}

/*-------------------------------------------------------------------------*/
/**
  @brief    find out the RA keyword in a CONICA header
  @param    filename    CONICA FITS file name
  @return   pointer to statically allocated character string
  History support for various conventions
  The returned string is statically allocated, no
  need to free() it!
 */
/*--------------------------------------------------------------------------*/
char * conica_get_ra(char * filename)
{
    /* So far, only one convention used for RA */
    return qfits_query_hdr(filename, "RA");
}       
    
        
/*-------------------------------------------------------------------------*/
/** 
  @brief    find out the DEC keyword in a CONICA header
  @param    filename    CONICA FITS file name
  @return   pointer to statically allocated character string
  History support for various conventions
  The returned string is statically allocated, no
  need to free() it!
 */
/*--------------------------------------------------------------------------*/
char * conica_get_dec(char * filename)
{
    /* So far, only one convention used for Dec */
    return qfits_query_hdr(filename, "DEC");
}   

/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_dit
  @memo     find out the character string associated to the DIT keyword
            in an conica header
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
    History support for various conventions
    The returned string is statically allocated, no
    need to free() it!
  
 */
/*--------------------------------------------------------------------------*/
char * conica_get_dit(char * filename)
{
    /* So far, only one convention used for DIT */
    return qfits_query_hdr(filename, "HIERARCH ESO DET DIT");
}

/*-------------------------------------------------------------------------*/
/**
  @brief    find out the character string associated to the DET.NCORRS key.
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  History support for various conventions
  The returned string is statically allocated, no need to free() it!
 */
/*--------------------------------------------------------------------------*/
char * conica_get_rom(char * filename)
{
    /* So far, only one convention used for DIT */
    return qfits_query_hdr(filename, "HIERARCH ESO DET NCORRS");
}

/*-------------------------------------------------------------------------*/
/**
  @brief    find out the character string associated to DET.NCORRS.NAME
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  History support for various conventions
  The returned string is statically allocated, no need to free() it!
 */
/*--------------------------------------------------------------------------*/
char * conica_get_rom_name(char * filename)
{
    /* So far, only one convention used for DIT */
    return qfits_query_hdr(filename, "HIERARCH ESO DET NCORRS NAME");
}



/*-------------------------------------------------------------------------*/
/**
  @brief    find out the character string associated to DET.MODE.NAME
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  History support for various conventions
  The returned string is statically allocated, no need to free() it!
 */
/*--------------------------------------------------------------------------*/
char * conica_get_mode(char * filename)
{
    /* So far, only one convention used for DIT */
    return qfits_query_hdr(filename, "HIERARCH ESO DET MODE NAME");
}


/*-------------------------------------------------------------------------*/
/**
  @brief    find out the character string associated to the EXPTIME keyword
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  History support for various conventions
  The returned string is statically allocated, no need to free() it!
 */
/*--------------------------------------------------------------------------*/
char * conica_get_exptime(char * filename)
{
    /* So far, only one convention used for EXPTIME */
    return qfits_query_hdr(filename, "EXPTIME") ;
}

/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_cumoffsetx    
  @memo     find out the character string associated to the CUMOFFSETX
            keyword in an conica header
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
    History support for various conventions
    The returned string is statically allocated, no
    need to free() it!

 */
/*--------------------------------------------------------------------------*/

char * conica_get_cumoffsetx(char * filename)
{
    /* So far, only one convention used for CUMOFFSETX */
    return qfits_query_hdr(filename, "HIERARCH ESO SEQ CUMOFFSETX");
}

/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_cumoffsety
  @memo     find out the character string associated to the CUMOFFSETY
            keyword in an conica header
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
    History support for various conventions
    The returned string is statically allocated, no
    need to free() it!

 */
/*--------------------------------------------------------------------------*/

char * conica_get_cumoffsety(char * filename)
{
    /* So far, only one convention used for CUMOFFSETY */
    return qfits_query_hdr(filename, "HIERARCH ESO SEQ CUMOFFSETY");
}


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_pixscale  
  @memo     find out the character string associated to the PIXSCALE 
            keyword in an conica header
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
    History support for various conventions
    The returned string is statically allocated, no
    need to free() it!

 */
/*--------------------------------------------------------------------------*/

char * conica_get_pixscale(char * filename)
{
    /* So far, only one convention used for PIXSCALE */
    return qfits_query_hdr(filename, "HIERARCH ESO INS PIXSCALE");
}


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_instrument
  @memo     find out the character string associated to the instrument
  @param    filename    conica FITS file name
  @return   pointer to statically allocated character string
  @doc
    History support for various conventions
    The returned string is statically allocated, no
    need to free() it!

 */
/*--------------------------------------------------------------------------*/

char * conica_get_instrument(char * filename)
{
    char * obj ;
    /* So far, only one convention used for resolution name */
    obj = qfits_query_hdr(filename, "INSTRUME");
    return qfits_pretty_string(obj);
}


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_dpr_catg
  @memo     find out the data category as defined by the DataFlow
  @param    filename    source FITS file
  @return   statically allocated char string, no need to free() it
  @doc
    returns NULL if error occurred
 */
/*--------------------------------------------------------------------------*/

char * conica_get_dpr_catg(char * filename)
{
    return qfits_query_hdr(filename, "HIERARCH ESO DPR CATG");
}

/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_dpr_type  
  @memo     find out the data type as defined by the DataFlow
  @param    filename    source FITS file
  @return   statically allocated char string, no need to free() it
  @doc
    returns NULL if error occurred
 */
/*--------------------------------------------------------------------------*/

char * conica_get_dpr_type(char * filename)
{
	char	*	s ;
    	s = qfits_query_hdr(filename, "HIERARCH ESO DPR TYPE");

	return qfits_pretty_string(s) ;
}


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_dpr_tech  
  @memo     find out the data tech as defined by the DataFlow
  @param    filename    source FITS file
  @return   statically allocated char string, no need to free() it
  @doc
    returns NULL if error occurred
 */
/*--------------------------------------------------------------------------*/

char * conica_get_dpr_tech(char * filename)
{
    return qfits_query_hdr(filename, "HIERARCH ESO DPR TECH");
}


/*-------------------------------------------------------------------------*/
/**
  @name     conica_get_filter  
  @memo     find out the filter used in a CONICA FITS frame.
  @param    filename    source FITS file
  @return   statically allocated char string, no need to free() it
  @doc
    returns NULL if error occurred
 */
/*--------------------------------------------------------------------------*/

char * conica_get_filter(char * filename)
{
	char * sval;

	sval = qfits_query_hdr(filename, "INS.OPTI5.ID");
	if (sval==NULL) return NULL ;
	sval = qfits_pretty_string(sval);
	
	if (!strcmp(sval, "empty")) {
		sval = qfits_query_hdr(filename, "INS.OPTI6.ID");
		sval = qfits_pretty_string(sval);
	}
	return sval ;
}

/*-------------------------------------------------------------------------*/
/**
  @brief    find out the ambient humidity level as defined in the
            relevant ambient monitor dictionary
  @param    filename    source FITS file
  @return   statically allocated char string, no need to free() it
  returns NULL if keyword cannot be found
 */ 
/*--------------------------------------------------------------------------*/
char * conica_get_humidity_level(char * filename)
{
    /* So far only one definition for this parameter */
    return qfits_query_hdr(filename, "TEL.AMBI.RHUM");
}

/*-------------------------------------------------------------------------*/
/**
  @brief    get airmass start or end from an CONICA FITS file
  @param    filename    source FITS file
  @param    when        0 to get start, 1 to get end
  @return   Char string containing what was found in header, NULL if error.
 */ 
/*--------------------------------------------------------------------------*/
char * conica_get_airmass(char * filename, int when)
{
    char   * am ;

    /* So far, only one convention used for AIRMASS START/END */
    if (when==AIRMASS_START) {      /* Get airmass start */
        if (is_paf_file(filename)) {
            am = paf_query(filename, "TEL.AIRM.START") ;
        } else {
            am = qfits_query_hdr(filename, "TEL.AIRM.START");
        }
    } else if (when==AIRMASS_END) {
        if (is_paf_file(filename)) {
            am = paf_query(filename, "TEL.AIRM.END") ;
        } else {
            am = qfits_query_hdr(filename, "TEL.AIRM.END");
        }
    } else {
        am = NULL ;
    }
    return qfits_pretty_string(am);
}

/*-------------------------------------------------------------------------*/
/**
  @brief    find out the OBS ID keyword 
  @param    filename    CONICA FITS file name
  @return   pointer to statically allocated character string
 */
/*--------------------------------------------------------------------------*/
char * conica_get_obs_id(char * filename)
{
    char        *   val ;
    
    if (is_paf_file(filename)) {
        val = paf_query(filename, "OBS.ID") ;
    } else {
        val = qfits_query_hdr(filename, "OBS.ID");
    }
    return qfits_pretty_string(val);
}

/*-------------------------------------------------------------------------*/
/**
  @brief    find out the OBS ID keyword 
  @param    filename    CONICA FITS file name
  @return   pointer to statically allocated character string
 */
/*--------------------------------------------------------------------------*/
char * conica_get_opti7_no(char * filename)
{
    char        *   val ;
    
    if (is_paf_file(filename)) {
        val = paf_query(filename, "INS.OPTI7.NO") ;
    } else {
        val = qfits_query_hdr(filename, "INS.OPTI7.NO");
    }
    return qfits_pretty_string(val);
}

/*-------------------------------------------------------------------------*/
/**
  @brief    find out the INS CON XREFZERO keyword 
  @param    filename    CONICA FITS file name
  @return   pointer to statically allocated character string
 */
/*--------------------------------------------------------------------------*/
char * conica_get_refzerox(char * filename)
{
    char        *   val ;
    
    if (is_paf_file(filename)) {
        val = paf_query(filename, "INS.CON.XREFZERO") ;
    } else {
        val = qfits_query_hdr(filename, "INS.CON.XREFZERO");
    }
    return qfits_pretty_string(val);
}

/*-------------------------------------------------------------------------*/
/**
  @brief    find out the INS CON YREFZERO keyword 
  @param    filename    CONICA FITS file name
  @return   pointer to statically allocated character string
 */
/*--------------------------------------------------------------------------*/
char * conica_get_refzeroy(char * filename)
{
    char        *   val ;
    
    if (is_paf_file(filename)) {
        val = paf_query(filename, "INS.CON.YREFZERO") ;
    } else {
        val = qfits_query_hdr(filename, "INS.CON.YREFZERO");
    }
    return qfits_pretty_string(val);
}