libairs.h

Go to the documentation of this file.

/*
  This file is part of the AIRS Code Collection.
  
  the AIRS Code Collections is free software: you can redistribute it
  and/or modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation, either version 3 of
  the License, or (at your option) any later version.
  
  The AIRS Code Collection is distributed in the hope that it will be
  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with the AIRS Code Collection. If not, see
  <http://www.gnu.org/licenses/>.
  
  Copyright (C) 2019-2025 Forschungszentrum Juelich GmbH
*/
 
#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 <airs_rad_typ.h>
#include <airs_rad_struct.h>
#include <airs_ret_typ.h>
#include <airs_ret_struct.h>
#include "jurassic.h"
 
/* ------------------------------------------------------------
   Dimensions...
   ------------------------------------------------------------ */
 
#define NDS 200000
 
#define NPG 30
 
#define L1_NCHAN 34
 
#define L1_NTRACK 135
 
#define L1_NXTRACK 90
 
#define L2_NLAY 27
 
#define L2_NTRACK 45
 
#define L2_NXTRACK 30
 
#define PERT_NTRACK 132000
 
#define PERT_NXTRACK 360
 
#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];
 
  double lat[L1_NTRACK][L1_NXTRACK];
 
  double sat_z[L1_NTRACK];
 
  double sat_lon[L1_NTRACK];
 
  double sat_lat[L1_NTRACK];
 
  double nu[L1_NCHAN];
 
  float rad[L1_NTRACK][L1_NXTRACK][L1_NCHAN];
 
} airs_l1_t;
 
typedef struct {
 
  double time[L2_NTRACK][L2_NXTRACK];
 
  double z[L2_NTRACK][L2_NXTRACK][L2_NLAY];
 
  double lon[L2_NTRACK][L2_NXTRACK];
 
  double lat[L2_NTRACK][L2_NXTRACK];
 
  double p[L2_NLAY];
 
  double t[L2_NTRACK][L2_NXTRACK][L2_NLAY];
 
} airs_l2_t;
 
typedef struct {
 
  int ntrack;
 
  int nxtrack;
 
  double time[PERT_NTRACK][PERT_NXTRACK];
 
  double lon[PERT_NTRACK][PERT_NXTRACK];
 
  double lat[PERT_NTRACK][PERT_NXTRACK];
 
  double dc[PERT_NTRACK][PERT_NXTRACK];
 
  double bt[PERT_NTRACK][PERT_NXTRACK];
 
  double pt[PERT_NTRACK][PERT_NXTRACK];
 
  double var[PERT_NTRACK][PERT_NXTRACK];
 
} 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];
 
} ret_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 var[WX][WY];
 
  double fit[WX][WY];
 
} wave_t;
 
/* ------------------------------------------------------------
   Functions...
   ------------------------------------------------------------ */
 
void add_att(
  int ncid,
  int varid,
  const char *unit,
  const char *long_name);
 
void add_var(
  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(
  double *xx,
  double *yy,
  int n,
  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 day2doy(
  int year,
  int mon,
  int day,
  int *doy);
 
void doy2day(
  int year,
  int doy,
  int *mon,
  int *day);
 
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 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);
 
void read_l1(
  char *filename,
  airs_l1_t * l1);
 
void read_l2(
  char *filename,
  airs_l2_t * l2);
 
void read_pert(
  char *filename,
  char *pertname,
  pert_t * pert);
 
void read_retr(
  char *filename,
  ret_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 rad2wave(
  airs_rad_gran_t * airs_rad_gran,
  double *nu,
  int nd,
  wave_t * wave);
 
void ret2wave(
  ret_t * ret,
  wave_t * wave,
  int dataset,
  int ip);
 
void variance(
  wave_t * wave,
  double dh);
 
void write_l1(
  char *filename,
  airs_l1_t * l1);
 
void write_l2(
  char *filename,
  airs_l2_t * l2);
 
void write_wave(
  char *filename,
  wave_t * wave);