libcris.h

Go to the documentation of this file.

#include <netcdf.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_fft_complex.h>
#include <gsl/gsl_multifit.h>
#include <gsl/gsl_poly.h>
#include <gsl/gsl_sort.h>
#include <gsl/gsl_spline.h>
#include "jurassic.h"
 
/* ------------------------------------------------------------
   Dimensions...
   ------------------------------------------------------------ */
 
#define NDS 200000
 
#define NPG 30
 
#define L1_NTRACK 45
 
#define L1_NXTRACK 30
 
#define L1_NFOV 9
 
#define L1_NCHAN_LW 717
 
#define L1_NCHAN_MW 869
 
#define L1_NCHAN_SW 637
 
#define PERT_NTRACK 44000
 
#define PERT_NXTRACK 120
 
#define PERT_NFOV 9
 
#define WX 300
 
#define WY 33000
 
#define PMAX 512
 
/* ------------------------------------------------------------
   Macros...
   ------------------------------------------------------------ */
 
#define NC(cmd) {                                    \
  int nc_result=(cmd);                               \
  if(nc_result!=NC_NOERR)                            \
    ERRMSG("%s", nc_strerror(nc_result));            \
}
 
/* ------------------------------------------------------------
   Structs...
   ------------------------------------------------------------ */
 
typedef struct {
 
  double time[L1_NTRACK][L1_NXTRACK];
 
  double lon[L1_NTRACK][L1_NXTRACK][L1_NFOV];
 
  double lat[L1_NTRACK][L1_NXTRACK][L1_NFOV];
 
  double sat_z[L1_NTRACK];
 
  double sat_lon[L1_NTRACK];
 
  double sat_lat[L1_NTRACK];
 
  double nu_lw[L1_NCHAN_LW];
 
  float rad_lw[L1_NTRACK][L1_NXTRACK][L1_NFOV][L1_NCHAN_LW];
 
  float nedn_lw[L1_NFOV][L1_NCHAN_LW];
 
  short qual_lw[L1_NTRACK][L1_NXTRACK][L1_NFOV];
 
  double nu_mw[L1_NCHAN_MW];
 
  float rad_mw[L1_NTRACK][L1_NXTRACK][L1_NFOV][L1_NCHAN_MW];
 
  float nedn_mw[L1_NFOV][L1_NCHAN_MW];
 
  short qual_mw[L1_NTRACK][L1_NXTRACK][L1_NFOV];
 
  double nu_sw[L1_NCHAN_SW];
 
  float rad_sw[L1_NTRACK][L1_NXTRACK][L1_NFOV][L1_NCHAN_SW];
 
  float nedn_sw[L1_NFOV][L1_NCHAN_SW];
 
  short qual_sw[L1_NTRACK][L1_NXTRACK][L1_NFOV];
 
} cris_l1_t;
 
typedef struct {
 
  int ntrack;
 
  int nxtrack;
 
  int nfov;
 
  double time[PERT_NTRACK][PERT_NXTRACK][PERT_NFOV];
 
  double lon[PERT_NTRACK][PERT_NXTRACK][PERT_NFOV];
 
  double lat[PERT_NTRACK][PERT_NXTRACK][PERT_NFOV];
 
  double dc[PERT_NTRACK][PERT_NXTRACK][PERT_NFOV];
 
  double bt[PERT_NTRACK][PERT_NXTRACK][PERT_NFOV];
 
  double pt[PERT_NTRACK][PERT_NXTRACK][PERT_NFOV];
 
  double var[PERT_NTRACK][PERT_NXTRACK][PERT_NFOV];
 
} pert_t;
 
typedef struct {
 
  int nds;
 
  int np;
 
  double time[NDS][NPG];
 
  double z[NDS][NPG];
 
  double lon[NDS][NPG];
 
  double lat[NDS][NPG];
 
  double p[NDS][NPG];
 
  double t[NDS][NPG];
 
  double t_apr[NDS][NPG];
 
  double t_tot[NDS][NPG];
 
  double t_noise[NDS][NPG];
 
  double t_fm[NDS][NPG];
 
  double t_cont[NDS][NPG];
 
  double t_res[NDS][NPG];
 
  double chisq[NDS];
 
} retr_t;
 
typedef struct {
 
  int nx;
 
  int ny;
 
  double time;
 
  double z;
 
  double lon[WX][WY];
 
  double lat[WX][WY];
 
  double x[WX];
 
  double y[WY];
 
  double temp[WX][WY];
 
  double bg[WX][WY];
 
  double pt[WX][WY];
 
  double fit[WX][WY];
 
  double var[WX][WY];
 
} wave_t;
 
/* ------------------------------------------------------------
   Functions...
   ------------------------------------------------------------ */
 
void add_att(
  const int ncid,
  const int varid,
  const char *unit,
  const char *long_name);
 
void add_var(
  const int ncid,
  const char *varname,
  const char *unit,
  const char *longname,
  int type,
  int dimid[],
  int *varid,
  int ndims);
 
void background_poly(
  wave_t * wave,
  int dim_x,
  int dim_y);
 
void background_poly_help(
  const double *xx,
  double *yy,
  const int n,
  const int dim);
 
void background_smooth(
  wave_t * wave,
  int npts_x,
  int npts_y);
 
void create_background(
  wave_t * wave);
 
void create_noise(
  wave_t * wave,
  double nedt);
 
void create_wave(
  wave_t * wave,
  double amp,
  double lx,
  double ly,
  double phi,
  double fwhm);
 
void fit_wave(
  wave_t * wave,
  double amp,
  double phi,
  double kx,
  double ky,
  double *chisq);
 
void fft_help(
  double *fcReal,
  double *fcImag,
  int n);
 
void fft(
  wave_t * wave,
  double *Amax,
  double *phimax,
  double *lhmax,
  double *kxmax,
  double *kymax,
  double *alphamax,
  double *betamax,
  char *filename);
 
void gauss(
  wave_t * wave,
  double fwhm);
 
void hamming(
  wave_t * wave,
  int nit);
 
void intpol_x(
  wave_t * wave,
  int n);
 
void median(
  wave_t * wave,
  int dx);
 
void merge_y(
  wave_t * wave1,
  wave_t * wave2);
 
void noise(
  wave_t * wave,
  double *mu,
  double *sig);
 
void noise_pert(
  pert_t * pert,
  int track0,
  int track1,
  double *mu,
  double *sig);
 
void period(
  wave_t * wave,
  double lxymax,
  double dlxy,
  double *Amax,
  double *phimax,
  double *lhmax,
  double *kxmax,
  double *kymax,
  double *alphamax,
  double *betamax,
  char *filename);
 
void pert2wave(
  pert_t * pert,
  wave_t * wave,
  int track0,
  int track1,
  int xtrack0,
  int xtrack1);
 
int read_cris_l1(
  char *filename,
  cris_l1_t * l1,
  int apo);
 
void read_pert(
  char *filename,
  char *pertname,
  int dc,
  pert_t * pert);
 
void read_retr(
  char *filename,
  retr_t * ret);
 
void read_retr_help(
  double *help,
  int nds,
  int np,
  double mat[NDS][NPG]);
 
void read_wave(
  char *filename,
  wave_t * wave);
 
void ret2wave(
  retr_t * ret,
  wave_t * wave,
  int dataset,
  int ip);
 
void variance(
  wave_t * wave,
  double dh);
 
void write_wave(
  char *filename,
  wave_t * wave);