libgps.h

Go to the documentation of this file.

/*
  This file is part of the GPS Code Collection.
  
  the GPS 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 GPS 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 GPS Code Collection. If not, see
  <http://www.gnu.org/licenses/>.
  
  Copyright (C) 2019-2025 Forschungszentrum Juelich GmbH
*/
 
#include <netcdf.h>
#include <gsl/gsl_multifit.h>
#include <gsl/gsl_poly.h>
#include <gsl/gsl_spline.h>
#include "jurassic.h"
 
/* ------------------------------------------------------------
   Dimensions...
   ------------------------------------------------------------ */
 
#define EP 73
 
#define EX 721
 
#define EY 361
 
#define NDS 10000
 
#define NZ 5000
 
/* ------------------------------------------------------------
   Constants...
   ------------------------------------------------------------ */
 
#ifndef MA
#define MA 28.9644
#endif
 
#ifndef RA
#define RA (1e3 * RI / MA)
#endif
 
#ifndef RI
#define RI 8.3144598
#endif
 
/* ------------------------------------------------------------
   Macros...
   ------------------------------------------------------------ */
 
#define LAPSE(p1, t1, p2, t2)                                           \
  (1e3 * G0 / RA * ((t2) - (t1)) / ((t2) + (t1))                        \
   * ((p2) + (p1)) / ((p2) - (p1)))
 
#define NC(cmd) {                                    \
    int nc_result=(cmd);                             \
    if(nc_result!=NC_NOERR)                          \
      ERRMSG("%s", nc_strerror(nc_result));          \
  }
 
#define P(z)                                    \
  (P0 * exp(-(z) / H0))
 
#define Z(p)                                    \
  (H0 * log(P0 / (p)))
 
/* ------------------------------------------------------------
   Structs...
   ------------------------------------------------------------ */
 
typedef struct {
 
  int nds;
 
  int nz[NDS];
 
  double time[NDS];
 
  double z[NDS][NZ];
 
  double lon[NDS][NZ];
 
  double lat[NDS][NZ];
 
  double p[NDS][NZ];
 
  double t[NDS][NZ];
 
  double wv[NDS][NZ];
 
  double pt[NDS][NZ];
 
  double th[NDS];
 
  double tp[NDS];
 
  double tt[NDS];
 
  double tq[NDS];
 
  double tlon[NDS];
 
  double tlat[NDS];
 
} gps_t;
 
typedef struct {
 
  double time;
 
  int nx;
 
  int ny;
 
  int np;
 
  double lon[EX];
 
  double lat[EY];
 
  double p[EP];
 
  float t[EX][EY][EP];
 
} met_t;
 
/* ------------------------------------------------------------
   Functions...
   ------------------------------------------------------------ */
 
void add_var(
  int ncid,
  const char *varname,
  const char *unit,
  const char *longname,
  int type,
  int dimid[],
  int *varid,
  int ndims);
 
void detrend_met(
  gps_t * gps,
  char *metbase,
  double dt_met);
 
void gauss(
  gps_t * gps,
  double dx,
  double dy);
 
void grid_gps(
  gps_t * gps,
  double zmin,
  double zmax,
  int nz);
 
void get_met(
  char *metbase,
  double dt_met,
  double t,
  met_t * met0,
  met_t * met1);
 
void get_met_help(
  double t,
  int direct,
  char *metbase,
  double dt_met,
  char *filename);
 
void intpol_met_3d(
  float array[EX][EY][EP],
  int ip,
  int ix,
  int iy,
  double wp,
  double wx,
  double wy,
  double *var);
 
void intpol_met_space(
  met_t * met,
  double p,
  double lon,
  double lat,
  double *t);
 
void intpol_met_time(
  met_t * met0,
  met_t * met1,
  double ts,
  double p,
  double lon,
  double lat,
  double *t);
 
void hamming_low_pass(
  gps_t * gps,
  double dz);
 
void hamming_high_pass(
  gps_t * gps,
  double dz);
 
void poly(
  gps_t * gps,
  int dim,
  double zmin,
  double zmax);
 
void poly_help(
  double *xx,
  double *yy,
  int n,
  int dim,
  double xmin,
  double xmax);
 
void read_gps_prof(
  char *filename,
  gps_t * gps);
 
void read_gps(
  char *filename,
  gps_t * gps);
 
void read_met(
  char *filename,
  met_t * met);
 
void read_met_extrapolate(
  met_t * met);
 
void read_met_help(
  int ncid,
  char *varname,
  char *varname2,
  met_t * met,
  float dest[EX][EY][EP],
  float scl);
 
void read_met_periodic(
  met_t * met);
 
void spline(
  const double *x,
  const double *y,
  const int n,
  const double *x2,
  double *y2,
  const int n2,
  const int method);
 
void tropopause(
  gps_t * gps);
 
void tropopause_spline(
  gps_t * gps,
  int met_tropo);
 
void write_gps(
  char *filename,
  gps_t * gps);