int main( int argc, char *argv[] )
{
register unsigned short np = 0;
unsigned short orbit;
float orbitPhase;
bool fnd_24, fnd_30;
float ao_24[CHANNEL_SIZE], lc_24[CHANNEL_SIZE],
ao_err_24[CHANNEL_SIZE], lc_err_24[CHANNEL_SIZE];
float ao_30[CHANNEL_SIZE], lc_30[CHANNEL_SIZE],
ao_err_30[CHANNEL_SIZE], lc_err_30[CHANNEL_SIZE];
/*
* initialization of command-line parameters
*/
if ( argc <= 2 || (argc > 1 && strncmp( argv[1], "-h", 2 ) == 0) ) {
(void) fprintf( stderr, "Usage: %s orbit orbitPhase\n", argv[0] );
exit( EXIT_FAILURE );
}
orbit = (unsigned short) atoi( argv[1] );
orbitPhase = (float) atof( argv[2] );
fnd_24 = SDMF_get_OrbitalDark_24( orbit, orbitPhase, ao_24, lc_24,
ao_err_24, lc_err_24 );
if ( IS_ERR_STAT_FATAL )
NADC_GOTO_ERROR(NADC_ERR_FATAL, "SDMF_get_OrbitalDark_24");
fnd_30 = SDMF_get_OrbitalDark_30( orbit, orbitPhase, ao_30, lc_30,
ao_err_30, lc_err_30 );
if ( IS_ERR_STAT_FATAL )
NADC_GOTO_ERROR(NADC_ERR_FATAL, "SDMF_get_OrbitalDark_30");
/*
*
*/
if ( ! (fnd_24 || fnd_30) ) goto done;
do {
(void) printf( "%5hu", np );
if ( fnd_24 ) {
(void) printf( " %12.6g %12.6g %12.6g %12.6g",
ao_24[np], lc_24[np], ao_err_24[np],
lc_err_24[np] );
}
if ( fnd_30 ) {
(void) printf( " %12.6g %12.6g %12.6g %12.6g",
ao_30[np], lc_30[np], ao_err_30[np],
lc_err_30[np] );
}
(void) printf( "\n" );
} while( ++np < CHANNEL_SIZE );
done:
NADC_Err_Trace( stderr );
if ( IS_ERR_STAT_FATAL )
exit( EXIT_FAILURE );
else
exit( EXIT_SUCCESS );
}
/*+++++++++++++++++++++++++
.IDENTifer SDMF_get_PPG_24
.PURPOSE Read Pixel-to-Pixel Gain factors from Monitoring database (v2.4)
.INPUT/OUTPUT
call as SDMF_get_PPG_24( absOrbit, channel, pixelGain );
input:
unsigned short absOrbit : absolute orbitnumber
unsigned short channel : channel ID or zero for all channels
output:
float *pixelGain : Pixel-to-Pixel Gain factors
.RETURNS flag: FALSE (no mask found) or TRUE
error status passed by global variable ``nadc_stat''
.COMMENTS none
-------------------------*/
bool SDMF_get_PPG_24( unsigned short absOrbit, unsigned short channel,
float *pixelGain )
{
register unsigned np = 0;
char ppg_fl[MAX_STRING_LENGTH];
FILE *db_fp;
const size_t disk_sz_ppg_rec = 32816;
struct ppg_rec {
int Orbit;
int MagicNumber;
int Saa;
float Tobm;
float Tdet[SCIENCE_CHANNELS];
float PixelGain[SCIENCE_PIXELS];
} mrec;
/*
* initialise output arrays
*/
if ( channel == 0 ) {
do { pixelGain[np] = 1.f; } while ( ++np < SCIENCE_PIXELS );
} else {
do { pixelGain[np] = 1.f; } while ( ++np < CHANNEL_SIZE );
}
/*
* find file with Pixel-to-Pixel Gains, requirements:
* - orbit number within a range MAX_DiffOrbitNumber
*/
if ( ! SDMF_get_fileEntry( SDMF24_PPG, (int) absOrbit, ppg_fl ) )
return FALSE;
/*
* read Pixel-to-Pixel Gain values
*/
if ( (db_fp = fopen( ppg_fl, "r" )) == NULL )
NADC_GOTO_ERROR( NADC_ERR_FILE, ppg_fl );
if ( fread( &mrec, disk_sz_ppg_rec, 1, db_fp ) != 1 )
NADC_GOTO_ERROR( NADC_ERR_FILE_RD, "mrec" );
(void) fclose( db_fp );
if ( channel == 0 ) {
(void) memcpy( pixelGain, mrec.PixelGain,
SCIENCE_PIXELS * sizeof(float) );
} else {
const size_t offs = (channel-1) * CHANNEL_SIZE;
(void) memcpy( pixelGain, mrec.PixelGain+offs,
CHANNEL_SIZE * sizeof(float) );
}
return TRUE;
done:
return FALSE;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++*/
int IDL_STDCALL _SDMF_RD_PT_CLUSTER( int argc, void *argv[] )
{
register size_t nr;
IDL_STRING *dbName;
unsigned short clus_id, state_id;
unsigned int numIndx, *metaIndx;
float *pixel_val;
struct mtbl_pt_rec *mtbl;
char grpName[9];
size_t C_numIndx, *C_metaIndx;
hid_t fid = -1, gid = -1;
/*
* check number of parameters
*/
if ( argc != 7 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
dbName = (IDL_STRING *) argv[0];
state_id = *(unsigned short *) argv[1];
clus_id = *(unsigned short *) argv[2];
numIndx = *(unsigned int *) argv[3];
metaIndx = (unsigned int *) argv[4];
mtbl = (struct mtbl_pt_rec *) argv[5];
pixel_val = (float *) argv[6];
if ( numIndx == 0 ) return 0;
fid = H5Fopen( dbName->s, H5F_ACC_RDONLY, H5P_DEFAULT );
if ( fid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, dbName->s );
(void) snprintf( grpName, 9, "State_%02hu", state_id );
gid = H5Gopen( fid, grpName, H5P_DEFAULT );
if ( gid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, grpName );
C_numIndx = (size_t) numIndx;
C_metaIndx = (size_t *) malloc( C_numIndx * sizeof( size_t ));
for ( nr = 0; nr < C_numIndx; nr++ )
C_metaIndx[nr] = (size_t) metaIndx[nr];
SDMF_rd_pt_metaTable( gid, &C_numIndx, C_metaIndx, &mtbl );
SDMF_rd_pt_cluster( gid, clus_id, &C_numIndx, C_metaIndx, pixel_val );
free( C_metaIndx );
(void) H5Gclose( gid );
(void) H5Fclose( fid );
return 1;
done:
H5E_BEGIN_TRY {
(void) H5Gclose( gid );
(void) H5Fclose( fid );
} H5E_END_TRY;
return -1;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
void SCIA_WR_SQL_CH4_META( PGconn *conn, const struct imap_hdr *hdr )
{
PGresult *res;
char *pntr, sql_query[SQL_STR_SIZE];
int nrow, numChar, meta_id;
/*
* check if product is already in database
*/
(void) snprintf( sql_query, SQL_STR_SIZE,
"SELECT * FROM %s WHERE name=\'%s\'",
META_TBL_NAME, hdr->product );
res = PQexec( conn, sql_query );
if ( PQresultStatus( res ) != PGRES_TUPLES_OK ) {
NADC_GOTO_ERROR( NADC_ERR_SQL, PQresultErrorMessage(res) );
}
if ( (nrow = PQntuples( res )) != 0 ) {
NADC_GOTO_ERROR( NADC_ERR_SQL_TWICE, hdr->product );
}
PQclear( res );
/*
* obtain next value for serial pk_meta
*/
res = PQexec( conn,
"SELECT nextval(\'meta_imap_ch4_pk_meta_seq\')" );
if ( PQresultStatus( res ) != PGRES_TUPLES_OK )
NADC_GOTO_ERROR( NADC_ERR_SQL, PQresultErrorMessage(res) );
pntr = PQgetvalue( res, 0, 0 );
meta_id = (int) strtol( pntr, (char **) NULL, 10 );
PQclear( res );
/*
* no error and not yet stored, then proceed
*/
numChar = snprintf( sql_query, SQL_STR_SIZE, SQL_INSERT_META,
META_TBL_NAME, meta_id,
hdr->product, hdr->l1b_product, hdr->file_size,
hdr->receive_date, hdr->creation_date,
hdr->validity_start, hdr->validity_stop,
hdr->software_version, hdr->orbit[0],
hdr->numRec );
/* (void) fprintf( stderr, "%s [%-d]\n", sql_query, numChar ); */
if ( numChar >= SQL_STR_SIZE )
NADC_RETURN_ERROR( NADC_ERR_STRLEN, "sql_query" );
/*
* do the actual insert
*/
res = PQexec( conn, sql_query );
if ( PQresultStatus( res ) != PGRES_COMMAND_OK )
NADC_GOTO_ERROR( NADC_ERR_SQL, PQresultErrorMessage(res) );
done:
PQclear( res );
}
int IDL_STDCALL _ENVI_RD_MPH( int argc, void *argv[] )
{
struct mph_envi *mph;
if ( argc != 1 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
if ( ! File_Is_Open )
NADC_GOTO_ERROR( NADC_ERR_FILE, "No open stream" );
mph = (struct mph_envi *) argv[0];
ENVI_RD_MPH( fd_nadc, mph );
if ( IS_ERR_STAT_FATAL ) return -1;
return 1;
done:
return -1;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
unsigned int SCIA_RD_H5_LADS( struct param_record param,
struct lads_scia *lads )
/*@globals lads_size, lads_offs@*/
{
hid_t ads_id;
hsize_t nfields, num_lads;
const size_t lads_sizes[NFIELDS] = {
sizeof( lads->mjd ),
sizeof( lads->flag_mds ),
sizeof( lads->corner )
};
/*
* create/open group /ADS/LADS
*/
ads_id = NADC_OPEN_HDF5_Group( param.hdf_file_id, "/ADS" );
if ( ads_id < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_GRP, "/ADS" );
/*
* read info_h5 records
*/
(void) H5TBget_table_info( ads_id, TBL_NAME, &nfields, &num_lads );
(void) H5TBread_table( ads_id, TBL_NAME, lads_size, lads_offs,
lads_sizes, lads );
(void) H5Gclose( ads_id );
return (unsigned int) num_lads;
done:
return 0u;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
short NADC_USRINDX( const char str_range[], int max_indx, short *indices )
{
register int nr;
char *cpntr, cbuff[MAX_STRING_LENGTH];
int num;
size_t nchar;
if ( (cpntr = strchr( str_range, '*' )) == NULL ) {
(void) NADC_USRINP( INT16_T, str_range, max_indx, indices, &num );
} else {
nchar = cpntr - str_range;
(void) nadc_strlcpy( cbuff, str_range, nchar );
(void) sprintf( cbuff, "%s%-d%s", cbuff, max_indx-1, cpntr+1 );
(void) NADC_USRINP( INT16_T, cbuff, max_indx, indices, &num );
}
for ( nr = 0; nr < num; nr++ ) {
if ( indices[nr] < 0 ) indices[nr] += (short) max_indx;
if ( indices[nr] < 0 || indices[nr] >= (short) max_indx ) {
num = nr;
NADC_GOTO_ERROR( NADC_ERR_PARAM, "indices" );
}
}
done:
return ((short) num);
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++*/
int IDL_STDCALL _SDMF_GET_PT_ORBITINDEX( int argc, void *argv[] )
{
register size_t nr;
IDL_STRING *dbName;
int orbit;
unsigned short state_id;
unsigned int *numIndx, *metaIndx;
char grpName[9];
size_t C_numIndx, *C_metaIndx;
hid_t fid = -1, gid = -1;
/*
* check number of parameters
*/
if ( argc != 5 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
dbName = (IDL_STRING *) argv[0];
state_id = *(unsigned short *) argv[1];
orbit = *(int *) argv[2];
numIndx = (unsigned int *) argv[3];
metaIndx = (unsigned int *) argv[4];
fid = H5Fopen( dbName->s, H5F_ACC_RDONLY, H5P_DEFAULT );
if ( fid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, dbName->s );
(void) snprintf( grpName, 9, "State_%02hu", state_id );
gid = H5Gopen( fid, grpName, H5P_DEFAULT );
if ( gid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, grpName );
C_numIndx = (size_t) (*numIndx);
C_metaIndx = (size_t *) malloc( C_numIndx * sizeof( size_t ));
SDMF_get_pt_orbitIndex( gid, orbit, &C_numIndx, C_metaIndx );
*numIndx = (unsigned int) C_numIndx;
for ( nr = 0; nr < C_numIndx; nr++ )
metaIndx[nr] = (unsigned int) C_metaIndx[nr];
free( C_metaIndx );
(void) H5Gclose( gid );
(void) H5Fclose( fid );
return 1;
done:
H5E_BEGIN_TRY {
(void) H5Gclose( gid );
(void) H5Fclose( fid );
} H5E_END_TRY;
return -1;
}
int main( int argc, char *argv[] )
{
register unsigned short np = 0;
bool wlsFlag = FALSE;
unsigned short orbit;
unsigned short channel = 0;
bool fnd_24, fnd_30;
float trans_24[SCIENCE_PIXELS], trans_30[SCIENCE_PIXELS];
/*
* initialization of command-line parameters
*/
if ( argc == 1 || (argc > 1 && strncmp( argv[1], "-h", 2 ) == 0) ) {
(void) fprintf(stderr, "Usage: %s orbit [channel] [wls]\n", argv[0]);
exit( EXIT_FAILURE );
}
orbit = (unsigned short) atoi( argv[1] );
if ( argc >= 3 ) channel = (unsigned short) atoi( argv[2] );
if ( argc == 4 ) wlsFlag = TRUE;
fnd_24 = SDMF_get_Transmission_24( wlsFlag, orbit, channel, trans_24 );
if ( IS_ERR_STAT_FATAL )
NADC_GOTO_ERROR( NADC_ERR_FATAL, "SDMF_get_Transmission_24" );
if ( ! fnd_24 ) (void) fprintf( stderr, "# no solution for SDMF v2.4\n" );
fnd_30 = SDMF_get_Transmission_30( wlsFlag, orbit, channel, trans_30 );
if ( IS_ERR_STAT_FATAL )
NADC_GOTO_ERROR( NADC_ERR_FATAL, "SDMF_get_Transmission_30" );
if ( ! fnd_30 ) (void) fprintf( stderr, "# no solution for SDMF v3.0\n" );
if ( ! (fnd_24 || fnd_30) ) goto done;
do {
(void) printf( "%5hu", np );
if ( fnd_24 )
(void) printf( " %12.6g", trans_24[np] );
if ( fnd_30 )
(void) printf( " %12.6g", trans_30[np] );
(void) printf( "\n" );
} while( ++np < ((channel == 0) ? SCIENCE_PIXELS : CHANNEL_SIZE) );
done:
NADC_Err_Trace( stderr );
if ( IS_ERR_STAT_FATAL )
exit( EXIT_FAILURE );
else
exit( EXIT_SUCCESS );
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++*/
int IDL_STDCALL _SDMF_RD_PT_CLUS_ATTR( int argc, void *argv[] )
{
IDL_STRING *dbName;
unsigned char *coaddf;
unsigned short state_id, clus_id;
unsigned short *num_pixels, *num_obs;
float *pet;
char grpName[9], clusName[11];
hid_t fid = -1, gid = -1;
/*
* check number of parameters
*/
if ( argc != 7 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
dbName = (IDL_STRING *) argv[0];
state_id = *(unsigned short *) argv[1];
clus_id = *(unsigned short *) argv[2];
coaddf = (unsigned char *) argv[3];
num_pixels = (unsigned short *) argv[4];
num_obs = (unsigned short *) argv[5];
pet = (float *) argv[6];
fid = H5Fopen( dbName->s, H5F_ACC_RDONLY, H5P_DEFAULT );
if ( fid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, dbName->s );
(void) snprintf( grpName, 9, "State_%02hu", state_id );
gid = H5Gopen( fid, grpName, H5P_DEFAULT );
if ( gid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, grpName );
(void) snprintf( clusName, 11, "cluster_%02hu", clus_id );
(void) H5LTget_attribute_uchar( gid, clusName, "coaddf", coaddf );
(void) H5LTget_attribute_ushort( gid, clusName, "numObs", num_obs );
(void) H5LTget_attribute_ushort( gid, clusName,"numPixels", num_pixels );
if ( H5LTget_attribute_float( gid, clusName, "PET", pet ) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_ATTR, "PET" );
(void) H5Gclose( gid );
(void) H5Fclose( fid );
return 1;
done:
H5E_BEGIN_TRY {
(void) H5Gclose( gid );
(void) H5Fclose( fid );
} H5E_END_TRY;
return -1;
}
/*+++++++++++++++++++++++++ Main Program or Functions +++++++++++++++*/
int IDL_STDCALL OpenFile( int argc, void *argv[] )
{
IDL_STRING *str_descr;
if ( argc != 1 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
str_descr = (IDL_STRING *) argv[0];
if ( File_Is_Open ) (void) fclose( fd_nadc );
if ((fd_nadc = fopen( str_descr[0].s, "r" )) == NULL ) {
NADC_GOTO_ERROR( NADC_ERR_FILE, strerror( errno ) );
} else
File_Is_Open = TRUE;
return 0;
done:
return -1;
}
/*+++++++++++++++++++++++++
.IDENTifer CAT_ASCII_FILE
.PURPOSE Open file for writing in append mode (create if non-existing)
.INPUT/OUTPUT
call as outfile = CAT_ASCII_File( fl_name, extension );
input:
char fl_name[] : name of output file (no extension!!!)
char extension[] : extension to be concatenated (without ".")
.RETURNS (open) stream pointer
.COMMENTS none
-------------------------*/
FILE *CAT_ASCII_File( const char filebase[], const char ext[] )
{
char flname[MAX_STRING_LENGTH];
FILE *outfl = NULL;
/*
* check size of output filename
*/
if ( (strlen( filebase) + strlen( ext )) > MAX_STRING_LENGTH ) {
(void) snprintf( flname, MAX_STRING_LENGTH,
"Filename too long (max: %d)\n",
(int) MAX_STRING_LENGTH );
NADC_GOTO_ERROR( NADC_ERR_FILE, flname );
}
(void) snprintf( flname, MAX_STRING_LENGTH, "%s.%s", filebase, ext );
if ( (outfl = fopen( flname, "a")) == NULL )
NADC_GOTO_ERROR( NADC_ERR_FILE_CRE, flname);
done:
return outfl;
}
int IDL_STDCALL _ENVI_RD_DSD( int argc, void *argv[] )
{
int nr_dsd = 0;
struct mph_envi mph;
struct dsd_envi *dsd;
if ( argc != 2 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
if ( ! File_Is_Open )
NADC_GOTO_ERROR( NADC_ERR_FILE, "No open stream" );
mph = *(struct mph_envi *) argv[0];
dsd = (struct dsd_envi *) argv[1];
nr_dsd = (int) ENVI_RD_DSD( fd_nadc, mph, dsd );
if ( IS_ERR_STAT_FATAL ) return -1;
return nr_dsd;
done:
return -1;
}
unsigned short IDL_STDCALL _GET_SCIA_QUALITY( int argc, void *argv[] )
{
int orbit, *range;
if ( argc != 2 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
orbit = *(int *) argv[0];
range = (int *) argv[1];
return GET_SCIA_QUALITY( orbit, range );
done:
return 0xFFFFU;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
int IDL_STDCALL _SDMF_RD_PT_CLUSDEF( int argc, void *argv[] )
{
IDL_STRING *dbName;
struct clusdef_rec *ClusDef;
hid_t fid = -1;
hid_t data_id = -1;
hid_t type_id = -1;
/*
* check number of parameters
*/
if ( argc != 2 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
dbName = (IDL_STRING *) argv[0];
ClusDef = (struct clusdef_rec *) argv[1];
fid = H5Fopen( dbName->s, H5F_ACC_RDONLY, H5P_DEFAULT );
if ( fid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, dbName->s );
if ( (data_id = H5Dopen( fid, "ClusDef", H5P_DEFAULT )) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_DATA, "ClusDef" );
if ( (type_id = H5Dget_type( data_id )) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_DTYPE, "ClusDef" );
if ( H5LTread_dataset( fid, "ClusDef", type_id, ClusDef ) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_RD, "ClusDef" );
(void) H5Tclose( type_id );
(void) H5Dclose( data_id );
(void) H5Fclose( fid );
return 1;
done:
H5E_BEGIN_TRY {
(void) H5Tclose( type_id );
(void) H5Dclose( data_id );
(void) H5Fclose( fid );
} H5E_END_TRY;
return -1;
}
/*++++++++++++++++++++++++++++++++++++++++++++++++++*/
int IDL_STDCALL _SDMF_RD_PT_GEO_ATTR( int argc, void *argv[] )
{
IDL_STRING *dbName;
unsigned short state_id;
unsigned short *num_obs;
char grpName[9];
hid_t fid = -1, gid = -1;
/*
* check number of parameters
*/
if ( argc != 3 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
dbName = (IDL_STRING *) argv[0];
state_id = *(unsigned short *) argv[1];
num_obs = (unsigned short *) argv[2];
fid = H5Fopen( dbName->s, H5F_ACC_RDONLY, H5P_DEFAULT );
if ( fid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, dbName->s );
(void) snprintf( grpName, 9, "State_%02hu", state_id );
gid = H5Gopen( fid, grpName, H5P_DEFAULT );
if ( gid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, grpName );
if ( H5LTget_attribute_ushort( gid, "pointing", "numObs", num_obs ) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_ATTR, "numObs" );
(void) H5Gclose( gid );
(void) H5Fclose( fid );
return 1;
done:
H5E_BEGIN_TRY {
(void) H5Gclose( gid );
(void) H5Fclose( fid );
} H5E_END_TRY;
return -1;
}
int IDL_STDCALL _SCIA_RD_LADS( int argc, void *argv[] )
{
int nr_lads;
unsigned int num_dsd;
struct dsd_envi *dsd;
struct lads_scia *lads;
if ( argc != 3 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
if ( ! File_Is_Open )
NADC_GOTO_ERROR( NADC_ERR_FILE, "No open stream" );
num_dsd = *(unsigned int *) argv[0];
dsd = (struct dsd_envi *) argv[1];
lads = (struct lads_scia *) argv[2];
nr_lads = (int) SCIA_RD_LADS( fd_nadc, num_dsd, dsd, &lads );
if ( IS_ERR_STAT_FATAL ) return -1;
return nr_lads;
done:
return -1;
}
unsigned int IDL_STDCALL _SCIA_SET_CALIB( int argc, void *argv[] )
{
IDL_STRING *calib_str;
unsigned int calib_mask;
if ( argc != 1 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
calib_str = (IDL_STRING *) argv[0];
if ( calib_str[0].slen == 0 ) return 0u;
SCIA_SET_CALIB( calib_str[0].s, &calib_mask );
return calib_mask;
done:
return 0u;
}
/*+++++++++++++++++++++++++
.IDENTifer SDMF_get_pt_jdayIndex
.PURPOSE obtain indices to last-limb/Sun records for julianDay interval
.INPUT/OUTPUT
call as SDMF_get_pt_jdayIndex( locID, jdayRange, &numIndx, metaIndx );
input:
hid_t locID : HDF5 identifier of group
double jdayRange[2] : range in julianDay (min,max)
in/output:
size_t *numIndx : [input] dimension of metaIndx
[output] number of indices found
output:
size_t *metaIndx : array with requested indices
.RETURNS nothing, error status passed by global variable ``nadc_stat''
.COMMENTS static function
-------------------------*/
void SDMF_get_pt_jdayIndex( hid_t locID, const double jdayRange[],
size_t *numIndx, size_t *metaIndx )
{
const size_t dimArray = *numIndx;
register size_t nr;
hid_t ptable;
hsize_t nrecords;
double *jdayList;
/*
* initialize return values
*/
*numIndx = 0;
*metaIndx = 0;
/*
* check if jdayList exists
*/
if ( (ptable = H5PTopen( locID, "jdayList" )) == H5I_BADID )
NADC_RETURN_ERROR( NADC_ERR_HDF_DATA, "jdayList" );
(void) H5PTget_num_packets( ptable, &nrecords );
if ( nrecords == 0 ) {
(void) H5PTclose( ptable );
return;
}
/*
* read list of orbits stored sofar
*/
jdayList = (double *) malloc( (size_t) nrecords * sizeof(double) );
if ( jdayList == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "jdayList" );
(void) H5PTread_packets( ptable, 0, (size_t) nrecords, jdayList );
/*
* find all matches
*/
for ( nr = 0; nr < (size_t) nrecords; nr++ ) {
if ( jdayList[nr] >= jdayRange[0] && jdayList[nr] <= jdayRange[1] ) {
metaIndx[*numIndx] = nr;
if ( ++(*numIndx) == dimArray ) break;
}
}
free( jdayList );
done:
(void) H5PTclose( ptable );
}
/*+++++++++++++++++++++++++
.IDENTifer SDMF_get_pt_orbitIndex
.PURPOSE obtain indices to last-limb/Sun records for given orbit number
.INPUT/OUTPUT
call as SDMF_get_pt_orbitIndex( locID, absOrbit, &numIndx, metaIndx );
input:
hid_t locID : HDF5 identifier of group
int absOrbit : orbit number
in/output:
size_t *numIndx : [input] dimension of metaIndx
[output] number of indices found
output:
size_t *metaIndx : array with requested indices
.RETURNS nothing, error status passed by global variable ``nadc_stat''
.COMMENTS static function
-------------------------*/
void SDMF_get_pt_orbitIndex( hid_t locID, int absOrbit,
size_t *numIndx, size_t *metaIndx )
{
const size_t dimArray = *numIndx;
register size_t nr;
hid_t ptable;
hsize_t nrecords;
int *orbitList;
/*
* initialize return values
*/
*numIndx = 0;
*metaIndx = 0;
/*
* check if orbitList exists
*/
if ( (ptable = H5PTopen( locID, "orbitList" )) == H5I_BADID )
NADC_RETURN_ERROR( NADC_ERR_HDF_DATA, "orbitList" );
(void) H5PTget_num_packets( ptable, &nrecords );
if ( nrecords == 0 ) {
(void) H5PTclose( ptable );
return;
}
/*
* read list of orbits stored sofar
*/
orbitList = (int *) malloc( (size_t) nrecords * sizeof(int) );
if ( orbitList == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "orbitList" );
(void) H5PTread_packets( ptable, 0, (size_t) nrecords, orbitList );
/*
* find all matches
*/
for ( nr = 0; nr < (size_t) nrecords; nr++ ) {
if ( orbitList[nr] == absOrbit ) {
metaIndx[*numIndx] = nr;
if ( ++(*numIndx) == dimArray ) break;
}
}
free( orbitList );
done:
(void) H5PTclose( ptable );
}
int IDL_STDCALL Err_Trace( int argc, void *argv[] )
{
FILE *fd_log;
IDL_STRING *log_name;
if ( argc != 1 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
log_name = (IDL_STRING *) argv[0];
/*
* create temporary file
*/
fd_log = fopen( log_name[0].s, "a" );
NADC_Err_Trace( fd_log );
(void) fclose( fd_log );
NADC_Err_Clear();
return 0;
done:
return -1;
}
int IDL_STDCALL _GET_SCIA_ROE_INFO( int argc, void *argv[] )
{
bool eclipseMode;
double julianDay;
bool *saaFlag;
int *absOrbit;
float *orbitPhase;
if ( argc != 5 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
eclipseMode = *(bool *) argv[0];
julianDay = *(double *) argv[1];
absOrbit = (int *) argv[2];
saaFlag = (bool *) argv[3];
orbitPhase = (float *) argv[4];
GET_SCIA_ROE_INFO( eclipseMode, julianDay,
absOrbit, saaFlag, orbitPhase );
return 0;
done:
return -1;
}
int IDL_STDCALL _GET_SCIA_ROE_ORBITPHASE( int argc, void *argv[] )
{
register int nm;
bool eclipseMode, saaFlag;
int num, orbit;
float *orbitPhase;
double *julianDay;
if ( argc != 4 ) NADC_GOTO_ERROR( NADC_ERR_PARAM, err_msg );
eclipseMode = *(bool *) argv[0];
num = *(int *) argv[1];
julianDay = (double *) argv[2];
orbitPhase = (float *) argv[3];
for ( nm = 0; nm < num; nm++ )
GET_SCIA_ROE_INFO( eclipseMode, julianDay[nm],
&orbit, &saaFlag, orbitPhase+nm );
return 0;
done:
return -1;
}
//
// Perform selections on complete states, applied criteria are:
// 1) MJD selection
// 2) state_id selection
// 3) reject incomplete states
// 4) CRC selection
// 5) Reject states with corrupted DSR records
//
//
size_t SCIA_LV0_SELECT_MDS( const struct param_record param,
size_t num_states, const struct mds0_states *states,
struct mds0_states **states_out )
{
register size_t ni;
register size_t nr_indx = num_states;
size_t *indx_states = NULL;
/*
* initialize output array
*/
*states_out = NULL;
if ( num_states == 0 ) return 0;
/*
* first check type of selected MDS
*/
if ( param.write_aux == PARAM_UNSET
&& param.write_det == PARAM_UNSET
&& param.write_pmd == PARAM_UNSET )
return 0u;
/*
* allocate memory to store indices to selected MDS records
*/
indx_states = (size_t *) malloc( num_states * sizeof(size_t) );
if ( indx_states == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "indx_states" );
for ( ni = 0; ni < num_states; ni++ ) indx_states[ni] = ni;
/*
* apply date-time criterium
*/
if ( param.flag_period != PARAM_UNSET ) {
nr_indx = SCIA_LV0_SELECT_MDS_PERIOD( ¶m, states,
nr_indx, indx_states );
}
if ( nr_indx == 0 ) goto done;
/*
* apply State ID criterium
*/
if ( param.stateID_nr != PARAM_UNSET ) {
nr_indx = SCIA_LV0_SELECT_MDS_STATE( ¶m, states,
nr_indx, indx_states );
}
if ( nr_indx == 0 ) goto done;
/*
* reject incomplete states
*/
if ( param.qcheck == PARAM_SET ) {
nr_indx = SCIA_LV0_SELECT_MDS_COMPLETE( ¶m, states,
nr_indx, indx_states );
}
if ( nr_indx == 0 ) goto done;
/*
* apply CRC criterium
*/
if ( param.qcheck == PARAM_SET ) {
nr_indx = SCIA_LV0_SELECT_MDS_CRC( ¶m, states,
nr_indx, indx_states );
}
if ( nr_indx == 0 ) goto done;
/*
* copy selected state-records to output array
*/
*states_out = (struct mds0_states *)
malloc( nr_indx * sizeof( struct mds0_states ));
if ( *states_out == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "mds0_states" );
for ( ni = 0; ni < nr_indx; ni++ ) {
(void) memcpy( &(*states_out)[ni].mjd, &states[indx_states[ni]].mjd,
sizeof(struct mjd_envi) );
(*states_out)[ni].category = states[indx_states[ni]].category;
(*states_out)[ni].state_id = states[indx_states[ni]].state_id;
(*states_out)[ni].q_aux.value = states[indx_states[ni]].q_aux.value ;
(*states_out)[ni].q_det.value = states[indx_states[ni]].q_det.value ;
(*states_out)[ni].q_pmd.value = states[indx_states[ni]].q_pmd.value ;
(*states_out)[ni].num_aux = states[indx_states[ni]].num_aux;
(*states_out)[ni].num_det = states[indx_states[ni]].num_det;
(*states_out)[ni].num_pmd = states[indx_states[ni]].num_pmd;
(*states_out)[ni].on_board_time =
states[indx_states[ni]].on_board_time;
(*states_out)[ni].offset = states[indx_states[ni]].offset;
if ( param.write_aux == PARAM_UNSET ) {
(*states_out)[ni].num_aux = 0;
(*states_out)[ni].info_aux = NULL;
} else if ( (*states_out)[ni].num_aux > 0 ) {
size_t num_aux = (*states_out)[ni].num_aux;
(*states_out)[ni].info_aux = (struct mds0_info *)
malloc( num_aux * sizeof(struct mds0_info));
(void) memcpy( (*states_out)[ni].info_aux,
states[indx_states[ni]].info_aux,
num_aux * sizeof(struct mds0_info) );
}
if ( param.write_det == PARAM_UNSET ) {
(*states_out)[ni].num_det = 0;
(*states_out)[ni].info_det = NULL;
} else if ( (*states_out)[ni].num_det > 0 ) {
size_t num_det = (*states_out)[ni].num_det;
(*states_out)[ni].info_det = (struct mds0_info *)
malloc( num_det * sizeof(struct mds0_info));
(void) memcpy( (*states_out)[ni].info_det,
states[indx_states[ni]].info_det,
num_det * sizeof(struct mds0_info) );
}
if ( param.write_pmd == PARAM_UNSET ) {
(*states_out)[ni].num_pmd = 0;
(*states_out)[ni].info_pmd = NULL;
} else if ( (*states_out)[ni].num_pmd > 0 ) {
size_t num_pmd = (*states_out)[ni].num_pmd;
(*states_out)[ni].info_pmd = (struct mds0_info *)
malloc( num_pmd * sizeof(struct mds0_info));
(void) memcpy( (*states_out)[ni].info_pmd,
states[indx_states[ni]].info_pmd,
num_pmd * sizeof(struct mds0_info) );
}
}
done:
if ( indx_states != NULL ) free( indx_states );
return nr_indx;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
int main( int argc, char *argv[] )
{
bool flag_remove = FALSE;
bool flag_replace = FALSE;
char flname[MAX_STRING_LENGTH];
char *cpntr, ctemp[SHORT_STRING_LENGTH];
int ncid;
int retval;
struct imap_hdr hdr;
struct imap_rec *rec = NULL;
#ifdef _WITH_SQL
PGconn *conn = NULL;
#endif
/*
* check command-line parameters
*/
if ( argc > 2 ) {
register int nr = 1;
do {
if ( strncmp( argv[nr], "-remove", 7 ) == 0 )
flag_remove = TRUE;
else if ( strncmp( argv[nr], "-replace", 8 ) == 0 )
flag_replace = TRUE;
else
NADC_GOTO_ERROR( NADC_ERR_PARAM, NADC_PARAMS );
} while( ++nr < (argc-1) );
(void) nadc_strlcpy( flname, argv[argc-1], MAX_STRING_LENGTH );
} else if ( argc == 2 ) {
(void) nadc_strlcpy( flname, argv[1], MAX_STRING_LENGTH );
} else
NADC_GOTO_ERROR( NADC_ERR_PARAM, NADC_PARAMS );
/*
* strip path of file-name
*/
if ( (cpntr = strrchr( flname, '/' )) != NULL ) {
(void) nadc_strlcpy( ctemp, ++cpntr, SHORT_STRING_LENGTH );
} else {
(void) nadc_strlcpy( ctemp, flname, SHORT_STRING_LENGTH );
}
/*
* read the IMAP CH4 product
*/
if ( (retval = nc_open( flname, NC_NOWRITE, &ncid )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
SCIA_RD_NC_CH4_META( ncid, &hdr );
if ( hdr.numProd > 1 )
NADC_GOTO_ERROR( NADC_ERR_FATAL,
"no more than one orbit per ingest" );
(void) nadc_strlcpy( hdr.product, ctemp, SHORT_STRING_LENGTH );
NADC_RECEIVEDATE( flname, hdr.receive_date );
hdr.file_size = nadc_file_size( flname );
hdr.numRec = SCIA_RD_NC_CH4_REC( ncid, &rec );
if ( (retval = nc_close( ncid )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
if ( IS_ERR_STAT_FATAL )
NADC_GOTO_ERROR( NADC_ERR_FILE_RD, flname );
/*
* connect to PostgreSQL database
*/
#ifdef _WITH_SQL
CONNECT_NADC_DB( &conn, "scia" );
if ( IS_ERR_STAT_FATAL ) {
NADC_ERROR( NADC_ERR_SQL, "IMAP (connect)" );
NADC_Err_Trace( stderr );
return NADC_ERR_FATAL;
}
if ( flag_remove || flag_replace ) {
SCIA_DEL_ENTRY_IMAP_CH4( conn, hdr.product );
if ( IS_ERR_STAT_FATAL )
NADC_GOTO_ERROR( NADC_ERR_SQL, "IMAP (remove)" );
}
/*
* write meta-information to database
*/
if ( ! flag_remove ) {
SCIA_WR_SQL_CH4_META( conn, &hdr );
if ( IS_ERR_STAT_FATAL ) {
NADC_ERROR( NADC_ERR_SQL, "IMAP (header)" );
} else {
SCIA_WR_SQL_CH4_TILE( conn, hdr.product, hdr.numRec, rec );
if ( IS_ERR_STAT_FATAL )
NADC_ERROR( NADC_ERR_SQL, "IMAP (records)" );
}
}
#endif
done:
/*
* close connection to PostgreSQL database
*/
#ifdef _WITH_SQL
if ( conn != NULL ) PQfinish( conn );
#endif
/*
* free allocated memory
*/
if ( rec != NULL ) free( rec );
/*
* display error messages
*/
NADC_Err_Trace( stderr );
if ( IS_ERR_STAT_FATAL )
return NADC_ERR_FATAL;
else
return NADC_ERR_NONE;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
unsigned
int SCIA_LV2_RD_BIAS( FILE *fd, const char bias_name[],
unsigned int num_dsd, const struct dsd_envi *dsd,
struct bias_scia **bias_out )
{
char *bias_pntr, *bias_char = NULL;
size_t dsd_size, nr_byte;
unsigned int indx_dsd;
unsigned int n_cross;
unsigned int nr_dsr = 0;
struct bias_scia *bias;
/*
* get index to data set descriptor
*/
indx_dsd = ENVI_GET_DSD_INDEX( num_dsd, dsd, bias_name );
if ( IS_ERR_STAT_FATAL )
NADC_GOTO_ERROR( NADC_ERR_PDS_RD, bias_name );
if ( dsd[indx_dsd].size == 0u ) return 0;
if ( ! Use_Extern_Alloc ) {
bias_out[0] = (struct bias_scia *)
malloc( dsd[indx_dsd].num_dsr * sizeof(struct bias_scia));
}
if ( (bias = bias_out[0]) == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "bias" );
/*
* allocate memory to temporary store data for output structure
*/
dsd_size = (size_t) dsd[indx_dsd].size;
if ( (bias_char = (char *) malloc( dsd_size )) == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "bias_char" );
/*
* rewind/read input data file
*/
(void) fseek( fd, (long) dsd[indx_dsd].offset, SEEK_SET );
if ( fread( bias_char, dsd_size, 1, fd ) != 1 )
NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" );
/*
* read data buffer to BIAS structure
*/
bias_pntr = bias_char;
do {
(void) memcpy( &bias->mjd.days, bias_pntr, ENVI_INT );
bias_pntr += ENVI_INT;
(void) memcpy( &bias->mjd.secnd, bias_pntr, ENVI_UINT );
bias_pntr += ENVI_UINT;
(void) memcpy( &bias->mjd.musec, bias_pntr, ENVI_UINT );
bias_pntr += ENVI_UINT;
(void) memcpy( &bias->dsrlen, bias_pntr, ENVI_UINT );
bias_pntr += ENVI_UINT;
(void) memcpy( &bias->quality, bias_pntr, ENVI_CHAR );
bias_pntr += ENVI_CHAR;
(void) memcpy( &bias->intg_time, bias_pntr, ENVI_USHRT );
bias_pntr += ENVI_USHRT;
(void) memcpy( &bias->numfitp, bias_pntr, ENVI_USHRT );
bias_pntr += ENVI_USHRT;
#ifdef _SWAP_TO_LITTLE_ENDIAN
bias->numfitp = byte_swap_u16( bias->numfitp );
#endif
(void) memcpy( &bias->numsegm, bias_pntr, ENVI_USHRT );
bias_pntr += ENVI_USHRT;
(void) memcpy( &bias->hght, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->errhght, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->hghtflag, bias_pntr, ENVI_USHRT );
bias_pntr += ENVI_USHRT;
(void) memcpy( &bias->vcd, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->errvcd, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->closure, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->errclosure, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->rms, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->chi2, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->goodness, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->cutoff, bias_pntr, ENVI_FLOAT );
bias_pntr += ENVI_FLOAT;
(void) memcpy( &bias->numiter, bias_pntr, ENVI_USHRT );
bias_pntr += ENVI_USHRT;
n_cross = (bias->numfitp * (bias->numfitp - 1u)) / 2u;
nr_byte = (size_t) n_cross * sizeof( float );
bias->corrpar = (float *) malloc( nr_byte );
if ( bias->corrpar == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "corrpar" );
(void) memcpy( bias->corrpar, bias_pntr, nr_byte );
bias_pntr += nr_byte;
(void) memcpy( &bias->vcdflag, bias_pntr, ENVI_USHRT );
bias_pntr += ENVI_USHRT;
#ifdef _SWAP_TO_LITTLE_ENDIAN
Sun2Intel_BIAS( bias );
#endif
bias++;
} while ( ++nr_dsr < dsd[indx_dsd].num_dsr );
/*
* check if we read the whole DSR
*/
if ( (unsigned int)(bias_pntr - bias_char) != dsd[indx_dsd].size )
NADC_GOTO_ERROR( NADC_ERR_PDS_SIZE, bias_name );
bias_pntr = NULL;
/*
* set return values
*/
done:
if ( bias_char != NULL ) free( bias_char );
return nr_dsr;
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
void SCIA_OL2_WR_SQL_META( PGconn *conn, bool be_verbose, const char *sciafl,
const char *l1b_product,
const struct mph_envi *mph,
const struct sph_sci_ol *sph )
{
PGresult *res;
char *pntr;
char str_quality[6];
char ctemp[SHORT_STRING_LENGTH];
char sql_query[SQL_STR_SIZE], cbuff[SQL_STR_SIZE];
bool first;
int nrow, numChar, meta_id;
/*
* check if product is already in database
*/
(void) snprintf( sql_query, MAX_STRING_LENGTH, "%s\'%s\'",
"SELECT * FROM meta__2P WHERE name=", mph->product );
res = PQexec( conn, sql_query );
if ( PQresultStatus( res ) != PGRES_TUPLES_OK ) {
PQclear( res );
NADC_RETURN_ERROR( NADC_ERR_SQL, PQresultErrorMessage(res) );
}
if ( (nrow = PQntuples( res )) != 0 ) {
PQclear( res );
NADC_RETURN_ERROR( NADC_ERR_SQL_TWICE, mph->product );
}
PQclear( res );
/*
* obtain next value for serial pk_meta
*/
res = PQexec( conn,
"SELECT nextval(\'meta__2p_pk_meta_seq\')" );
if ( PQresultStatus( res ) != PGRES_TUPLES_OK )
NADC_GOTO_ERROR( NADC_ERR_SQL, PQresultErrorMessage(res) );
pntr = PQgetvalue( res, 0, 0 );
meta_id = (int) strtol( pntr, (char **) NULL, 10 );
PQclear( res );
/*
* no error and not yet stored, then proceed
*/
/* pk_meta */
(void) snprintf( sql_query, SQL_STR_SIZE,
"INSERT INTO meta__2P VALUES (%d,", meta_id );
/* name */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s\'%s\',",
strcpy(cbuff,sql_query), mph->product );
/* l1b_product */
(void) nadc_strlcpy( ctemp, l1b_product, ENVI_FILENAME_SIZE );
SCIA_CHECK_SQL_LV1B_NAME( conn, ctemp );
(void) snprintf( sql_query, SQL_STR_SIZE, "%s\'%s\',",
strcpy(cbuff,sql_query), ctemp );
/* fileSize */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%u,",
strcpy(cbuff,sql_query), mph->tot_size );
/* receiveDate */
NADC_RECEIVEDATE( sciafl, ctemp );
(void) snprintf( sql_query, SQL_STR_SIZE, "%s\'%s\',",
strcpy(cbuff,sql_query), ctemp );
/* procStage */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s\'%s\',",
strcpy(cbuff,sql_query), mph->proc_stage );
/* procCenter */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s\'%s\',",
strcpy(cbuff,sql_query), mph->proc_center );
/* softVersion */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s\'%s\',",
strcpy(cbuff,sql_query), mph->soft_version );
/* fittingErrSum */
nadc_rstrip( str_quality, sph->errorsum );
(void) snprintf( sql_query, SQL_STR_SIZE, "%s\'%s\',",
strcpy(cbuff,sql_query), str_quality );
/* dateTimeStart */
(void) snprintf( sql_query, SQL_STR_SIZE,
"%sdate_trunc('second', TIMESTAMP \'%s\'),",
strcpy(cbuff,sql_query), sph->start_time );
/* muSecStart */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s,",
strcpy(cbuff,sql_query), sph->start_time+21 );
/* dateTimeStop */
(void) snprintf( sql_query, SQL_STR_SIZE,
"%sdate_trunc('second', TIMESTAMP \'%s\'),",
strcpy(cbuff,sql_query), sph->stop_time );
/* muSecStop */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s,",
strcpy(cbuff,sql_query), sph->stop_time+21 );
/* absOrbit */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%d,",
strcpy(cbuff,sql_query), mph->abs_orbit );
/* relOrbit */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%d,",
strcpy(cbuff,sql_query), mph->rel_orbit );
/* numDataSets */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%u,",
strcpy(cbuff,sql_query), mph->num_data_sets );
/* naditFittingWindows */
first = TRUE;
(void) strcat( sql_query, "\'" );
if ( strncmp( sph->nadir_win_uv0, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_uv0, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_uv1, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_uv1, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_uv2, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_uv2, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_uv3, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_uv3, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_uv4, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_uv4, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_uv5, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_uv5, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_uv6, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_uv6, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_uv7, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_uv7, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_ir0, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_ir0, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_ir1, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_ir1, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_ir2, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_ir2, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_ir3, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_ir3, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_ir4, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_ir4, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->nadir_win_ir5, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->nadir_win_ir5, ctemp );
if ( ! first ) strcat( sql_query, "," );
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
(void) strcat( sql_query, "\'," );
/* limbFittingWindows */
first = TRUE;
(void) strcat( sql_query, "\'" );
if ( strncmp( sph->limb_win_pth, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_pth, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_uv0, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_uv0, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_uv1, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_uv1, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_uv2, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_uv2, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_uv3, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_uv3, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_uv4, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_uv4, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_uv5, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_uv5, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_uv6, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_uv6, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_uv7, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_uv7, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_ir0, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_ir0, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_ir1, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_ir1, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_ir2, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_ir2, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_ir3, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_ir3, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->limb_win_ir4, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->limb_win_ir4, ctemp );
if ( ! first ) strcat( sql_query, "," );
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
(void) strcat( sql_query, "\'," );
/* occultFittingWindows */
first = TRUE;
(void) strcat( sql_query, "\'" );
if ( strncmp( sph->occl_win_pth, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_pth, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_uv0, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_uv0, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_uv1, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_uv1, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_uv2, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_uv2, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_uv3, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_uv3, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_uv4, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_uv4, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_uv5, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_uv5, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_uv6, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_uv6, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_uv7, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_uv7, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_ir0, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_ir0, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_ir1, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_ir1, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_ir2, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_ir2, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_ir3, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_ir3, ctemp );
if ( ! first ) strcat( sql_query, "," ); else first = FALSE;
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
if ( strncmp( sph->occl_win_ir4, "EMPTY", 5 ) != 0 ) {
NADC_STRIP( sph->occl_win_ir4, ctemp );
if ( ! first ) strcat( sql_query, "," );
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%s",
strcpy(cbuff,sql_query), ctemp );
}
(void) strcat( sql_query, "\'," );
/* numNadirFW */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%hu,",
strcpy(cbuff,sql_query), sph->no_nadir_win );
/* numLimbFW */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%hu,",
strcpy(cbuff,sql_query), sph->no_limb_win );
/* numOccultFW */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%hu,",
strcpy(cbuff,sql_query), sph->no_occl_win );
/* noEntryDMOP */
(void) snprintf( sql_query, SQL_STR_SIZE, "%s%d,",
strcpy(cbuff,sql_query), 0 );
/* delayedBy */
numChar = snprintf( sql_query, SQL_STR_SIZE, "%s%s)",
strcpy( cbuff, sql_query ), "NULL" );
if ( be_verbose )
(void) printf( "%s(): %s [%-d]\n", __func__, sql_query, numChar );
if ( numChar >= SQL_STR_SIZE )
NADC_RETURN_ERROR( NADC_ERR_STRLEN, "sql_query" );
/*
* do the actual insert
*/
res = PQexec( conn, sql_query );
if ( PQresultStatus( res ) != PGRES_COMMAND_OK )
NADC_GOTO_ERROR( NADC_ERR_SQL, PQresultErrorMessage(res) );
done:
PQclear( res );
}
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/
unsigned
int SCIA_OL2_RD_LFIT( FILE *fd, const char lfit_name[],
unsigned int num_dsd, const struct dsd_envi *dsd,
struct lfit_scia **lfit_out )
{
register unsigned short nl;
char *lfit_pntr, *lfit_char = NULL;
size_t dsd_size;
unsigned int indx_dsd, n_rec;
unsigned int nr_dsr = 0;
struct lfit_scia *lfit;
/*
* get index to data set descriptor
*/
NADC_ERR_SAVE();
indx_dsd = ENVI_GET_DSD_INDEX( num_dsd, dsd, lfit_name );
if ( IS_ERR_STAT_FATAL || IS_ERR_STAT_ABSENT )
NADC_GOTO_ERROR( NADC_ERR_PDS_RD, lfit_name );
if ( IS_ERR_STAT_ABSENT || dsd[indx_dsd].num_dsr == 0 ) {
NADC_ERR_RESTORE();
lfit_out[0] = NULL;
return 0u;
}
dsd_size = (size_t) dsd[indx_dsd].size;
/*
* allocate memory to store output structures
*/
if ( ! Use_Extern_Alloc ) {
lfit_out[0] = (struct lfit_scia *)
malloc( dsd[indx_dsd].num_dsr * sizeof(struct lfit_scia));
}
if ( (lfit = lfit_out[0]) == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "lfit" );
/*
* allocate memory to temporary store data for output structure
*/
if ( (lfit_char = (char *) malloc( dsd_size )) == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "lfit_char" );
/*
* rewind/read input data file
*/
(void) fseek( fd, (long) dsd[indx_dsd].offset, SEEK_SET );
if ( fread( lfit_char, dsd_size, 1, fd ) != 1 )
NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" );
/*
* read data buffer to LFIT structure
*/
lfit_pntr = lfit_char;
do {
(void) memcpy( &lfit->mjd.days, lfit_pntr, ENVI_INT );
lfit_pntr += ENVI_INT;
(void) memcpy( &lfit->mjd.secnd, lfit_pntr, ENVI_UINT );
lfit_pntr += ENVI_UINT;
(void) memcpy( &lfit->mjd.musec, lfit_pntr, ENVI_UINT );
lfit_pntr += ENVI_UINT;
(void) memcpy( &lfit->dsrlen, lfit_pntr, ENVI_UINT );
lfit_pntr += ENVI_UINT;
(void) memcpy( &lfit->quality, lfit_pntr, ENVI_CHAR );
lfit_pntr += ENVI_CHAR;
(void) memcpy( &lfit->intg_time, lfit_pntr, ENVI_USHRT );
lfit_pntr += ENVI_USHRT;
(void) memcpy( &lfit->method, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( &lfit->refh, lfit_pntr, ENVI_FLOAT );
lfit_pntr += ENVI_FLOAT;
(void) memcpy( &lfit->refp, lfit_pntr, ENVI_FLOAT );
lfit_pntr += ENVI_FLOAT;
(void) memcpy( &lfit->refpsrc, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( &lfit->num_rlevel, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( &lfit->num_mlevel, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( &lfit->num_species, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( &lfit->num_closure, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( &lfit->num_other, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( &lfit->num_scale, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
if ( lfit->num_rlevel > 0u ) {
lfit->tangh = (float *)
malloc( lfit->num_rlevel * sizeof(float) );
if ( lfit->tangh == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "tangh" );
(void) memcpy( lfit->tangh, lfit_pntr,
lfit->num_rlevel * ENVI_FLOAT );
lfit_pntr += lfit->num_rlevel * ENVI_FLOAT;
lfit->tangp = (float *)
malloc( lfit->num_rlevel * sizeof(float) );
if ( lfit->tangp == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "tangp" );
(void) memcpy( lfit->tangp, lfit_pntr,
lfit->num_rlevel * ENVI_FLOAT );
lfit_pntr += lfit->num_rlevel * ENVI_FLOAT;
lfit->tangt = (float *)
malloc( lfit->num_rlevel * sizeof(float) );
if ( lfit->tangt == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "tangt" );
(void) memcpy( lfit->tangt, lfit_pntr,
lfit->num_rlevel * ENVI_FLOAT );
lfit_pntr += lfit->num_rlevel * ENVI_FLOAT;
}
n_rec = lfit->num_rlevel * lfit->num_species;
if ( n_rec > 0u ) {
lfit->mainrec = (struct layer_rec *)
malloc( n_rec * sizeof( struct layer_rec ));
if ( lfit->mainrec == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "mainrec" );
(void) memcpy( lfit->mainrec, lfit_pntr,
n_rec * sizeof(struct layer_rec) );
lfit_pntr += n_rec * sizeof(struct layer_rec);
}
n_rec = lfit->num_rlevel * lfit->num_scale;
if ( n_rec > 0u ) {
lfit->scaledrec = (struct layer_rec *)
malloc( n_rec * sizeof( struct layer_rec ));
if ( lfit->scaledrec == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "scaledrec" );
(void) memcpy( lfit->scaledrec, lfit_pntr,
n_rec * sizeof(struct layer_rec) );
lfit_pntr += n_rec * sizeof(struct layer_rec);
}
/*
* note that meas_grid is not aligned
*/
if ( lfit->num_mlevel > 0u ) {
lfit->mgrid = (struct meas_grid *)
malloc( lfit->num_mlevel * sizeof( struct meas_grid ));
if ( lfit->mgrid == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "mgrid" );
nl = 0;
do {
(void) memcpy( &lfit->mgrid[nl].mjd.days, lfit_pntr,
ENVI_INT );
lfit_pntr += ENVI_INT;
(void) memcpy( &lfit->mgrid[nl].mjd.secnd, lfit_pntr,
ENVI_UINT );
lfit_pntr += ENVI_UINT;
(void) memcpy( &lfit->mgrid[nl].mjd.musec, lfit_pntr,
ENVI_UINT );
lfit_pntr += ENVI_UINT;
(void) memcpy( &lfit->mgrid[nl].tangh, lfit_pntr,
ENVI_FLOAT );
lfit_pntr += ENVI_FLOAT;
(void) memcpy( &lfit->mgrid[nl].tangp, lfit_pntr,
ENVI_FLOAT );
lfit_pntr += ENVI_FLOAT;
(void) memcpy( &lfit->mgrid[nl].tangt, lfit_pntr,
ENVI_FLOAT );
lfit_pntr += ENVI_FLOAT;
(void) memcpy( &lfit->mgrid[nl].num_win, lfit_pntr,
ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( lfit->mgrid[nl].win_limits, lfit_pntr,
2 * ENVI_FLOAT );
lfit_pntr += 2 * ENVI_FLOAT;
} while ( ++nl < lfit->num_mlevel );
}
(void) memcpy( &lfit->stvec_size, lfit_pntr, ENVI_USHRT );
lfit_pntr += ENVI_USHRT;
#ifdef _SWAP_TO_LITTLE_ENDIAN
lfit->stvec_size = byte_swap_u16( lfit->stvec_size );
#endif
if ( lfit->stvec_size > 0u ) {
lfit->statevec = (struct state_vec *)
malloc( lfit->stvec_size * sizeof(struct state_vec) );
if ( lfit->statevec == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "statevec" );
(void) memcpy( lfit->statevec, lfit_pntr,
lfit->stvec_size * sizeof( struct state_vec ));
lfit_pntr += lfit->stvec_size * sizeof( struct state_vec );
}
(void) memcpy( &lfit->cmatrixsize, lfit_pntr, ENVI_USHRT );
lfit_pntr += ENVI_USHRT;
#ifdef _SWAP_TO_LITTLE_ENDIAN
lfit->cmatrixsize = byte_swap_u16( lfit->cmatrixsize );
#endif
if ( lfit->cmatrixsize > 0u ) {
lfit->corrmatrix = (float *)
malloc((size_t) lfit->cmatrixsize * ENVI_FLOAT );
if ( lfit->corrmatrix == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "corrmatrix" );
(void) memcpy( lfit->corrmatrix, lfit_pntr,
lfit->cmatrixsize * ENVI_FLOAT );
lfit_pntr += lfit->cmatrixsize * ENVI_FLOAT ;
}
(void) memcpy( &lfit->rms, lfit_pntr, ENVI_FLOAT );
lfit_pntr += ENVI_FLOAT;
(void) memcpy( &lfit->chi2, lfit_pntr, ENVI_FLOAT );
lfit_pntr += ENVI_FLOAT;
(void) memcpy( &lfit->goodness, lfit_pntr, ENVI_FLOAT );
lfit_pntr += ENVI_FLOAT;
(void) memcpy( &lfit->numiter, lfit_pntr, ENVI_USHRT );
lfit_pntr += ENVI_USHRT;
(void) memcpy( lfit->summary, lfit_pntr, 2 * ENVI_USHRT );
lfit_pntr += 2 * ENVI_USHRT;
(void) memcpy( &lfit->criteria, lfit_pntr, ENVI_UCHAR );
lfit_pntr += ENVI_UCHAR;
(void) memcpy( &lfit->ressize, lfit_pntr, ENVI_USHRT );
lfit_pntr += ENVI_USHRT;
#ifdef _SWAP_TO_LITTLE_ENDIAN
lfit->ressize = byte_swap_u16( lfit->ressize );
#endif
if ( lfit->ressize > 0u ) {
lfit->residuals = (float *)
malloc((size_t) lfit->ressize * ENVI_FLOAT );
if ( lfit->residuals == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "residuals" );
(void) memcpy( lfit->residuals, lfit_pntr,
lfit->ressize * ENVI_FLOAT );
lfit_pntr += lfit->ressize * ENVI_FLOAT ;
}
(void) memcpy( &lfit->num_adddiag, lfit_pntr, ENVI_USHRT );
lfit_pntr += ENVI_USHRT;
#ifdef _SWAP_TO_LITTLE_ENDIAN
lfit->num_adddiag = byte_swap_u16( lfit->num_adddiag );
#endif
if ( lfit->num_adddiag > 0u ) {
lfit->adddiag = (float *)
malloc((size_t) lfit->num_adddiag * ENVI_FLOAT );
if ( lfit->adddiag == NULL )
NADC_GOTO_ERROR( NADC_ERR_ALLOC, "adddiag" );
(void) memcpy( lfit->adddiag, lfit_pntr,
lfit->num_adddiag * ENVI_FLOAT );
lfit_pntr += lfit->num_adddiag * ENVI_FLOAT ;
}
#ifdef _SWAP_TO_LITTLE_ENDIAN
Sun2Intel_LFIT( lfit );
#endif
lfit++;
} while ( ++nr_dsr < dsd[indx_dsd].num_dsr );
/*
* check if we read the whole DSR
*/
if ( (unsigned int)(lfit_pntr - lfit_char) != dsd[indx_dsd].size )
NADC_GOTO_ERROR( NADC_ERR_PDS_SIZE, lfit_name );
lfit_pntr = NULL;
/*
* set return values
*/
done:
if ( lfit_char != NULL ) free( lfit_char );
return nr_dsr;
}
/*+++++++++++++++++++++++++
.IDENTifer SDMF_get_OrbitalDark_24
.PURPOSE obtain dark correction parameters (SDMF v2.4.x)
.INPUT/OUTPUT
call as found = SDMF_get_OrbitalDark_24( orbit, orbitPhase
analogOffs, darkCurrent,
analogOffsError, darkCurrentError );
input:
unsigned short absOrbit : orbit number
float orbitPhase : orbit phase (ESA definition)
in/output:
float *analogOffs : analog offset (BU)
float *darkCurrent : leakage current (BU/s)
float *analogOffsError : analog offset error (BU)
float *darkCurrentError : leakage current error (BU/s)
.RETURNS solution found (True or False)
error status passed by global variable ``nadc_stat''
.COMMENTS none
-------------------------*/
bool SDMF_get_OrbitalDark_24( unsigned short absOrbit, float orbitPhase,
float *analogOffs, float *darkCurrent,
float *analogOffsError, float *darkCurrentError )
{
const int orbit = (int) absOrbit;
const unsigned short numOrbitDark = 72;
const long sz_chan_byte = CHANNEL_SIZE * ENVI_FLOAT;
const long sz_ds_byte = numOrbitDark * sz_chan_byte;
register unsigned short nd, np;
bool fnd, found = FALSE;
char dark_fl[MAX_STRING_LENGTH];
FILE *dark_fp;
float rbuff[CHANNEL_SIZE], orbitDark[numOrbitDark * CHANNEL_SIZE];
unsigned short nd_low, nd_high;
const float orbitPhaseDiff = SDMF_orbitPhaseDiff( orbit );
/*
* read constant dark parameters from SDMF database
*/
fnd = SDMF_get_FittedDark_24( 8, absOrbit, analogOffs, darkCurrent,
analogOffsError, darkCurrentError, NULL );
if ( ! fnd )
NADC_GOTO_ERROR( NADC_ERR_FATAL,
"No dark entry found in SDMF (v2.4)" );
/*
* convert orbit phase to SDMF definition:
* orbitPhase(ESA) = orbitPhaseDiff + orbitPhase(SDMF);
*/
orbitPhase -= orbitPhaseDiff;
if ( orbitPhase < 0.f ) orbitPhase += 1.f;
/*
* find file with dark signals, requirements:
* - orbit number within a range MAX_DiffOrbitNumber
*/
if ( ! SDMF_get_fileEntry( SDMF24_ORBITAL, orbit, dark_fl ) ) return FALSE;
/*
* read dark parameters
*/
if ( (dark_fp = fopen( dark_fl, "r" )) == NULL )
NADC_GOTO_ERROR( NADC_ERR_FILE, dark_fl );
if ( fread( orbitDark, sz_ds_byte, 1, dark_fp ) != 1 )
NADC_GOTO_ERROR( NADC_ERR_FILE_RD, "orbitDark" );
(void) fclose( dark_fp );
found = TRUE;
/*
* linear interpolate to get the variable fraction of the leakage current
*/
for ( nd = 0; nd < numOrbitDark; nd++ )
if ( orbitPhase <= ((float) nd / numOrbitDark) ) break;
nd_low = (nd > 0u) ? nd - 1u : 0u;
nd_high = (nd < numOrbitDark) ? nd : nd - 1u;
NADC_INTERPOL( orbitPhase, ((float) nd_low / numOrbitDark),
((float) nd_high / numOrbitDark), CHANNEL_SIZE,
&orbitDark[nd_low * CHANNEL_SIZE],
&orbitDark[nd_high * CHANNEL_SIZE], rbuff );
/*
* add orbital dark correction to dark current
*/
for ( np = 0; np < CHANNEL_SIZE; np++ ) {
if ( isnormal( darkCurrent[np] ) && isnormal( rbuff[np] ) )
darkCurrent[np] += rbuff[np];
}
done:
return found;
}
/*+++++++++++++++++++++++++
.IDENTifer SDMF_get_OrbitalDark_30
.PURPOSE obtain dark correction parameters (SDMF v3.0)
.INPUT/OUTPUT
call as found = SDMF_get_OrbitalDark_30( orbit, orbitPhase
analogOffs, darkCurrent,
analogOffsError, darkCurrentError );
input:
unsigned short absOrbit : orbit number
float orbitPhase : orbit phase
in/output:
float *analogOffs : analog offset (BU)
float *darkCurrent : leakage current (BU/s)
float *analogOffsError : analog offset error (BU)
float *darkCurrentError : leakage current error (BU/s)
.RETURNS solution found (True or False)
error status passed by global variable ``nadc_stat''
.COMMENTS none
-------------------------*/
bool SDMF_get_OrbitalDark_30( unsigned short absOrbit, float orbitPhase,
float *analogOffs, float *darkCurrent,
float *analogOffsError, float *darkCurrentError )
{
register unsigned short np;
hid_t fid = -1;
hid_t gid = -1;
bool found = FALSE;
int numIndx, metaIndx;
float orbvar, orbsig;
float amp1[CHANNEL_SIZE], sig_amp1[CHANNEL_SIZE];
char str_msg[MAX_STRING_LENGTH];
char sdmf_db[MAX_STRING_LENGTH];
struct mtbl_simudark_rec *mtbl = NULL;
const int orbit = (int) absOrbit;
const int pixelRange[] = {0, CHANNEL_SIZE-1};
const long sz_chan_byte = CHANNEL_SIZE * ENVI_FLOAT;
const char msg_found[] =
"\n\tapplied SDMF SimuDark (v3.0) of orbit: %-d";
/*
* initialize returned values
*/
(void) memset( analogOffs, 0, sz_chan_byte );
(void) memset( darkCurrent, 0, sz_chan_byte );
(void) memset( analogOffsError, 0, sz_chan_byte );
(void) memset( darkCurrentError, 0, sz_chan_byte );
/*
* open SDMF simu-dark database
*/
(void) snprintf( sdmf_db, MAX_STRING_LENGTH, "%s/%s",
SDMF_PATH("3.0"), "sdmf_simudark.h5" );
H5E_BEGIN_TRY {
fid = H5Fopen( sdmf_db, H5F_ACC_RDONLY, H5P_DEFAULT );
} H5E_END_TRY;
if ( fid < 0 ) NADC_GOTO_ERROR( NADC_ERR_HDF_FILE, sdmf_db );
if ( (gid = H5Gopen( fid, "ch8", H5P_DEFAULT )) < 0 )
NADC_GOTO_ERROR( NADC_ERR_HDF_GRP, "/ch8" );
/*
* obtain indices relevant entries
*/
numIndx = 1;
metaIndx = -1;
(void) SDMF_get_metaIndex( gid, orbit, &numIndx, &metaIndx );
if ( numIndx == 0 ) goto done;
found = TRUE;
/*
* read simu-dark data
*/
SDMF_rd_simudarkTable( gid, &numIndx, &metaIndx, &mtbl );
SDMF_rd_float_Array( gid, "ao", 1, &metaIndx, pixelRange, analogOffs );
SDMF_rd_float_Array( gid, "lc", 1, &metaIndx, pixelRange, darkCurrent );
SDMF_rd_float_Array( gid, "sig_ao", 1, &metaIndx, pixelRange,
analogOffsError );
SDMF_rd_float_Array( gid, "sig_lc", 1, &metaIndx, pixelRange,
darkCurrentError );
SDMF_rd_float_Array( gid, "amp1", 1, &metaIndx, pixelRange, amp1 );
SDMF_rd_float_Array( gid, "sig_amp1", 1, &metaIndx, pixelRange, sig_amp1 );
/*
* calculate orbital dark for requested orbit-phase
*/
orbvar = (float)
(cos(2 * PI * (mtbl->orbitPhase + orbitPhase))
+ mtbl->amp2 * cos(4 * PI * (mtbl->phase2 + orbitPhase)));
orbsig = (float)
(cos(2 * PI * (mtbl->orbitPhase + orbitPhase))
+ mtbl->sig_amp2 * cos(4 * PI * (mtbl->phase2 + orbitPhase)));
for ( np = 0; np < CHANNEL_SIZE; np++ ) {
darkCurrent[np] += orbvar * amp1[np];
darkCurrentError[np] += orbsig * sig_amp1[np];
}
(void) snprintf( str_msg, SHORT_STRING_LENGTH, msg_found, mtbl->absOrbit );
NADC_ERROR( NADC_ERR_NONE, str_msg );
done:
if ( mtbl != NULL ) free( mtbl );
if ( gid > 0 ) H5Gclose( gid );
if ( fid > 0 ) H5Fclose( fid );
return found;
}
