MPTRAC
Macros | Functions
met_lapse.c File Reference

Calculate lapse rate statistics. More...

#include "mptrac.h"

Go to the source code of this file.

Macros

#define LAPSEMIN   -20.0
 Lapse rate minimum [K/km. More...
 
#define DLAPSE   0.1
 Lapse rate bin size [K/km]. More...
 
#define IDXMAX   400
 Maximum number of histogram bins. More...
 

Functions

int main (int argc, char *argv[])
 

Detailed Description

Calculate lapse rate statistics.

Definition in file met_lapse.c.

Macro Definition Documentation

◆ LAPSEMIN

#define LAPSEMIN   -20.0

Lapse rate minimum [K/km.

Definition at line 32 of file met_lapse.c.

◆ DLAPSE

#define DLAPSE   0.1

Lapse rate bin size [K/km].

Definition at line 35 of file met_lapse.c.

◆ IDXMAX

#define IDXMAX   400

Maximum number of histogram bins.

Definition at line 38 of file met_lapse.c.

Function Documentation

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 44 of file met_lapse.c.

46 {
47
48 ctl_t ctl;
49
50 clim_t *clim;
51
52 met_t *met;
53
54 dd_t *dd;
55
56 FILE *out;
57
58 static double p2[1000], t[1000], t2[1000], z[1000], z2[1000], lat_mean,
59 z_mean;
60
61 static int hist_max[1000], hist_min[1000], hist_mean[1000], hist_sig[1000],
62 nhist_max, nhist_min, nhist_mean, nhist_sig, np;
63
64 /* Allocate... */
65 ALLOC(clim, clim_t, 1);
66 ALLOC(met, met_t, 1);
67 ALLOC(dd, dd_t, 1);
68
69 /* Check arguments... */
70 if (argc < 4)
71 ERRMSG("Give parameters: <ctl> <lapse.tab> <met0> [ <met1> ... ]");
72
73 /* Read control parameters... */
74 mptrac_read_ctl(argv[1], argc, argv, &ctl);
75 const int dz =
76 (int) scan_ctl(argv[1], argc, argv, "LAPSE_DZ", -1, "20", NULL);
77 const double lat0 =
78 (int) scan_ctl(argv[1], argc, argv, "LAPSE_LAT0", -1, "-90", NULL);
79 const double lat1 =
80 (int) scan_ctl(argv[1], argc, argv, "LAPSE_LAT1", -1, "90", NULL);
81 const double z0 =
82 (int) scan_ctl(argv[1], argc, argv, "LAPSE_Z0", -1, "0", NULL);
83 const double z1 =
84 (int) scan_ctl(argv[1], argc, argv, "LAPSE_Z1", -1, "100", NULL);
85 const int intpol =
86 (int) scan_ctl(argv[1], argc, argv, "LAPSE_INTPOL", -1, "1", NULL);
87
88 /* Read climatological data... */
89 mptrac_read_clim(&ctl, clim);
90
91 /* Loop over files... */
92 for (int i = 3; i < argc; i++) {
93
94 /* Read meteorological data... */
95 if (!mptrac_read_met(argv[i], &ctl, clim, met, dd))
96 continue;
97
98 /* Get altitude and pressure profiles... */
99 for (int iz = 0; iz < met->np; iz++)
100 z[iz] = Z(met->p[iz]);
101 for (int iz = 0; iz <= 250; iz++) {
102 z2[iz] = 0.0 + 0.1 * iz;
103 p2[iz] = P(z2[iz]);
104 }
105
106 /* Loop over grid points... */
107 for (int ix = 0; ix < met->nx; ix++)
108 for (int iy = 0; iy < met->ny; iy++) {
109
110 /* Check latitude range... */
111 if (met->lat[iy] < lat0 || met->lat[iy] > lat1)
112 continue;
113
114 /* Interpolate temperature profile... */
115 for (int iz = 0; iz < met->np; iz++)
116 t[iz] = met->t[ix][iy][iz];
117 if (intpol == 1)
118 spline(z, t, met->np, z2, t2, 251, ctl.met_tropo_spline);
119 else
120 for (int iz = 0; iz <= 250; iz++) {
121 int idx = locate_irr(z, met->np, z2[iz]);
122 t2[iz] = LIN(z[idx], t[idx], z[idx + 1], t[idx + 1], z2[iz]);
123 }
124
125 /* Loop over vertical levels... */
126 for (int iz = 0; iz <= 250; iz++) {
127
128 /* Check height range... */
129 if (z2[iz] < z0 || z2[iz] > z1)
130 continue;
131
132 /* Check surface pressure... */
133 if (p2[iz] > met->ps[ix][iy])
134 continue;
135
136 /* Get mean latitude and height... */
137 lat_mean += met->lat[iy];
138 z_mean += z2[iz];
139 np++;
140
141 /* Get lapse rates within a vertical layer... */
142 int nlapse = 0;
143 double lapse_max = -1e99, lapse_min = 1e99, lapse_mean =
144 0, lapse_sig = 0;
145 for (int iz2 = iz + 1; iz2 <= iz + dz; iz2++) {
146 lapse_max =
147 MAX(LAPSE(p2[iz], t2[iz], p2[iz2], t2[iz2]), lapse_max);
148 lapse_min =
149 MIN(LAPSE(p2[iz], t2[iz], p2[iz2], t2[iz2]), lapse_min);
150 lapse_mean += LAPSE(p2[iz], t2[iz], p2[iz2], t2[iz2]);
151 lapse_sig += SQR(LAPSE(p2[iz], t2[iz], p2[iz2], t2[iz2]));
152 nlapse++;
153 }
154 lapse_mean /= nlapse;
155 lapse_sig = sqrt(MAX(lapse_sig / nlapse - SQR(lapse_mean), 0));
156
157 /* Get histograms... */
158 int idx = (int) ((lapse_max - LAPSEMIN) / DLAPSE);
159 if (idx >= 0 && idx < IDXMAX) {
160 hist_max[idx]++;
161 nhist_max++;
162 }
163
164 idx = (int) ((lapse_min - LAPSEMIN) / DLAPSE);
165 if (idx >= 0 && idx < IDXMAX) {
166 hist_min[idx]++;
167 nhist_min++;
168 }
169
170 idx = (int) ((lapse_mean - LAPSEMIN) / DLAPSE);
171 if (idx >= 0 && idx < IDXMAX) {
172 hist_mean[idx]++;
173 nhist_mean++;
174 }
175
176 idx = (int) ((lapse_sig - LAPSEMIN) / DLAPSE);
177 if (idx >= 0 && idx < IDXMAX) {
178 hist_sig[idx]++;
179 nhist_sig++;
180 }
181 }
182 }
183 }
184
185 /* Create output file... */
186 LOG(1, "Write lapse rate data: %s", argv[2]);
187 if (!(out = fopen(argv[2], "w")))
188 ERRMSG("Cannot create file!");
189
190 /* Write header... */
191 fprintf(out,
192 "# $1 = mean altitude [km]\n"
193 "# $2 = mean latitude [deg]\n"
194 "# $3 = lapse rate [K/km]\n"
195 "# $4 = counts of maxima per bin\n"
196 "# $5 = total number of maxima\n"
197 "# $6 = normalized frequency of maxima\n"
198 "# $7 = counts of minima per bin\n"
199 "# $8 = total number of minima\n"
200 "# $9 = normalized frequency of minima\n"
201 "# $10 = counts of means per bin\n"
202 "# $11 = total number of means\n"
203 "# $12 = normalized frequency of means\n"
204 "# $13 = counts of sigmas per bin\n"
205 "# $14 = total number of sigmas\n"
206 "# $15 = normalized frequency of sigmas\n\n");
207
208 /* Write data... */
209 double nmax_max = 0, nmax_min = 0, nmax_mean = 0, nmax_sig = 0;
210 for (int idx = 0; idx < IDXMAX; idx++) {
211 nmax_max = MAX(hist_max[idx], nmax_max);
212 nmax_min = MAX(hist_min[idx], nmax_min);
213 nmax_mean = MAX(hist_mean[idx], nmax_mean);
214 nmax_sig = MAX(hist_sig[idx], nmax_sig);
215 }
216 for (int idx = 0; idx < IDXMAX; idx++)
217 fprintf(out,
218 "%g %g %g %d %d %g %d %d %g %d %d %g %d %d %g\n",
219 z_mean / np, lat_mean / np, (idx + .5) * DLAPSE + LAPSEMIN,
220 hist_max[idx], nhist_max,
221 (double) hist_max[idx] / (double) nmax_max, hist_min[idx],
222 nhist_min, (double) hist_min[idx] / (double) nmax_min,
223 hist_mean[idx], nhist_mean,
224 (double) hist_mean[idx] / (double) nmax_mean, hist_sig[idx],
225 nhist_sig, (double) hist_sig[idx] / (double) nmax_sig);
226
227 /* Close file... */
228 fclose(out);
229
230 /* Free... */
231 free(clim);
232 free(met);
233
234 return EXIT_SUCCESS;
235}
LAPSEMIN
#define LAPSEMIN
Lapse rate minimum [K/km.
Definition: met_lapse.c:32
IDXMAX
#define IDXMAX
Maximum number of histogram bins.
Definition: met_lapse.c:38
DLAPSE
#define DLAPSE
Lapse rate bin size [K/km].
Definition: met_lapse.c:35
locate_irr
int locate_irr(const double *xx, const int n, const double x)
Locate the index of the interval containing a given value in a sorted array.
Definition: mptrac.c:2822
spline
void spline(const double *x, const double *y, const int n, const double *x2, double *y2, const int n2, const int method)
Performs spline interpolation or linear interpolation.
Definition: mptrac.c:11004
scan_ctl
double scan_ctl(const char *filename, int argc, char *argv[], const char *varname, const int arridx, const char *defvalue, char *value)
Scans a control file or command-line arguments for a specified variable.
Definition: mptrac.c:10899
mptrac_read_clim
void mptrac_read_clim(const ctl_t *ctl, clim_t *clim)
Reads various climatological data and populates the given climatology structure.
Definition: mptrac.c:5406
mptrac_read_met
int mptrac_read_met(const char *filename, const ctl_t *ctl, const clim_t *clim, met_t *met, dd_t *dd)
Reads meteorological data from a file, supporting multiple formats and MPI broadcasting.
Definition: mptrac.c:6357
mptrac_read_ctl
void mptrac_read_ctl(const char *filename, int argc, char *argv[], ctl_t *ctl)
Reads control parameters from a configuration file and populates the given structure.
Definition: mptrac.c:5466
LAPSE
#define LAPSE(p1, t1, p2, t2)
Calculate lapse rate.
Definition: mptrac.h:991
MIN
#define MIN(a, b)
Macro to determine the minimum of two values.
Definition: mptrac.h:1138
ERRMSG
#define ERRMSG(...)
Print an error message with contextual information and terminate the program.
Definition: mptrac.h:2043
Z
#define Z(p)
Convert pressure to altitude.
Definition: mptrac.h:1880
P
#define P(z)
Compute pressure at given altitude.
Definition: mptrac.h:1443
ALLOC
#define ALLOC(ptr, type, n)
Allocate memory for a pointer with error handling.
Definition: mptrac.h:416
SQR
#define SQR(x)
Compute the square of a value.
Definition: mptrac.h:1696
LOG
#define LOG(level,...)
Print a log message with a specified logging level.
Definition: mptrac.h:1973
LIN
#define LIN(x0, y0, x1, y1, x)
Linear interpolation.
Definition: mptrac.h:1010
MAX
#define MAX(a, b)
Macro to determine the maximum of two values.
Definition: mptrac.h:1037
clim_t
Climatological data.
Definition: mptrac.h:3487
ctl_t
Control parameters.
Definition: mptrac.h:2264
ctl_t::met_tropo_spline
int met_tropo_spline
Tropopause interpolation method (0=linear, 1=spline).
Definition: mptrac.h:2747
dd_t
Domain decomposition data structure.
Definition: mptrac.h:3720
met_t
Meteo data structure.
Definition: mptrac.h:3546
met_t::nx
int nx
Number of longitudes.
Definition: mptrac.h:3552
met_t::ny
int ny
Number of latitudes.
Definition: mptrac.h:3555
met_t::ps
float ps[EX][EY]
Surface pressure [hPa].
Definition: mptrac.h:3585
met_t::np
int np
Number of pressure levels.
Definition: mptrac.h:3558
met_t::t
float t[EX][EY][EP]
Temperature [K].
Definition: mptrac.h:3660
met_t::lat
double lat[EY]
Latitudes [deg].
Definition: mptrac.h:3567
met_t::p
double p[EP]
Pressure levels [hPa].
Definition: mptrac.h:3570
Here is the call graph for this function:
Generated on Mon Oct 13 2025 08:01:16 for MPTRAC by doxygen 1.9.4