jurassic/doxygen/jurassic_8h_source.html

/*

  This file is part of JURASSIC.


  JURASSIC 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.


  JURASSIC 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 JURASSIC. If not, see <http://www.gnu.org/licenses/>.


  Copyright (C) 2003-2024 Forschungszentrum Juelich GmbH

*/


#ifndef JURASSIC_H

#define JURASSIC_H


#include <gsl/gsl_math.h>

#include <gsl/gsl_blas.h>

#include <gsl/gsl_linalg.h>

#include <gsl/gsl_randist.h>

#include <gsl/gsl_rng.h>

#include <gsl/gsl_statistics.h>

#include <math.h>

#include <omp.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>


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

   Macros...

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


#define ALLOC(ptr, type, n)                             \

  if((ptr=malloc((size_t)(n)*sizeof(type)))==NULL)      \

    ERRMSG("Out of memory!");


#define BRIGHT(rad, nu)                                 \

  (C2 * (nu) / gsl_log1p(C1 * POW3(nu) / (rad)))


#define DEG2RAD(deg)                            \

  ((deg) * (M_PI / 180.0))


#define DIST(a, b) sqrt(DIST2(a, b))


#define DIST2(a, b)                                                     \

  ((a[0]-b[0])*(a[0]-b[0])+(a[1]-b[1])*(a[1]-b[1])+(a[2]-b[2])*(a[2]-b[2]))


#define DOTP(a, b) (a[0]*b[0]+a[1]*b[1]+a[2]*b[2])


#define FREAD(ptr, type, size, out) {                                   \

    if(fread(ptr, sizeof(type), size, out)!=size)                       \

      ERRMSG("Error while reading!");                                   \

  }


#define FWRITE(ptr, type, size, out) {                                  \

    if(fwrite(ptr, sizeof(type), size, out)!=size)                      \

      ERRMSG("Error while writing!");                                   \

  }


#define MAX(a,b)                                \

  (((a)>(b))?(a):(b))


#define MIN(a,b)                                \

  (((a)<(b))?(a):(b))


#define LIN(x0, y0, x1, y1, x)                  \

  ((y0)+((y1)-(y0))/((x1)-(x0))*((x)-(x0)))


#define LOGX(x0, y0, x1, y1, x)                         \

  (((x)/(x0)>0 && (x1)/(x0)>0)                          \

   ? ((y0)+((y1)-(y0))*log((x)/(x0))/log((x1)/(x0)))    \

   : LIN(x0, y0, x1, y1, x))


#define LOGY(x0, y0, x1, y1, x)                                 \

  (((y1)/(y0)>0)                                                \

   ? ((y0)*exp(log((y1)/(y0))/((x1)-(x0))*((x)-(x0))))          \

   : LIN(x0, y0, x1, y1, x))


#define NORM(a) sqrt(DOTP(a, a))


#define PLANCK(T, nu)                           \

  (C1 * POW3(nu) / gsl_expm1(C2 * (nu) / (T)))


#define POW2(x) ((x)*(x))


#define POW3(x) ((x)*(x)*(x))


#define RAD2DEG(rad)                            \

  ((rad) * (180.0 / M_PI))


#define REFRAC(p, T)                            \

  (7.753e-05 * (p) / (T))


#define TIMER(name, mode)                               \

  {timer(name, __FILE__, __func__, __LINE__, mode);}


#define TOK(line, tok, format, var) {                   \

    if(((tok)=strtok((line), " \t"))) {                 \

      if(sscanf(tok, format, &(var))!=1) continue;      \

    } else ERRMSG("Error while reading!");              \

  }


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

   Log messages...

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


#ifndef LOGLEV

#define LOGLEV 2

#endif


#define LOG(level, ...) {                                               \

    if(level >= 2)                                                      \

      printf("  ");                                                     \

    if(level <= LOGLEV) {                                               \

      printf(__VA_ARGS__);                                              \

      printf("\n");                                                     \

    }                                                                   \

  }


#define WARN(...) {                                                     \

    printf("\nWarning (%s, %s, l%d): ", __FILE__, __func__, __LINE__);  \

    LOG(0, __VA_ARGS__);                                                \

  }


