static void Sun2Intel_DOAS( struct doas_scia *doas ) { register unsigned short nc; unsigned int n_cross; doas->mjd.days = byte_swap_32( doas->mjd.days ); doas->mjd.secnd = byte_swap_u32( doas->mjd.secnd ); doas->mjd.musec = byte_swap_u32( doas->mjd.musec ); doas->dsrlen = byte_swap_u32( doas->dsrlen ); doas->intg_time = byte_swap_u16( doas->intg_time ); IEEE_Swap__FLT( &doas->vcd ); IEEE_Swap__FLT( &doas->errvcd ); IEEE_Swap__FLT( &doas->esc ); IEEE_Swap__FLT( &doas->erresc ); IEEE_Swap__FLT( &doas->rms ); IEEE_Swap__FLT( &doas->chi2 ); IEEE_Swap__FLT( &doas->goodness ); IEEE_Swap__FLT( &doas->amfgnd ); IEEE_Swap__FLT( &doas->amfcld ); IEEE_Swap__FLT( &doas->reflgnd ); IEEE_Swap__FLT( &doas->reflcld ); IEEE_Swap__FLT( &doas->refl ); doas->numiter = byte_swap_u16( doas->numiter ); n_cross = (doas->numfitp * (doas->numfitp - 1)) / 2; for ( nc = 0; nc < n_cross; nc++ ) IEEE_Swap__FLT( &doas->corrpar[nc] ); }
static void Sun2Intel_BIAS( struct bias_scia *bias ) { register unsigned short nc; unsigned int n_cross; bias->mjd.days = byte_swap_32( bias->mjd.days ); bias->mjd.secnd = byte_swap_u32( bias->mjd.secnd ); bias->mjd.musec = byte_swap_u32( bias->mjd.musec ); bias->dsrlen = byte_swap_u32( bias->dsrlen ); bias->intg_time = byte_swap_u16( bias->intg_time ); bias->numsegm = byte_swap_u16( bias->numsegm ); IEEE_Swap__FLT( &bias->hght ); IEEE_Swap__FLT( &bias->errhght ); IEEE_Swap__FLT( &bias->vcd ); IEEE_Swap__FLT( &bias->errvcd ); IEEE_Swap__FLT( &bias->closure ); IEEE_Swap__FLT( &bias->errclosure ); IEEE_Swap__FLT( &bias->rms ); IEEE_Swap__FLT( &bias->chi2 ); IEEE_Swap__FLT( &bias->goodness ); IEEE_Swap__FLT( &bias->cutoff ); bias->numiter = byte_swap_u16( bias->numiter ); n_cross = (bias->numfitp * (bias->numfitp - 1)) / 2; for ( nc = 0; nc < n_cross; nc++ ) IEEE_Swap__FLT( &bias->corrpar[nc] ); }
static void Sun2Intel_SMCD( struct smcd_gome *smcd ) { register int ni; smcd->indx_spec = byte_swap_16( smcd->indx_spec ); smcd->indx_leak = byte_swap_16( smcd->indx_leak ); ni = 0; do { smcd->indx_bands[ni] = byte_swap_16( smcd->indx_bands[ni] ); } while ( ++ni < NUM_SPEC_BANDS ); smcd->utc_date = byte_swap_u32( smcd->utc_date ); smcd->utc_time = byte_swap_u32( smcd->utc_time ); IEEE_Swap__FLT( &smcd->north_sun_zen ); IEEE_Swap__FLT( &smcd->north_sun_azim ); IEEE_Swap__FLT( &smcd->north_sm_zen ); IEEE_Swap__FLT( &smcd->north_sm_azim ); IEEE_Swap__FLT( &smcd->sun_or_moon ); IEEE_Swap__FLT( &smcd->dark_current ); IEEE_Swap__FLT( &smcd->noise_factor ); smcd->ihr.subsetcounter = byte_swap_u16( smcd->ihr.subsetcounter ); smcd->ihr.prism_temp = byte_swap_u16( smcd->ihr.prism_temp ); smcd->ihr.averagemode = byte_swap_u16( smcd->ihr.averagemode ); smcd->ihr.intg.two_byte = byte_swap_u16( smcd->ihr.intg.two_byte ); ni = 0; do { smcd->ihr.pmd[0][ni] = byte_swap_u16( smcd->ihr.pmd[0][ni] ); smcd->ihr.pmd[1][ni] = byte_swap_u16( smcd->ihr.pmd[1][ni] ); smcd->ihr.pmd[2][ni] = byte_swap_u16( smcd->ihr.pmd[2][ni] ); } while ( ++ni < PMD_IN_GRID ); ni = 0; do { smcd->ihr.peltier[ni] = byte_swap_u16( smcd->ihr.peltier[ni] ); } while ( ++ni < SCIENCE_CHANNELS ); }
static void Sun2Intel_CLD( struct cld_sci_ol *cld ) { register unsigned short np; cld->mjd.days = byte_swap_32( cld->mjd.days ); cld->mjd.secnd = byte_swap_u32( cld->mjd.secnd ); cld->mjd.musec = byte_swap_u32( cld->mjd.musec ); cld->dsrlen = byte_swap_u32( cld->dsrlen ); cld->intg_time = byte_swap_u16( cld->intg_time ); IEEE_Swap__FLT( &cld->surfpress ); IEEE_Swap__FLT( &cld->cloudfrac ); IEEE_Swap__FLT( &cld->errcldfrac ); cld->numpmdpix = byte_swap_u16( cld->numpmdpix ); cld->fullfree[0] = byte_swap_u16( cld->fullfree[0] ); cld->fullfree[1] = byte_swap_u16( cld->fullfree[1] ); IEEE_Swap__FLT( &cld->toppress ); IEEE_Swap__FLT( &cld->errtoppress ); IEEE_Swap__FLT( &cld->cldoptdepth ); IEEE_Swap__FLT( &cld->errcldoptdep ); cld->cloudtype = byte_swap_u16( cld->cloudtype ); IEEE_Swap__FLT( &cld->cloudbrdf ); IEEE_Swap__FLT( &cld->errcldbrdf ); IEEE_Swap__FLT( &cld->effsurfrefl ); IEEE_Swap__FLT( &cld->erreffsrefl ); cld->cloudflag = byte_swap_u16( cld->cloudflag ); IEEE_Swap__FLT( &cld->aai ); IEEE_Swap__FLT( &cld->aaidiag ); cld->aaiflag = byte_swap_u16( cld->aaiflag ); for ( np = 0; np < cld->numaeropars; np++ ) IEEE_Swap__FLT( &cld->aeropars[np] ); }
static void Sun2Intel_GEO( struct geo_scia *geo ) { register unsigned short ni; geo->mjd.days = byte_swap_32( geo->mjd.days ); geo->mjd.secnd = byte_swap_u32( geo->mjd.secnd ); geo->mjd.musec = byte_swap_u32( geo->mjd.musec ); geo->intg_time = byte_swap_u16( geo->intg_time ); IEEE_Swap__FLT( &geo->sat_h ); IEEE_Swap__FLT( &geo->earth_rad ); for ( ni = 0; ni < 3; ni++ ) { IEEE_Swap__FLT( &geo->sun_zen_ang[ni] ); IEEE_Swap__FLT( &geo->los_zen_ang[ni] ); IEEE_Swap__FLT( &geo->rel_azi_ang[ni] ); } for ( ni = 0; ni < 4; ni++ ) { geo->corner[ni].lon = byte_swap_32( geo->corner[ni].lon ); geo->corner[ni].lat = byte_swap_32( geo->corner[ni].lat ); } geo->center.lon = byte_swap_32( geo->center.lon ); geo->center.lat = byte_swap_32( geo->center.lat ); }
/*+++++++++++++++++++++++++ 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; }
static void Sun2Intel_LFIT( struct lfit_scia *lfit ) { register unsigned short ni, nj, np, nr; lfit->mjd.days = byte_swap_32( lfit->mjd.days ); lfit->mjd.secnd = byte_swap_u32( lfit->mjd.secnd ); lfit->mjd.musec = byte_swap_u32( lfit->mjd.musec ); lfit->dsrlen = byte_swap_u32( lfit->dsrlen ); lfit->intg_time = byte_swap_u16( lfit->intg_time ); IEEE_Swap__FLT( &lfit->refh ); IEEE_Swap__FLT( &lfit->refp ); for ( ni = nj = np = 0; np < lfit->num_rlevel; np++ ) { IEEE_Swap__FLT( &lfit->tangh[np] ); IEEE_Swap__FLT( &lfit->tangp[np] ); IEEE_Swap__FLT( &lfit->tangt[np] ); for ( nr = 0; nr < lfit->num_species; nr++, ni++ ) { IEEE_Swap__FLT( &lfit->mainrec[ni].tangvmr ); IEEE_Swap__FLT( &lfit->mainrec[ni].errtangvmr ); IEEE_Swap__FLT( &lfit->mainrec[ni].vertcol ); IEEE_Swap__FLT( &lfit->mainrec[ni].errvertcol ); } for ( nr = 0; nr < lfit->num_scale; nr++, nj++ ) { IEEE_Swap__FLT( &lfit->scaledrec[nj].tangvmr ); IEEE_Swap__FLT( &lfit->scaledrec[nj].errtangvmr ); IEEE_Swap__FLT( &lfit->scaledrec[nj].vertcol ); IEEE_Swap__FLT( &lfit->scaledrec[nj].errvertcol ); } } /* struct meas_grid */ for ( np = 0; np < lfit->num_mlevel; np++ ) { lfit->mgrid[np].mjd.days = byte_swap_32( lfit->mgrid[np].mjd.days ); lfit->mgrid[np].mjd.secnd = byte_swap_u32( lfit->mgrid[np].mjd.secnd ); lfit->mgrid[np].mjd.musec = byte_swap_u32( lfit->mgrid[np].mjd.musec ); IEEE_Swap__FLT( &lfit->mgrid[np].tangh ); IEEE_Swap__FLT( &lfit->mgrid[np].tangp ); IEEE_Swap__FLT( &lfit->mgrid[np].tangt ); IEEE_Swap__FLT( &lfit->mgrid[np].win_limits[0] ); IEEE_Swap__FLT( &lfit->mgrid[np].win_limits[1] ); } /* struct state_vec */ for ( np = 0; np < lfit->stvec_size; np++ ) { IEEE_Swap__FLT( &lfit->statevec[np].value ); IEEE_Swap__FLT( &lfit->statevec[np].error ); } for ( np = 0; np < lfit->cmatrixsize; np++ ) IEEE_Swap__FLT( &lfit->corrmatrix[np] ); IEEE_Swap__FLT( &lfit->rms ); IEEE_Swap__FLT( &lfit->chi2 ); IEEE_Swap__FLT( &lfit->goodness ); lfit->numiter = byte_swap_u16( lfit->numiter ); lfit->summary[0] = byte_swap_u16( lfit->summary[0] ); lfit->summary[1] = byte_swap_u16( lfit->summary[1] ); for ( np = 0; np < lfit->ressize; np++ ) IEEE_Swap__FLT( &lfit->residuals[np] ); for ( np = 0; np < lfit->num_adddiag; np++ ) IEEE_Swap__FLT( &lfit->adddiag[np] ); }
/*+++++++++++++++++++++++++ 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 SCIA_LV1C_RD_MDS .PURPOSE read SCIAMACHY level 1c MDS .INPUT/OUTPUT call as nr_mds = SCIA_LV1C_RD_MDS( fd, clus_mask, state, &mds ); input: FILE *fd : (open) stream pointer ulong64 clus_mask : mask for cluster selection in/output: struct state1_scia *state : structure with States of the product output: struct mds1c_scia **mds : structure for level 1c MDS .RETURNS number of level 1c MDS read (unsigned int), error status passed by global variable ``nadc_stat'' .COMMENTS This routine allocates memory for the following variables: pixel_ids, pixel_wv, pixel_wv_err, pixel_val, pixel_err, geoN/geoL/geoC -------------------------*/ unsigned int SCIA_LV1C_RD_MDS( FILE *fd, unsigned long long clus_mask, struct state1_scia *state, struct mds1c_scia **mds_out ) /*@globals source;@*/ /*@modifies source@*/ { register unsigned short nc, ncc, ni, nobs; register unsigned int nr_mds = 0u; register unsigned short bcp_in_limb, bcp_deep_space; char *mds_char, *mds_pntr; size_t dsr_length_left, nr_byte; unsigned short ubuff; unsigned short num_clus_file, num_clus_out; struct mds1c_scia *mds = NULL; static unsigned short bcp_in_nadir = 0; const unsigned char uchar_one = 1; const size_t DSR_Read = sizeof(struct mjd_envi) + ENVI_UINT; /* * set variable source (= type of MDS) */ source = (int) state->type_mds; /* * count number of cluster to be read */ num_clus_out = 0; num_clus_file = state->num_clus; for ( nc = 0; nc < num_clus_file; nc++ ) { if ( Get_Bit_LL( clus_mask, state->Clcon[nc].id - uchar_one ) == 1ULL ) num_clus_out++; } /* * check dimension of the output array mds_out */ if ( num_clus_out == 0u || mds_out == NULL ) { if ( mds_out != NULL ) *mds_out = NULL; return 0u; } /* * allocate memory to store output records */ mds = (struct mds1c_scia *) malloc( num_clus_out * sizeof(struct mds1c_scia)); if ( mds == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "mds1_scia" ); *mds_out = mds; /* * initialize MDS-structure */ nc = 0; do { mds[nc].num_obs = 0; mds[nc].num_pixels = 0; mds[nc].pixel_ids = NULL; mds[nc].pixel_wv = NULL; mds[nc].pixel_wv_err = NULL; mds[nc].pixel_val = NULL; mds[nc].pixel_err = NULL; mds[nc].geoN = NULL; mds[nc].geoL = NULL; mds[nc].geoC = NULL; } while ( ++nc < num_clus_out ); /* * rewind/read input data file */ (void) fseek( fd, (long) state->offset, SEEK_SET ); /* * read data set records */ nc = 0; do { mds->type_mds = state->type_mds; mds->state_index = (unsigned char) state->indx; mds->dur_scan = state->dur_scan; /* 1 */ if ( fread( &mds->mjd, sizeof( struct mjd_envi ), 1, fd ) != 1 ) NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" ); /* 2 */ if ( fread( &mds->dsr_length, ENVI_UINT, 1, fd ) != 1 ) NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" ); #ifdef _SWAP_TO_LITTLE_ENDIAN mds->dsr_length = byte_swap_u32( mds->dsr_length ); #endif /* * now we know the size of this dsr, so read it in memory! */ dsr_length_left = mds->dsr_length - DSR_Read; mds_char = (char *) malloc( dsr_length_left ); if ( mds_char == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "mds_char" ); if ( fread( mds_char, dsr_length_left, 1, fd ) != 1 ) NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" ); /* 3 */ (void) memcpy( &mds->quality_flag, mds_char, ENVI_CHAR ); mds_pntr = mds_char + ENVI_CHAR; /* 4 */ (void) memcpy( &mds->orbit_phase, mds_pntr, ENVI_FLOAT ); mds_pntr += ENVI_FLOAT; /* 5 */ (void) memcpy( &ubuff, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN ubuff = byte_swap_u16( ubuff ); #endif mds->category = (unsigned char) ubuff; /* 6 */ (void) memcpy( &ubuff, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN ubuff = byte_swap_u16( ubuff ); #endif mds->state_id = (unsigned char) ubuff; /* 7 */ (void) memcpy( &ubuff, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN ubuff = byte_swap_u16( ubuff ); #endif mds->clus_id = (unsigned char) ubuff; for ( ncc = 0; ncc < state->num_clus; ncc++ ) if ( state->Clcon[ncc].id == mds->clus_id ) break; mds->chan_id = state->Clcon[ncc].channel; mds->coaddf = (unsigned char) state->Clcon[ncc].coaddf; mds->pet = state->Clcon[ncc].pet; if ( Get_Bit_LL(clus_mask,(unsigned char)(mds->clus_id-1)) != 0ULL ){ /* 8 */ (void) memcpy( &mds->num_obs, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN mds->num_obs = byte_swap_u16( mds->num_obs ); #endif /* 9 */ (void) memcpy( &mds->num_pixels, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN mds->num_pixels = byte_swap_u16( mds->num_pixels ); #endif /* 10 */ (void) memcpy( &mds->rad_units_flag, mds_pntr, ENVI_CHAR ); mds_pntr += ENVI_CHAR; /* 11 */ nr_byte = mds->num_pixels * ENVI_USHRT; mds->pixel_ids = (unsigned short *) malloc( nr_byte ); if ( mds->pixel_ids == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "pixel_ids" ); } (void) memcpy( mds->pixel_ids, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* 12 */ nr_byte = mds->num_pixels * ENVI_FLOAT; mds->pixel_wv = (float *) malloc( nr_byte ); if ( mds->pixel_wv == NULL ) { free( mds_char ); NADC_GOTO_ERROR(NADC_ERR_ALLOC, "pixel_wv"); } (void) memcpy( mds->pixel_wv, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* 13 */ mds->pixel_wv_err = (float *) malloc( nr_byte ); if ( mds->pixel_wv_err == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "pixel_wv_err" ); } (void) memcpy( mds->pixel_wv_err, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* 14 */ nr_byte = mds->num_obs * mds->num_pixels * ENVI_FLOAT; mds->pixel_val = (float *) malloc( nr_byte ); if ( mds->pixel_val == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "pixel_val" ); } (void) memcpy( mds->pixel_val, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* 15 */ mds->pixel_err = (float *) malloc( nr_byte ); if ( mds->pixel_err == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "pixel_err" ); } (void) memcpy( mds->pixel_err, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* 16 */ switch ( source ) { case SCIA_NADIR: mds->geoN = (struct geoN_scia *) malloc( mds->num_obs * sizeof( struct geoN_scia )); if ( mds->geoN == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoN" ); } mds_pntr += SCIA_LV1_RD_GeoN( mds_pntr, mds->num_obs, mds->geoN ); /* * set Rainbow/Sun glint flags and pixel type: 0 (= backscan) else 1 */ for ( nobs = 0; nobs < mds->num_obs; nobs++ ) { mds->geoN[nobs].glint_flag = 0; bcp_in_nadir += state->Clcon[ncc].intg_time; if ( bcp_in_nadir > 64 ) { mds->geoN[nobs].pixel_type = BACK_SCAN; if ( bcp_in_nadir == 80 ) bcp_in_nadir = 0; } else mds->geoN[nobs].pixel_type = FORWARD_SCAN; } break; case SCIA_LIMB: mds->geoL = (struct geoL_scia *) malloc( mds->num_obs * sizeof( struct geoL_scia )); if ( mds->geoL == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoL" ); } mds_pntr += SCIA_LV1_RD_GeoL( mds_pntr, mds->num_obs, mds->geoL ); /* * set Rainbow/Sun glint flags and pixel type */ bcp_in_limb = 0; bcp_deep_space = mds->num_obs * state->Clcon[ncc].intg_time - 24; for ( nobs = 0; nobs < mds->num_obs; nobs++ ) { mds->geoL[nobs].glint_flag = 0; mds->geoL[nobs].pixel_type = ALONG_TANG_HGHT; if ( nobs == mds->num_obs-1 || bcp_in_limb > bcp_deep_space ) mds->geoL[nobs].pixel_type = DEEP_SPACE; else if ( (bcp_in_limb % 24) == 0 ) mds->geoL[nobs].pixel_type = NEW_TANG_HGHT; bcp_in_limb += state->Clcon[ncc].intg_time; } break; case SCIA_OCCULT: mds->geoL = (struct geoL_scia *) malloc( mds->num_obs * sizeof( struct geoL_scia )); if ( mds->geoL == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoL" ); } mds_pntr += SCIA_LV1_RD_GeoL( mds_pntr, mds->num_obs, mds->geoL ); /* * set Rainbow/Sun glint flags and pixel type */ for ( nobs = 0; nobs < mds->num_obs; nobs++ ) { mds->geoL[nobs].glint_flag = 0; mds->geoL[nobs].pixel_type = ALONG_TANG_HGHT; } break; case SCIA_MONITOR: mds->geoC = (struct geoC_scia *) malloc( mds->num_obs * sizeof( struct geoC_scia )); if ( mds->geoC == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoC" ); } mds_pntr += SCIA_LV1_RD_GeoC( mds_pntr, mds->num_obs, mds->geoC ); break; } /* * check if we read the whole DSR */ if ( (size_t)(mds_pntr - mds_char) != dsr_length_left ) { const char *dsd_names[] = { "UNKNOWN", "NADIR", "LIMB", "OCCULTATION", "MONITORING" }; free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_PDS_SIZE, dsd_names[source] ); } /* * byte swap data to local representation */ #ifdef _SWAP_TO_LITTLE_ENDIAN Sun2Intel_L1C_MDS( mds ); #endif if ( ++nr_mds == num_clus_out ) { free( mds_char ); break; } /* * pixel_ids has a value in the range [0..8191] */ for ( ni = 0; ni < mds->num_pixels; ni++ ) mds->pixel_ids[ni] += (mds->chan_id - 1) * CHANNEL_SIZE; mds++; } free( mds_char ); } while ( ++nc < num_clus_file ); /* * update state-record to reflect the actual clusters to be read * note that the dimension of 'mds_out' equals 'num_clus_out' */ num_clus_out = 0; for ( nc = 0; nc < num_clus_file; nc++ ) { if ( Get_Bit_LL( clus_mask, state->Clcon[nc].id - uchar_one ) == 1ULL ) { if ( num_clus_out < nc ) (void) memmove( &state->Clcon[num_clus_out], &state->Clcon[nc], sizeof( struct Clcon_scia ) ); num_clus_out++; } } state->num_clus = num_clus_out; /* * set return values */ return nr_mds; done: *mds_out = NULL; if ( (mds -= nr_mds) != NULL ) SCIA_LV1C_FREE_MDS( source, nr_mds, mds ); return 0u; }
/*+++++++++++++++++++++++++ .IDENTifer SCIA_LV1_RD_ONE_MDS .PURPOSE General function to read one Measurement Data Set .INPUT/OUTPUT call as SCIA_LV1_RD_ONE_MDS( fd, clus_mask, state, mds ); input: FILE *fd : (open) stream pointer ulong64 clus_mask : mask for cluster selection in/output: struct state1_scia *state : structure with States of the product output: struct mds1_scia **mds : structure for level 1b MDS .RETURNS exits on failure .COMMENTS static function -------------------------*/ static void SCIA_LV1_RD_ONE_MDS( FILE *fd, unsigned long long clus_mask, const struct state1_scia *state, /*@partial@*/ struct mds1_scia *mds ) /*@globals errno, nadc_stat, nadc_err_stack, source;@*/ /*@modifies errno, nadc_stat, nadc_err_stack, fd, mds@*/ { register char *mds_pntr; register unsigned short na, nc, ncc, ni, nr; char *mds_char; char msg[64]; size_t nr_byte; unsigned char *glint_flags; const int intg_per_sec = 16 / state->intg_times[state->num_intg-1]; const unsigned short indx_deep_space = state->num_aux - (state->intg_times[0] / state->intg_times[state->num_intg-1]); /* * allocate memory for the Sun glint/Rainbow flags */ glint_flags = (unsigned char *) malloc( (size_t) mds->n_aux ); if ( glint_flags == NULL ) NADC_RETURN_ERROR( NADC_ERR_ALLOC, "glint_flags" ); /* * allocate memory to temporary store data for output structure */ mds_char = (char *) malloc( (size_t) state->length_dsr ); if ( mds_char == NULL ) { free( glint_flags ); NADC_RETURN_ERROR( NADC_ERR_ALLOC, "mds_char" ); } /* * read all MDS parameters of this state */ if ( fread( mds_char, (size_t) state->length_dsr, 1, fd ) != 1 ) { (void) snprintf( msg, 64, "MDS[%-u]: read failed", state->indx ); NADC_GOTO_ERROR( NADC_ERR_FILE_RD, msg ); } /* * read data buffer to MDS structure */ mds_pntr = mds_char; (void) memcpy( &mds->mjd, mds_pntr, sizeof( struct mjd_envi ) ); mds_pntr += sizeof( struct mjd_envi ); (void) memcpy( &mds->dsr_length, mds_pntr, ENVI_UINT ); mds_pntr += ENVI_UINT; #ifdef _SWAP_TO_LITTLE_ENDIAN mds->dsr_length = byte_swap_u32( mds->dsr_length ); #endif if ( mds->dsr_length != state->length_dsr ) { (void) snprintf( msg, 64, "MDS[%-u]: Size according to State/DSR = %-u/%-u", state->indx, state->length_dsr, mds->dsr_length ); NADC_GOTO_ERROR( NADC_ERR_PDS_SIZE, msg ); } (void) memcpy( &mds->quality_flag, mds_pntr, ENVI_CHAR ); mds_pntr += ENVI_CHAR; /* * read scale factor [SCIENCE_CHANNELS] */ nr_byte = (size_t) SCIENCE_CHANNELS * ENVI_UCHAR; (void) memcpy( mds->scale_factor, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* * read satellite flags */ nr_byte = mds->n_aux * ENVI_UCHAR; if ( (mds->sat_flags = (unsigned char *) malloc( nr_byte )) == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "sat_flags" ); (void) memcpy( mds->sat_flags, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* * read red grass flags */ nr_byte = (size_t) state->num_clus * mds->n_aux; if ( (mds->red_grass = (unsigned char *) malloc( nr_byte )) == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "red_grass" ); (void) memcpy( mds->red_grass, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* * read Sun glint flags */ if ( source != SCIA_MONITOR ) { (void) memcpy( glint_flags, mds_pntr, (size_t) mds->n_aux ); mds_pntr += (size_t) mds->n_aux; } /* * read geolocation */ switch ( source ) { case SCIA_NADIR: mds->geoN = (struct geoN_scia *) malloc( mds->n_aux * sizeof( struct geoN_scia ) ); if ( mds->geoN == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoN" ); mds_pntr += SCIA_LV1_RD_GeoN( mds_pntr, mds->n_aux, mds->geoN ); /* set Rainbow/Sun glint flag and pixel type: 0 (= backscan) or 1 */ for ( na = 0; na < mds->n_aux; na++ ) { mds->geoN[na].glint_flag = glint_flags[na]; if ( sec_in_scan == 5 ) sec_in_scan = 0; if ( sec_in_scan == 0 ) mds->geoN[na].pixel_type = BACK_SCAN; else mds->geoN[na].pixel_type = FORWARD_SCAN; if ( (na+1) % intg_per_sec == 0 ) sec_in_scan++; } break; case SCIA_LIMB: mds->geoL = (struct geoL_scia *) malloc( mds->n_aux * sizeof( struct geoL_scia ) ); if ( mds->geoL == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoL" ); mds_pntr += SCIA_LV1_RD_GeoL( mds_pntr, mds->n_aux, mds->geoL ); /* set Rainbow/Sun glint flags and pixel type */ for ( na = 0; na < mds->n_aux; na++ ) { mds->geoL[na].glint_flag = glint_flags[na]; mds->geoL[na].pixel_type = ALONG_TANG_HGHT; if ( indx_limb >= indx_deep_space ) mds->geoL[na].pixel_type |= DEEP_SPACE; if ( ++indx_limb >= state->num_aux ) indx_limb = 0; } mds->geoL[0].pixel_type |= NEW_TANG_HGHT; break; case SCIA_OCCULT: mds->geoL = (struct geoL_scia *) malloc( mds->n_aux * sizeof( struct geoL_scia ) ); if ( mds->geoL == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoL" ); mds_pntr += SCIA_LV1_RD_GeoL( mds_pntr, mds->n_aux, mds->geoL ); /* set Rainbow/Sun glint flags and pixel type */ for ( na = 0; na < mds->n_aux; na++ ) { mds->geoL[na].glint_flag = glint_flags[na]; mds->geoL[na].pixel_type = ALONG_TANG_HGHT; } break; case SCIA_MONITOR: mds->geoC = (struct geoC_scia *) malloc( mds->n_aux * sizeof( struct geoC_scia ) ); if ( mds->geoC == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoC" ); mds_pntr += SCIA_LV1_RD_GeoC( mds_pntr, mds->n_aux, mds->geoC ); break; } /* * level 0 header */ mds->lv0 = (struct lv0_hdr *) malloc( mds->n_aux * sizeof( struct lv0_hdr ) ); if ( mds->lv0 == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "lv0" ); mds_pntr += SCIA_LV1_RD_LV0Hdr( mds_pntr, mds->n_aux, mds->lv0 ); /* * PMD values */ if ( source != SCIA_MONITOR ) { nr_byte = mds->n_pmd * ENVI_FLOAT; mds->int_pmd = (float *) malloc( nr_byte ); if ( mds->int_pmd == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "int_pmd" ); (void) memcpy( mds->int_pmd, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* * Fractional polarisation values */ mds->polV = (struct polV_scia *) malloc( mds->n_pol * sizeof( struct polV_scia ) ); if ( mds->polV == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "mds->polV" ); mds_pntr += SCIA_LV1_RD_PolV( mds_pntr, mds->n_pol, mds->polV ); /* * add integration times */ for ( ncc = ni = 0; ni < state->num_intg; ni++ ) { unsigned short n_pol_intg = state->num_polar[ni] / state->num_dsr; for ( nr = 0; nr < n_pol_intg; nr++ ) mds->polV[ncc + nr].intg_time = state->intg_times[ni]; ncc += n_pol_intg; } } /* * cluster data */ (void) strcpy( msg, "" ); nc = ncc = 0; do { unsigned short num = state->Clcon[nc].length * state->Clcon[nc].n_read; switch ( state->Clcon[nc].type ) { case RSIG: case ESIG: if ( Get_Bit_LL( clus_mask, (unsigned char) nc ) == 0ULL ){ size_t byte_dest = ncc * mds->n_aux; size_t byte_src = (ncc + 1) * mds->n_aux; size_t bytes_to_move = (state->num_clus - ncc - 1) * mds->n_aux; (void) memmove( mds->red_grass + byte_dest, mds->red_grass + byte_src, bytes_to_move ); mds_pntr += num * (2 * ENVI_CHAR + ENVI_USHRT); } else { /* mds->clus[ncc].id = state->Clcon[nc].id; */ mds->clus[ncc].sig = (struct Sig_scia *) malloc( (size_t) num * SCIA_SIG ); if ( mds->clus[ncc].sig == NULL ) { (void) snprintf( msg, 25, "clus[%-hu].sig", nc ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, msg ); } nr = 0; do { (void) memcpy( &mds->clus[ncc].sig[nr].corr, mds_pntr, ENVI_CHAR ); mds_pntr += ENVI_CHAR; (void) memcpy( &mds->clus[ncc].sig[nr].sign, mds_pntr, ENVI_USHRT ); #ifdef _SWAP_TO_LITTLE_ENDIAN mds->clus[ncc].sig[nr].sign = byte_swap_u16( mds->clus[ncc].sig[nr].sign ); #endif mds_pntr += ENVI_USHRT; (void) memcpy( &mds->clus[ncc].sig[nr].stray, mds_pntr, ENVI_CHAR ); mds_pntr += ENVI_CHAR; } while ( ++nr < num ); mds->clus[ncc++].n_sig = num; } break; case RSIGC: case ESIGC: if ( Get_Bit_LL( clus_mask, (unsigned char) nc ) == 0ULL ){ size_t byte_dest = ncc * mds->n_aux; size_t byte_src = (ncc + 1) * mds->n_aux; size_t bytes_to_move = (state->num_clus - ncc - 1) * mds->n_aux; (void) memmove( mds->red_grass + byte_dest, mds->red_grass + byte_src, bytes_to_move ); mds_pntr += num * (ENVI_CHAR + ENVI_UINT); } else { /* mds->clus[ncc].id = state->Clcon[nc].id; */ mds->clus[ncc].sigc = (struct Sigc_scia *) malloc( (size_t) num * SCIA_SIGC ); if ( mds->clus[ncc].sigc == NULL ) { (void) snprintf( msg, 25, "clus[%-hu].sigc", nc ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, msg ); } nr = 0; do { (void) memcpy( &mds->clus[ncc].sigc[nr].det.four_byte, mds_pntr, ENVI_UINT ); #ifdef _SWAP_TO_LITTLE_ENDIAN mds->clus[ncc].sigc[nr].det.four_byte = byte_swap_u32( mds->clus[ncc].sigc[nr].det.four_byte ); #endif mds_pntr += ENVI_UINT; (void) memcpy( &mds->clus[ncc].sigc[nr].stray, mds_pntr, ENVI_CHAR ); mds_pntr += ENVI_CHAR; } while ( ++nr < num ); mds->clus[ncc++].n_sigc = num; } break; default: (void) snprintf( msg, 25, "unknown reticon type: %02hu", (unsigned short) state->Clcon[nc].type ); NADC_GOTO_ERROR( NADC_ERR_FATAL, msg ); } } while ( ++nc < state->num_clus ); mds->n_clus = ncc; /* * check if we read the whole DSR */ if ( (nr_byte = mds_pntr - mds_char) != (size_t) state->length_dsr ) { (void) snprintf( msg, 64, "MDS[%-u]: expected: %6u - read: %6zd", state->indx, state->length_dsr, nr_byte ); NADC_GOTO_ERROR( NADC_ERR_PDS_SIZE, msg ); } /* * deallocate memory */ done: free( glint_flags ); free( mds_char ); return; }
/*+++++++++++++++++++++++++ .IDENTifer SCIA_LV1C_RD_MDS_POLV .PURPOSE read SCIAMACHY level 1c POLV MDS .INPUT/OUTPUT call as nr_mds = SCIA_LV1C_RD_MDS_POLV( fd, state, &polV ); input: FILE *fd : (open) stream pointer struct state1_scia *state : structure with States of the product output: struct mds1c_polV **polV : structure for level 1c POLV MDS .RETURNS number of level 1c POLV MDS read (unsigned int), error status passed by global variable ``nadc_stat'' .COMMENTS This routine allocates memory for the following variables: polV, geoN/geoL/geoC -------------------------*/ unsigned int SCIA_LV1C_RD_MDS_POLV( FILE *fd, const struct state1_scia *state, struct mds1c_polV **polV_out ) /*@globals source;@*/ /*@modifies source@*/ { char *mds_char, *mds_pntr; size_t dsr_length_left, nr_byte; unsigned short ubuff; struct mds1c_polV *polV; const size_t DSR_Read = sizeof(struct mjd_envi) + ENVI_UINT; /* * set variable source (= type of MDS) */ source = (int) state->type_mds; /* * check type of MDS */ if ( (source != SCIA_NADIR && source != SCIA_LIMB && source != SCIA_OCCULT) || state->offs_polV == 0L ) { *polV_out = NULL; return 0u; } /* * allocate memory to store output records */ *polV_out = (struct mds1c_polV *) malloc( sizeof(struct mds1c_polV) ); if ( (polV = *polV_out) == NULL ) { NADC_GOTO_ERROR( NADC_ERR_ALLOC, "mds1c_polV" ); } /* * initialize MDS-structure */ polV->total_polV = 0u; polV->num_geo = 0u; polV->polV = NULL; polV->geoN = NULL; polV->geoL = NULL; /* * rewind/read input data file */ (void) fseek( fd, (long) state->offs_polV, SEEK_SET ); /* * read data set records */ polV->type_mds = state->type_mds; polV->state_index = (unsigned char) state->indx; /* 1 */ if ( fread( &polV->mjd, sizeof( struct mjd_envi ), 1 , fd ) != 1 ) NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" ); /* 2 */ if ( fread( &polV->dsr_length, ENVI_UINT, 1 , fd ) != 1 ) NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" ); #ifdef _SWAP_TO_LITTLE_ENDIAN polV->dsr_length = byte_swap_u32( polV->dsr_length ); #endif /* * now we know the size of this dsr, so read it in memory! */ dsr_length_left = polV->dsr_length - DSR_Read; mds_char = (char *) malloc( dsr_length_left ); if ( mds_char == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "mds_char" ); if ( fread( mds_char, dsr_length_left, 1, fd ) != 1 ) NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" ); /* 3 */ (void) memcpy( &polV->quality_flag, mds_char, ENVI_CHAR ); mds_pntr = mds_char + ENVI_CHAR; /* 4 */ (void) memcpy( &polV->orbit_phase, mds_pntr, ENVI_FLOAT ); mds_pntr += ENVI_FLOAT; /* 5 */ (void) memcpy( &ubuff, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN ubuff = byte_swap_u16( ubuff ); #endif polV->category = (unsigned char) ubuff; /* 6 */ (void) memcpy( &ubuff, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN ubuff = byte_swap_u16( ubuff ); #endif polV->state_id = (unsigned char) ubuff; /* 7 */ (void) memcpy( &polV->dur_scan, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; /* 8 */ (void) memcpy( &polV->num_geo, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN polV->num_geo = byte_swap_u16( polV->num_geo ); #endif /* 9 */ (void) memcpy( &polV->total_polV, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN polV->total_polV = byte_swap_u16( polV->total_polV ); #endif /* 10 */ (void) memcpy( &polV->num_diff_intg, mds_pntr, ENVI_USHRT ); mds_pntr += ENVI_USHRT; /* 11 */ nr_byte = MAX_CLUSTER * ENVI_USHRT; (void) memcpy( polV->intg_times, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* 12 */ (void) memcpy( polV->num_polar, mds_pntr, nr_byte ); mds_pntr += nr_byte; /* 13 */ nr_byte = polV->total_polV * sizeof( struct polV_scia ); polV->polV = (struct polV_scia *) malloc( nr_byte ); if ( polV->polV == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "polV" ); } mds_pntr += SCIA_LV1_RD_PolV( mds_pntr, polV->total_polV, polV->polV ); /* 14 */ switch ( source ) { case SCIA_NADIR: polV->geoN = (struct geoN_scia *) malloc( polV->num_geo * sizeof( struct geoN_scia ) ); if ( polV->geoN == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoN" ); } mds_pntr += SCIA_LV1_RD_GeoN(mds_pntr, polV->num_geo, polV->geoN); break; case SCIA_LIMB: case SCIA_OCCULT: polV->geoL = (struct geoL_scia *) malloc( polV->num_geo * sizeof( struct geoL_scia ) ); if ( polV->geoL == NULL ) { free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_ALLOC, "geoL" ); } mds_pntr += SCIA_LV1_RD_GeoL(mds_pntr, polV->num_geo, polV->geoL); break; } /* * check if we read the whole DSR */ if ( (size_t)(mds_pntr - mds_char) != dsr_length_left ) { const char *dsd_names[] = { "UNKNOWN", "NADIR_FRAC_POL", "LIMB_FRAC_POL", "OCCULTATION_FRAC_POL" }; free( mds_char ); NADC_GOTO_ERROR( NADC_ERR_PDS_SIZE, dsd_names[source] ); } free( mds_char ); /* * byte swap data to local representation */ #ifdef _SWAP_TO_LITTLE_ENDIAN Sun2Intel_L1C_MDS_POLV( polV ); #endif /* * set return values */ polV = NULL; return 1; done: if ( polV != NULL ) SCIA_LV1C_FREE_MDS_POLV( source, polV ); return 0; }
/*+++++++++++++++++++++++++ Main Program or Function +++++++++++++++*/ unsigned int SCIA_OL2_RD_CLD( FILE *fd, unsigned int num_dsd, const struct dsd_envi *dsd, struct cld_sci_ol **cld_out ) { char *cld_pntr, *cld_char = NULL; size_t dsd_size; unsigned int indx_dsd; unsigned int nr_dsr = 0; struct cld_sci_ol *cld; const char dsd_name[] = "CLOUDS_AEROSOL"; /* * get index to data set descriptor */ NADC_ERR_SAVE(); indx_dsd = ENVI_GET_DSD_INDEX( num_dsd, dsd, dsd_name ); if ( IS_ERR_STAT_FATAL ) NADC_GOTO_ERROR( NADC_ERR_PDS_RD, dsd_name ); if ( IS_ERR_STAT_ABSENT || dsd[indx_dsd].num_dsr == 0 ) { NADC_ERR_RESTORE(); cld_out[0] = NULL; return 0u; } dsd_size = (size_t) dsd[indx_dsd].size; /* * allocate memory to store output structures */ if ( ! Use_Extern_Alloc ) { cld_out[0] = (struct cld_sci_ol *) malloc( dsd[indx_dsd].num_dsr * sizeof(struct cld_sci_ol)); } if ( (cld = cld_out[0]) == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "cld" ); /* * allocate memory to temporary store data for output structure */ if ( (cld_char = (char *) malloc( dsd_size )) == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "cld_char" ); /* * rewind/read input data file */ (void) fseek( fd, (long) dsd[indx_dsd].offset, SEEK_SET ); if ( fread( cld_char, dsd_size, 1, fd ) != 1 ) NADC_GOTO_ERROR( NADC_ERR_PDS_RD, "" ); /* * read data buffer to CLD structure */ cld_pntr = cld_char; do { (void) memcpy( &cld->mjd.days, cld_pntr, ENVI_INT ); cld_pntr += ENVI_INT; (void) memcpy( &cld->mjd.secnd, cld_pntr, ENVI_UINT ); cld_pntr += ENVI_UINT; (void) memcpy( &cld->mjd.musec, cld_pntr, ENVI_UINT ); cld_pntr += ENVI_UINT; (void) memcpy( &cld->dsrlen, cld_pntr, ENVI_UINT ); cld_pntr += ENVI_UINT; (void) memcpy( &cld->quality, cld_pntr, ENVI_CHAR ); cld_pntr += ENVI_CHAR; (void) memcpy( &cld->intg_time, cld_pntr, ENVI_USHRT ); cld_pntr += ENVI_USHRT; (void) memcpy( &cld->surfpress, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->cloudfrac, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->errcldfrac, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->numpmdpix, cld_pntr, ENVI_USHRT ); cld_pntr += ENVI_USHRT; (void) memcpy( cld->fullfree, cld_pntr, 2 * ENVI_USHRT ); cld_pntr += 2 * ENVI_USHRT; (void) memcpy( &cld->toppress, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->errtoppress, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->cldoptdepth, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->errcldoptdep, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->cloudtype, cld_pntr, ENVI_USHRT ); cld_pntr += ENVI_USHRT; (void) memcpy( &cld->cloudbrdf, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->errcldbrdf, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->effsurfrefl, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->erreffsrefl, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->cloudflag, cld_pntr, ENVI_USHRT ); cld_pntr += ENVI_USHRT; (void) memcpy( &cld->aai, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->aaidiag, cld_pntr, ENVI_FLOAT ); cld_pntr += ENVI_FLOAT; (void) memcpy( &cld->aaiflag, cld_pntr, ENVI_USHRT ); cld_pntr += ENVI_USHRT; (void) memcpy( &cld->numaeropars, cld_pntr, ENVI_USHRT ); cld_pntr += ENVI_USHRT; #ifdef _SWAP_TO_LITTLE_ENDIAN cld->numaeropars = byte_swap_u16( cld->numaeropars ); #endif if ( cld->numaeropars > 0u ) { cld->aeropars = (float *) malloc((size_t) cld->numaeropars * sizeof( float )); if ( cld->aeropars == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "aeropars" ); (void) memcpy( cld->aeropars, cld_pntr, cld->numaeropars * ENVI_FLOAT ); cld_pntr += cld->numaeropars * ENVI_FLOAT; } #ifdef _SWAP_TO_LITTLE_ENDIAN Sun2Intel_CLD( cld ); #endif cld++; } while ( ++nr_dsr < dsd[indx_dsd].num_dsr ); /* * check if we read the whole DSR */ if ( (unsigned int)(cld_pntr - cld_char) != dsd[indx_dsd].size ) NADC_GOTO_ERROR( NADC_ERR_PDS_SIZE, dsd_name ); cld_pntr = NULL; /* * set return values */ done: if ( cld_char != NULL ) free( cld_char ); return nr_dsr; }