#define ERRMSG(...) {                                                   \

    printf("\nError (%s, %s, l%d): ", __FILE__, __func__, __LINE__);    \

    LOG(0, __VA_ARGS__);                                                \

    exit(EXIT_FAILURE);                                                 \

  }


#define PRINT(format, var)                                              \

  printf("Print (%s, %s, l%d): %s= "format"\n",                         \

         __FILE__, __func__, __LINE__, #var, var);


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

   Constants...

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


#ifndef C1

#define C1 1.19104259e-8

#endif


#ifndef C2

#define C2 1.43877506

#endif


#ifndef EPSMIN

#define EPSMIN 0

#endif


#ifndef EPSMAX

#define EPSMAX 1

#endif


#ifndef G0

#define G0 9.80665

#endif


#ifndef H0

#define H0 7.0

#endif


#ifndef KB

#define KB 1.3806504e-23

#endif


#ifndef ME

#define ME 5.976e24

#endif


#ifndef NA

#define NA 6.02214199e23

#endif


#ifndef RE

#define RE 6367.421

#endif


#ifndef RI

#define RI 8.3144598

#endif


#ifndef P0

#define P0 1013.25

#endif


#ifndef T0

#define T0 273.15

#endif


#ifndef TMIN

#define TMIN 100.

#endif


#ifndef TMAX

#define TMAX 400.

#endif


#ifndef TSUN

#define TSUN 5780.

#endif


#ifndef UMIN

#define UMIN 0

#endif


#ifndef UMAX

#define UMAX 1e30

#endif


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

   Dimensions...

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


#ifndef NCL

#define NCL 8

#endif


#ifndef ND

#define ND 128

#endif


#ifndef NG

#define NG 8

#endif


#ifndef NP

#define NP 256

#endif


#ifndef NR

#define NR 256

#endif


#ifndef NSF

#define NSF 8

#endif


#ifndef NW

#define NW 4

#endif


#ifndef LEN

#define LEN 10000

#endif


#ifndef M

#define M (NR*ND)

#endif


#ifndef N

#define N ((2+NG+NW)*NP+NCL+NSF+5)

#endif


#ifndef NQ

#define NQ (7+NG+NW+NCL+NSF)

#endif


#ifndef NLOS

#define NLOS 4096

#endif


#ifndef NSHAPE

#define NSHAPE 20000

#endif


#ifndef NFOV

#define NFOV 5

#endif


#ifndef TBLNP

#define TBLNP 41

#endif


#ifndef TBLNT

#define TBLNT 30

#endif


#ifndef TBLNU

#define TBLNU 320

#endif


#ifndef TBLNS

#define TBLNS 1200

#endif


#ifndef RFMNPTS

#define RFMNPTS 10000000

#endif


#ifndef RFMLINE

#define RFMLINE 100000

#endif


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

   Quantity indices...

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


#define IDXP 0


#define IDXT 1


#define IDXQ(ig) (2+ig)


#define IDXK(iw) (2+ctl->ng+iw)


#define IDXCLZ (2+ctl->ng+ctl->nw)


#define IDXCLDZ (3+ctl->ng+ctl->nw)


#define IDXCLK(icl) (4+ctl->ng+ctl->nw+icl)


#define IDXSFZ (4+ctl->ng+ctl->nw+ctl->ncl)


#define IDXSFP (5+ctl->ng+ctl->nw+ctl->ncl)


#define IDXSFT (6+ctl->ng+ctl->nw+ctl->ncl)


#define IDXSFEPS(isf) (7+ctl->ng+ctl->nw+ctl->ncl+isf)


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

   Structs...

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


typedef struct {


  int np;


  double time[NP];


  double z[NP];


  double lon[NP];


  double lat[NP];


  double p[NP];


  double t[NP];


  double q[NG][NP];


  double k[NW][NP];


  double clz;


  double cldz;


  double clk[NCL];


  double sfz;


  double sfp;


  double sft;


  double sfeps[NSF];


} atm_t;


typedef struct {


  int ng;


  char emitter[NG][LEN];


  int nd;


  double nu[ND];


  int nw;


  int window[ND];


  int ncl;


  double clnu[NCL];


  int nsf;


  double sfnu[NSF];


  int sftype;


  double sfsza;


  char tblbase[LEN];


  int tblfmt;


  double hydz;


  int ctm_co2;


  int ctm_h2o;


  int ctm_n2;


  int ctm_o2;


  int refrac;


  double rayds;


  double raydz;


  char fov[LEN];


  double retp_zmin;


  double retp_zmax;


  double rett_zmin;


  double rett_zmax;


  double retq_zmin[NG];


  double retq_zmax[NG];


  double retk_zmin[NW];


  double retk_zmax[NW];


  int ret_clz;


  int ret_cldz;


  int ret_clk;


  int ret_sfz;


  int ret_sfp;


  int ret_sft;


  int ret_sfeps;


  int write_bbt;


  int write_matrix;


  int formod;


  char rfmbin[LEN];


  char rfmhit[LEN];


  char rfmxsc[NG][LEN];


} ctl_t;


typedef struct {


  int np;


  double z[NLOS];


  double lon[NLOS];


  double lat[NLOS];


  double p[NLOS];


  double t[NLOS];


  double q[NLOS][NG];


  double k[NLOS][ND];


  double sft;


  double sfeps[ND];


  double ds[NLOS];


  double u[NLOS][NG];


  double cgp[NLOS][NG];


  double cgt[NLOS][NG];


  double cgu[NLOS][NG];


  double eps[NLOS][ND];


  double src[NLOS][ND];


} los_t;


typedef struct {


  int nr;


  double time[NR];


  double obsz[NR];


  double obslon[NR];


  double obslat[NR];


  double vpz[NR];


  double vplon[NR];


  double vplat[NR];


  double tpz[NR];


  double tplon[NR];


  double tplat[NR];


  double tau[ND][NR];


  double rad[ND][NR];


} obs_t;


typedef struct {


  int np[ND][NG];


  int nt[ND][NG][TBLNP];


  int nu[ND][NG][TBLNP][TBLNT];


  double p[ND][NG][TBLNP];


  double t[ND][NG][TBLNP][TBLNT];


  float u[ND][NG][TBLNP][TBLNT][TBLNU];


  float eps[ND][NG][TBLNP][TBLNT][TBLNU];


  double st[TBLNS];


  double sr[TBLNS][ND];


} tbl_t;


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

   Functions...

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


size_t atm2x(

  const ctl_t * ctl,

  const atm_t * atm,

  gsl_vector * x,

  int *iqa,

  int *ipa);


void atm2x_help(

  const double value,

  const int value_iqa,

  const int value_ip,

  gsl_vector * x,

  int *iqa,

  int *ipa,

  size_t *n);


void cart2geo(

  const double *x,

  double *z,

  double *lon,

  double *lat);


void climatology(

  const ctl_t * ctl,

  atm_t * atm_mean);


double ctmco2(

  const double nu,

  const double p,

  const double t,

  const double u);


double ctmh2o(

  const double nu,

  const double p,

  const double t,

  const double q,

  const double u);


double ctmn2(

  const double nu,

  const double p,

  const double t);


double ctmo2(

  const double nu,

  const double p,

  const double t);


void copy_atm(

  const ctl_t * ctl,

  atm_t * atm_dest,

  const atm_t * atm_src,

  const int init);


void copy_obs(

  const ctl_t * ctl,

  obs_t * obs_dest,

  const obs_t * obs_src,

  const int init);


int find_emitter(

  const ctl_t * ctl,

  const char *emitter);


void formod(

  const ctl_t * ctl,

  atm_t * atm,

  obs_t * obs);


void formod_continua(

  const ctl_t * ctl,

  const los_t * los,

  const int ip,

  double *beta);


void formod_fov(

  const ctl_t * ctl,

  obs_t * obs);


void formod_pencil(

  const ctl_t * ctl,

  const atm_t * atm,

  obs_t * obs,

  const int ir);


void formod_rfm(

  const ctl_t * ctl,

  const atm_t * atm,

  obs_t * obs);


void formod_srcfunc(

  const ctl_t * ctl,

  const tbl_t * tbl,

  const double t,

  double *src);


void geo2cart(

  const double z,

  const double lon,

  const double lat,

  double *x);


void hydrostatic(

  const ctl_t * ctl,

  atm_t * atm);


void idx2name(

  const ctl_t * ctl,

  const int idx,

  char *quantity);


void init_srcfunc(

  const ctl_t * ctl,

  tbl_t * tbl);


void intpol_atm(

  const ctl_t * ctl,

  const atm_t * atm,

  const double z,

  double *p,

  double *t,

  double *q,

  double *k);


void intpol_tbl_cga(

  const ctl_t * ctl,

  const tbl_t * tbl,

  const los_t * los,

  const int ip,

  double tau_path[ND][NG],

  double tau_seg[ND]);


void intpol_tbl_ega(

  const ctl_t * ctl,

  const tbl_t * tbl,

  const los_t * los,

  const int ip,

  double tau_path[ND][NG],

  double tau_seg[ND]);


double intpol_tbl_eps(

  const tbl_t * tbl,

  const int ig,

  const int id,

  const int ip,

  const int it,

  const double u);


double intpol_tbl_u(

  const tbl_t * tbl,

  const int ig,

  const int id,

  const int ip,

  const int it,

  const double eps);


void jsec2time(

  const double jsec,

  int *year,

  int *mon,

  int *day,

  int *hour,

  int *min,

  int *sec,

  double *remain);


void kernel(

  ctl_t * ctl,

  atm_t * atm,

  obs_t * obs,

  gsl_matrix * k);


int locate_irr(

  const double *xx,

  const int n,

  const double x);


int locate_reg(

  const double *xx,

  const int n,

  const double x);


int locate_tbl(

  const float *xx,

  const int n,

  const double x);


size_t obs2y(

  const ctl_t * ctl,

  const obs_t * obs,

  gsl_vector * y,

  int *ida,

  int *ira);


void raytrace(

  const ctl_t * ctl,

  const atm_t * atm,

  obs_t * obs,

  los_t * los,

  const int ir);


void read_atm(

  const char *dirname,

  const char *filename,

  const ctl_t * ctl,

  atm_t * atm);


void read_ctl(

  int argc,

  char *argv[],

  ctl_t * ctl);


void read_matrix(

  const char *dirname,

  const char *filename,

  gsl_matrix * matrix);


void read_obs(

  const char *dirname,

  const char *filename,

  const ctl_t * ctl,

  obs_t * obs);


double read_obs_rfm(

  const char *basename,

  const double z,

  double *nu,

  double *f,

  int n);


void read_rfm_spec(

  const char *filename,

  double *nu,

  double *rad,

  int *npts);


void read_shape(

  const char *filename,

  double *x,

  double *y,

  int *n);


void read_tbl(

  const ctl_t * ctl,

  tbl_t * tbl);


double scan_ctl(

  int argc,

  char *argv[],

  const char *varname,

  int arridx,

  const char *defvalue,

  char *value);


double sza(

  double sec,

  double lon,

  double lat);


void tangent_point(

  const los_t * los,

  double *tpz,

  double *tplon,

  double *tplat);


void time2jsec(

  const int year,

  const int mon,

  const int day,

  const int hour,

  const int min,

  const int sec,

  const double remain,

  double *jsec);


void timer(

  const char *name,

  const char *file,

  const char *func,

  int line,

  int mode);


void write_atm(

  const char *dirname,

  const char *filename,

  const ctl_t * ctl,

  const atm_t * atm);


void write_atm_rfm(

  const char *filename,

  const ctl_t * ctl,

  const atm_t * atm);


void write_matrix(

  const char *dirname,

  const char *filename,

  const ctl_t * ctl,

  const gsl_matrix * matrix,

  const atm_t * atm,

  const obs_t * obs,

  const char *rowspace,

  const char *colspace,

  const char *sort);


void write_obs(

  const char *dirname,

  const char *filename,

  const ctl_t * ctl,

  const obs_t * obs);


void write_shape(

  const char *filename,

  const double *x,

  const double *y,

  const int n);


void write_tbl(

  const ctl_t * ctl,

  const tbl_t * tbl);


void x2atm(

  const ctl_t * ctl,

  const gsl_vector * x,

  atm_t * atm);


void x2atm_help(

  double *value,

  const gsl_vector * x,

  size_t *n);


void y2obs(

  const ctl_t * ctl,

  const gsl_vector * y,

  obs_t * obs);


#endif

LEN
#define LEN
Maximum length of ASCII data lines.
Definition: jurassic.h:383

read_matrix
void read_matrix(const char *dirname, const char *filename, gsl_matrix *matrix)
Read matrix.
Definition: jurassic.c:4660

timer
void timer(const char *name, const char *file, const char *func, int line, int mode)
Measure wall-clock time.
Definition: jurassic.c:5301

read_rfm_spec
void read_rfm_spec(const char *filename, double *nu, double *rad, int *npts)
Read RFM spectrum.
Definition: jurassic.c:4859

read_tbl
void read_tbl(const ctl_t *ctl, tbl_t *tbl)
Read look-up table data.
Definition: jurassic.c:4952

write_atm
void write_atm(const char *dirname, const char *filename, const ctl_t *ctl, const atm_t *atm)
Write atmospheric data.
Definition: jurassic.c:5339

locate_reg
int locate_reg(const double *xx, const int n, const double x)
Find array index for regular grid.
Definition: jurassic.c:4137

intpol_tbl_ega
void intpol_tbl_ega(const ctl_t *ctl, const tbl_t *tbl, const los_t *los, const int ip, double tau_path[ND][NG], double tau_seg[ND])
Get transmittance from look-up tables (EGA method).
Definition: jurassic.c:3799

read_obs_rfm
double read_obs_rfm(const char *basename, const double z, double *nu, double *f, int n)
Read observation data in RFM format.
Definition: jurassic.c:4801

formod_rfm
void formod_rfm(const ctl_t *ctl, const atm_t *atm, obs_t *obs)
Apply RFM for radiative transfer calculations.
Definition: jurassic.c:3342

ctmo2
double ctmo2(const double nu, const double p, const double t)
Compute oxygen continuum (absorption coefficient).
Definition: jurassic.c:2861

idx2name
void idx2name(const ctl_t *ctl, const int idx, char *quantity)
Determine name of state vector quantity for given index.
Definition: jurassic.c:3586

read_ctl
void read_ctl(int argc, char *argv[], ctl_t *ctl)
Read forward model control parameters.
Definition: jurassic.c:4550

formod_continua
void formod_continua(const ctl_t *ctl, const los_t *los, const int ip, double *beta)
Compute absorption coefficient of continua.
Definition: jurassic.c:3075

raytrace
void raytrace(const ctl_t *ctl, const atm_t *atm, obs_t *obs, los_t *los, const int ir)
Do ray-tracing to determine LOS.
Definition: jurassic.c:4205

locate_irr
int locate_irr(const double *xx, const int n, const double x)
Find array index for irregular grid.
Definition: jurassic.c:4107

time2jsec
void time2jsec(const int year, const int mon, const int day, const int hour, const int min, const int sec, const double remain, double *jsec)
Convert date to seconds.
Definition: jurassic.c:5270

x2atm
void x2atm(const ctl_t *ctl, const gsl_vector *x, atm_t *atm)
Decompose parameter vector or state vector.
Definition: jurassic.c:5899

atm2x_help
void atm2x_help(const double value, const int value_iqa, const int value_ip, gsl_vector *x, int *iqa, int *ipa, size_t *n)
Add element to state vector.
Definition: jurassic.c:87

ctmh2o
double ctmh2o(const double nu, const double p, const double t, const double q, const double u)
Compute water vapor continuum (optical depth).
Definition: jurassic.c:1746

intpol_tbl_cga
void intpol_tbl_cga(const ctl_t *ctl, const tbl_t *tbl, const los_t *los, const int ip, double tau_path[ND][NG], double tau_seg[ND])
Get transmittance from look-up tables (CGA method).
Definition: jurassic.c:3710

write_atm_rfm
void write_atm_rfm(const char *filename, const ctl_t *ctl, const atm_t *atm)
Write atmospheric data in RFM format.
Definition: jurassic.c:5457

ND
#define ND
Maximum number of radiance channels.
Definition: jurassic.h:353

intpol_tbl_u
double intpol_tbl_u(const tbl_t *tbl, const int ig, const int id, const int ip, const int it, const double eps)
Interpolate column density from look-up tables.
Definition: jurassic.c:3933

intpol_tbl_eps
double intpol_tbl_eps(const tbl_t *tbl, const int ig, const int id, const int ip, const int it, const double u)
Interpolate emissivity from look-up tables.
Definition: jurassic.c:3894

write_tbl
void write_tbl(const ctl_t *ctl, const tbl_t *tbl)
Write look-up table data.
Definition: jurassic.c:5813

intpol_atm
void intpol_atm(const ctl_t *ctl, const atm_t *atm, const double z, double *p, double *t, double *q, double *k)
Interpolate atmospheric data.
Definition: jurassic.c:3685

find_emitter
int find_emitter(const ctl_t *ctl, const char *emitter)
Find index of an emitter.
Definition: jurassic.c:3013

formod_pencil
void formod_pencil(const ctl_t *ctl, const atm_t *atm, obs_t *obs, const int ir)
Compute radiative transfer for a pencil beam.
Definition: jurassic.c:3196

tangent_point
void tangent_point(const los_t *los, double *tpz, double *tplon, double *tplat)
Find tangent point of a given LOS.
Definition: jurassic.c:5226

TBLNU
#define TBLNU
Maximum number of column densities in emissivity tables.
Definition: jurassic.h:428

formod
void formod(const ctl_t *ctl, atm_t *atm, obs_t *obs)
Determine ray paths and compute radiative transfer.
Definition: jurassic.c:3026

climatology
void climatology(const ctl_t *ctl, atm_t *atm_mean)
Interpolate climatological data.
Definition: jurassic.c:123

ctmco2
double ctmco2(const double nu, const double p, const double t, const double u)
Compute carbon dioxide continuum (optical depth).
Definition: jurassic.c:886

read_atm
void read_atm(const char *dirname, const char *filename, const ctl_t *ctl, atm_t *atm)
Read atmospheric data.
Definition: jurassic.c:4445

copy_obs
void copy_obs(const ctl_t *ctl, obs_t *obs_dest, const obs_t *obs_src, const int init)
Copy and initialize observation data.
Definition: jurassic.c:2975

read_obs
void read_obs(const char *dirname, const char *filename, const ctl_t *ctl, obs_t *obs)
Read observation data.
Definition: jurassic.c:4700

write_obs
void write_obs(const char *dirname, const char *filename, const ctl_t *ctl, const obs_t *obs)
Write observation data.
Definition: jurassic.c:5673

TBLNT
#define TBLNT
Maximum number of temperatures in emissivity tables.
Definition: jurassic.h:423

x2atm_help
void x2atm_help(double *value, const gsl_vector *x, size_t *n)
Get element from state vector.
Definition: jurassic.c:5953

cart2geo
void cart2geo(const double *x, double *z, double *lon, double *lat)
Convert Cartesian coordinates to geolocation.
Definition: jurassic.c:108

NP
#define NP
Maximum number of atmospheric data points.
Definition: jurassic.h:363

formod_fov
void formod_fov(const ctl_t *ctl, obs_t *obs)
Apply field of view convolution.
Definition: jurassic.c:3121

init_srcfunc
void init_srcfunc(const ctl_t *ctl, tbl_t *tbl)
Initialize source function table.
Definition: jurassic.c:3631

write_shape
void write_shape(const char *filename, const double *x, const double *y, const int n)
Write shape function.
Definition: jurassic.c:5783

NG
#define NG
Maximum number of emitters.
Definition: jurassic.h:358

formod_srcfunc
void formod_srcfunc(const ctl_t *ctl, const tbl_t *tbl, const double t, double *src)
Compute Planck source function.
Definition: jurassic.c:3483

jsec2time
void jsec2time(const double jsec, int *year, int *mon, int *day, int *hour, int *min, int *sec, double *remain)
Convert seconds to date.
Definition: jurassic.c:3973

TBLNS
#define TBLNS
Maximum number of source function temperature levels.
Definition: jurassic.h:433

scan_ctl
double scan_ctl(int argc, char *argv[], const char *varname, int arridx, const char *defvalue, char *value)
Search control parameter file for variable entry.
Definition: jurassic.c:5117

sza
double sza(double sec, double lon, double lat)
Calculate solar zenith angle.
Definition: jurassic.c:5186

copy_atm
void copy_atm(const ctl_t *ctl, atm_t *atm_dest, const atm_t *atm_src, const int init)
Copy and initialize atmospheric data.
Definition: jurassic.c:2921

obs2y
size_t obs2y(const ctl_t *ctl, const obs_t *obs, gsl_vector *y, int *ida, int *ira)
Compose measurement vector.
Definition: jurassic.c:4178

y2obs
void y2obs(const ctl_t *ctl, const gsl_vector *y, obs_t *obs)
Decompose measurement vector.
Definition: jurassic.c:5965

hydrostatic
void hydrostatic(const ctl_t *ctl, atm_t *atm)
Set hydrostatic equilibrium.
Definition: jurassic.c:3520

read_shape
void read_shape(const char *filename, double *x, double *y, int *n)
Read shape function.
Definition: jurassic.c:4910

ctmn2
double ctmn2(const double nu, const double p, const double t)
Compute nitrogen continuum (absorption coefficient).
Definition: jurassic.c:2796

atm2x
size_t atm2x(const ctl_t *ctl, const atm_t *atm, gsl_vector *x, int *iqa, int *ipa)
Compose state vector or parameter vector.
Definition: jurassic.c:29

TBLNP
#define TBLNP
Maximum number of pressure levels in emissivity tables.
Definition: jurassic.h:418

geo2cart
void geo2cart(const double z, const double lon, const double lat, double *x)
Convert geolocation to Cartesian coordinates.
Definition: jurassic.c:3500

NSF
#define NSF
Maximum number of surface layer spectral grid points.
Definition: jurassic.h:373

write_matrix
void write_matrix(const char *dirname, const char *filename, const ctl_t *ctl, const gsl_matrix *matrix, const atm_t *atm, const obs_t *obs, const char *rowspace, const char *colspace, const char *sort)
Write matrix.
Definition: jurassic.c:5495

NCL
#define NCL
Maximum number of cloud layer spectral grid points.
Definition: jurassic.h:348

NLOS
#define NLOS
Maximum number of LOS points.
Definition: jurassic.h:403

kernel
void kernel(ctl_t *ctl, atm_t *atm, obs_t *obs, gsl_matrix *k)
Compute Jacobians.
Definition: jurassic.c:4006

NR
#define NR
Maximum number of ray paths.
Definition: jurassic.h:368

locate_tbl
int locate_tbl(const float *xx, const int n, const double x)
Find array index in float array.
Definition: jurassic.c:4156

NW
#define NW
Maximum number of spectral windows.
Definition: jurassic.h:378

atm_t
Atmospheric data.
Definition: jurassic.h:488

atm_t::sfz
double sfz
Surface height [km].
Definition: jurassic.h:527

atm_t::sfp
double sfp
Surface pressure [hPa].
Definition: jurassic.h:530

atm_t::clz
double clz
Cloud layer height [km].
Definition: jurassic.h:518

atm_t::np
int np
Number of data points.
Definition: jurassic.h:491

atm_t::cldz
double cldz
Cloud layer depth [km].
Definition: jurassic.h:521

atm_t::sft
double sft
Surface temperature [K].
Definition: jurassic.h:533

ctl_t
Forward model control parameters.
Definition: jurassic.h:541

ctl_t::write_matrix
int write_matrix
Write matrix file (0=no, 1=yes).
Definition: jurassic.h:661

ctl_t::nw
int nw
Number of spectral windows.
Definition: jurassic.h:556

ctl_t::retp_zmin
double retp_zmin
Minimum altitude for pressure retrieval [km].
Definition: jurassic.h:613

ctl_t::hydz
double hydz
Reference height for hydrostatic pressure profile (-999 to skip) [km].
Definition: jurassic.h:586

ctl_t::ret_sfz
int ret_sfz
Retrieve surface layer height (0=no, 1=yes).
Definition: jurassic.h:646

ctl_t::ctm_co2
int ctm_co2
Compute CO2 continuum (0=no, 1=yes).
Definition: jurassic.h:589

ctl_t::rett_zmax
double rett_zmax
Maximum altitude for temperature retrieval [km].
Definition: jurassic.h:622

ctl_t::ret_sfeps
int ret_sfeps
Retrieve surface layer emissivity (0=no, 1=yes).
Definition: jurassic.h:655

ctl_t::ret_sft
int ret_sft
Retrieve surface layer temperature (0=no, 1=yes).
Definition: jurassic.h:652

ctl_t::ret_clz
int ret_clz
Retrieve cloud layer height (0=no, 1=yes).
Definition: jurassic.h:637

ctl_t::ctm_n2
int ctm_n2
Compute N2 continuum (0=no, 1=yes).
Definition: jurassic.h:595

ctl_t::ctm_h2o
int ctm_h2o
Compute H2O continuum (0=no, 1=yes).
Definition: jurassic.h:592

ctl_t::formod
int formod
Forward model (0=CGA, 1=EGA, 2=RFM).
Definition: jurassic.h:664

ctl_t::ng
int ng
Number of emitters.
Definition: jurassic.h:544

ctl_t::refrac
int refrac
Take into account refractivity (0=no, 1=yes).
Definition: jurassic.h:601

ctl_t::rett_zmin
double rett_zmin
Minimum altitude for temperature retrieval [km].
Definition: jurassic.h:619

ctl_t::sfsza
double sfsza
Solar zenith angle at the surface [deg] (-999=auto).
Definition: jurassic.h:577

ctl_t::nd
int nd
Number of radiance channels.
Definition: jurassic.h:550

ctl_t::sftype
int sftype
Surface treatment (0=none, 1=emissions, 2=downward, 3=solar).
Definition: jurassic.h:574

ctl_t::ret_sfp
int ret_sfp
Retrieve surface layer pressure (0=no, 1=yes).
Definition: jurassic.h:649

ctl_t::ncl
int ncl
Number of cloud layer spectral grid points.
Definition: jurassic.h:562

ctl_t::ctm_o2
int ctm_o2
Compute O2 continuum (0=no, 1=yes).
Definition: jurassic.h:598

ctl_t::ret_clk
int ret_clk
Retrieve cloud layer extinction (0=no, 1=yes).
Definition: jurassic.h:643

ctl_t::nsf
int nsf
Number of surface layer spectral grid points.
Definition: jurassic.h:568

ctl_t::rayds
double rayds
Maximum step length for raytracing [km].
Definition: jurassic.h:604

ctl_t::ret_cldz
int ret_cldz
Retrieve cloud layer depth (0=no, 1=yes).
Definition: jurassic.h:640

ctl_t::tblfmt
int tblfmt
Look-up table file format (1=ASCII, 2=binary).
Definition: jurassic.h:583

ctl_t::raydz
double raydz
Vertical step length for raytracing [km].
Definition: jurassic.h:607

ctl_t::write_bbt
int write_bbt
Use brightness temperature instead of radiance (0=no, 1=yes).
Definition: jurassic.h:658

ctl_t::retp_zmax
double retp_zmax
Maximum altitude for pressure retrieval [km].
Definition: jurassic.h:616

los_t
Line-of-sight data.
Definition: jurassic.h:678

los_t::sft
double sft
Surface temperature [K].
Definition: jurassic.h:705

los_t::np
int np
Number of LOS points.
Definition: jurassic.h:681

obs_t
Observation geometry and radiance data.
Definition: jurassic.h:734

obs_t::nr
int nr
Number of ray paths.
Definition: jurassic.h:737

tbl_t
Emissivity look-up tables.
Definition: jurassic.h:778