MPTRAC
Functions
atm_dist.c File Reference

Calculate transport deviations of trajectories. More...

#include "mptrac.h"

Go to the source code of this file.

Functions

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

Detailed Description

Calculate transport deviations of trajectories.

Definition in file atm_dist.c.

Function Documentation

◆ main()

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

Definition at line 27 of file atm_dist.c.

29 {
30
31 ctl_t ctl;
32
33 atm_t *atm1, *atm2;
34
35 FILE *out;
36
37 double *ahtd, *aqtd, *avtd, ahtdm, aqtdm[NQ], avtdm, *lat1_old, *lat2_old,
38 *lh1, *lh2, *lon1_old, *lon2_old, *lv1, *lv2, *rhtd, *rqtd, *rvtd, rhtdm,
39 rqtdm[NQ], rvtdm, t0 =
40 0, x0[3], x1[3], x2[3], z1, *z1_old, z2, *z2_old, *work;
41
42 int f, init = 0, ip, iq, np;
43
44 /* Allocate... */
45 ALLOC(atm1, atm_t, 1);
46 ALLOC(atm2, atm_t, 1);
47 ALLOC(lon1_old, double,
48 NP);
49 ALLOC(lat1_old, double,
50 NP);
51 ALLOC(z1_old, double,
52 NP);
53 ALLOC(lh1, double,
54 NP);
55 ALLOC(lv1, double,
56 NP);
57 ALLOC(lon2_old, double,
58 NP);
59 ALLOC(lat2_old, double,
60 NP);
61 ALLOC(z2_old, double,
62 NP);
63 ALLOC(lh2, double,
64 NP);
65 ALLOC(lv2, double,
66 NP);
67 ALLOC(ahtd, double,
68 NP);
69 ALLOC(avtd, double,
70 NP);
71 ALLOC(aqtd, double,
72 NP * NQ);
73 ALLOC(rhtd, double,
74 NP);
75 ALLOC(rvtd, double,
76 NP);
77 ALLOC(rqtd, double,
78 NP * NQ);
79 ALLOC(work, double,
80 NP);
81
82 /* Check arguments... */
83 if (argc < 6)
84 ERRMSG("Give parameters: <ctl> <dist.tab> <param> <atm1a> <atm1b>"
85 " [<atm2a> <atm2b> ...]");
86
87 /* Read control parameters... */
88 read_ctl(argv[1], argc, argv, &ctl);
89 int ens = (int) scan_ctl(argv[1], argc, argv, "DIST_ENS", -1, "-999", NULL);
90 double p0 = P(scan_ctl(argv[1], argc, argv, "DIST_Z0", -1, "-1000", NULL));
91 double p1 = P(scan_ctl(argv[1], argc, argv, "DIST_Z1", -1, "1000", NULL));
92 double lat0 = scan_ctl(argv[1], argc, argv, "DIST_LAT0", -1, "-1000", NULL);
93 double lat1 = scan_ctl(argv[1], argc, argv, "DIST_LAT1", -1, "1000", NULL);
94 double lon0 = scan_ctl(argv[1], argc, argv, "DIST_LON0", -1, "-1000", NULL);
95 double lon1 = scan_ctl(argv[1], argc, argv, "DIST_LON1", -1, "1000", NULL);
96 double zscore =
97 scan_ctl(argv[1], argc, argv, "DIST_ZSCORE", -1, "-999", NULL);
98
99 /* Write info... */
100 LOG(1, "Write transport deviations: %s", argv[2]);
101
102 /* Create output file... */
103 if (!(out = fopen(argv[2], "w")))
104 ERRMSG("Cannot create file!");
105
106 /* Write header... */
107 fprintf(out,
108 "# $1 = time [s]\n"
109 "# $2 = time difference [s]\n"
110 "# $3 = absolute horizontal distance (%s) [km]\n"
111 "# $4 = relative horizontal distance (%s) [%%]\n"
112 "# $5 = absolute vertical distance (%s) [km]\n"
113 "# $6 = relative vertical distance (%s) [%%]\n",
114 argv[3], argv[3], argv[3], argv[3]);
115 for (iq = 0; iq < ctl.nq; iq++)
116 fprintf(out,
117 "# $%d = %s absolute difference (%s) [%s]\n"
118 "# $%d = %s relative difference (%s) [%%]\n",
119 7 + 2 * iq, ctl.qnt_name[iq], argv[3], ctl.qnt_unit[iq],
120 8 + 2 * iq, ctl.qnt_name[iq], argv[3]);
121 fprintf(out, "# $%d = number of particles\n\n", 7 + 2 * ctl.nq);
122
123 /* Loop over file pairs... */
124 for (f = 4; f < argc; f += 2) {
125
126 /* Read atmopheric data... */
127 if (!read_atm(argv[f], &ctl, atm1) || !read_atm(argv[f + 1], &ctl, atm2))
128 continue;
129
130 /* Check if structs match... */
131 if (atm1->np != atm2->np)
132 ERRMSG("Different numbers of particles!");
133
134 /* Get time from filename... */
135 double t = time_from_filename(argv[f], ctl.atm_type < 2 ? 20 : 19);
136
137 /* Save initial time... */
138 if (!init) {
139 init = 1;
140 t0 = t;
141 }
142
143 /* Init... */
144 np = 0;
145 for (ip = 0; ip < atm1->np; ip++) {
146 ahtd[ip] = avtd[ip] = rhtd[ip] = rvtd[ip] = 0;
147 for (iq = 0; iq < ctl.nq; iq++)
148 aqtd[iq * NP + ip] = rqtd[iq * NP + ip] = 0;
149 }
150
151 /* Loop over air parcels... */
152 for (ip = 0; ip < atm1->np; ip++) {
153
154 /* Check air parcel index... */
155 if (ctl.qnt_idx > 0
156 && (atm1->q[ctl.qnt_idx][ip] != atm2->q[ctl.qnt_idx][ip]))
157 ERRMSG("Air parcel index does not match!");
158
159 /* Check ensemble index... */
160 if (ctl.qnt_ens > 0
161 && (atm1->q[ctl.qnt_ens][ip] != ens
162 || atm2->q[ctl.qnt_ens][ip] != ens))
163 continue;
164
165 /* Check time... */
166 if (!isfinite(atm1->time[ip]) || !isfinite(atm2->time[ip]))
167 continue;
168
169 /* Check spatial range... */
170 if (atm1->p[ip] > p0 || atm1->p[ip] < p1
171 || atm1->lon[ip] < lon0 || atm1->lon[ip] > lon1
172 || atm1->lat[ip] < lat0 || atm1->lat[ip] > lat1)
173 continue;
174 if (atm2->p[ip] > p0 || atm2->p[ip] < p1
175 || atm2->lon[ip] < lon0 || atm2->lon[ip] > lon1
176 || atm2->lat[ip] < lat0 || atm2->lat[ip] > lat1)
177 continue;
178
179 /* Convert coordinates... */
180 geo2cart(0, atm1->lon[ip], atm1->lat[ip], x1);
181 geo2cart(0, atm2->lon[ip], atm2->lat[ip], x2);
182 z1 = Z(atm1->p[ip]);
183 z2 = Z(atm2->p[ip]);
184
185 /* Calculate absolute transport deviations... */
186 ahtd[np] = DIST(x1, x2);
187 avtd[np] = z1 - z2;
188 for (iq = 0; iq < ctl.nq; iq++)
189 aqtd[iq * NP + np] = atm1->q[iq][ip] - atm2->q[iq][ip];
190
191 /* Calculate relative transport deviations... */
192 if (f > 4) {
193
194 /* Get trajectory lengths... */
195 geo2cart(0, lon1_old[ip], lat1_old[ip], x0);
196 lh1[ip] += DIST(x0, x1);
197 lv1[ip] += fabs(z1_old[ip] - z1);
198
199 geo2cart(0, lon2_old[ip], lat2_old[ip], x0);
200 lh2[ip] += DIST(x0, x2);
201 lv2[ip] += fabs(z2_old[ip] - z2);
202
203 /* Get relative transport deviations... */
204 if (lh1[ip] + lh2[ip] > 0)
205 rhtd[np] = 200. * DIST(x1, x2) / (lh1[ip] + lh2[ip]);
206 if (lv1[ip] + lv2[ip] > 0)
207 rvtd[np] = 200. * (z1 - z2) / (lv1[ip] + lv2[ip]);
208 }
209
210 /* Get relative transport deviations... */
211 for (iq = 0; iq < ctl.nq; iq++)
212 rqtd[iq * NP + np] = 200. * (atm1->q[iq][ip] - atm2->q[iq][ip])
213 / (fabs(atm1->q[iq][ip]) + fabs(atm2->q[iq][ip]));
214
215 /* Save positions of air parcels... */
216 lon1_old[ip] = atm1->lon[ip];
217 lat1_old[ip] = atm1->lat[ip];
218 z1_old[ip] = z1;
219
220 lon2_old[ip] = atm2->lon[ip];
221 lat2_old[ip] = atm2->lat[ip];
222 z2_old[ip] = z2;
223
224 /* Increment air parcel counter... */
225 np++;
226 }
227
228 /* Filter data... */
229 if (zscore > 0 && np > 1) {
230
231 /* Get means and standard deviations of transport deviations... */
232 size_t n = (size_t) np;
233 double muh = gsl_stats_mean(ahtd, 1, n);
234 double muv = gsl_stats_mean(avtd, 1, n);
235 double sigh = gsl_stats_sd(ahtd, 1, n);
236 double sigv = gsl_stats_sd(avtd, 1, n);
237
238 /* Filter data... */
239 np = 0;
240 for (size_t i = 0; i < n; i++)
241 if (fabs((ahtd[i] - muh) / sigh) < zscore
242 && fabs((avtd[i] - muv) / sigv) < zscore) {
243 ahtd[np] = ahtd[i];
244 rhtd[np] = rhtd[i];
245 avtd[np] = avtd[i];
246 rvtd[np] = rvtd[i];
247 for (iq = 0; iq < ctl.nq; iq++) {
248 aqtd[iq * NP + np] = aqtd[iq * NP + (int) i];
249 rqtd[iq * NP + np] = rqtd[iq * NP + (int) i];
250 }
251 np++;
252 }
253 }
254
255 /* Get statistics... */
256 if (strcasecmp(argv[3], "mean") == 0) {
257 ahtdm = gsl_stats_mean(ahtd, 1, (size_t) np);
258 rhtdm = gsl_stats_mean(rhtd, 1, (size_t) np);
259 avtdm = gsl_stats_mean(avtd, 1, (size_t) np);
260 rvtdm = gsl_stats_mean(rvtd, 1, (size_t) np);
261 for (iq = 0; iq < ctl.nq; iq++) {
262 aqtdm[iq] = gsl_stats_mean(&aqtd[iq * NP], 1, (size_t) np);
263 rqtdm[iq] = gsl_stats_mean(&rqtd[iq * NP], 1, (size_t) np);
264 }
265 } else if (strcasecmp(argv[3], "stddev") == 0) {
266 ahtdm = gsl_stats_sd(ahtd, 1, (size_t) np);
267 rhtdm = gsl_stats_sd(rhtd, 1, (size_t) np);
268 avtdm = gsl_stats_sd(avtd, 1, (size_t) np);
269 rvtdm = gsl_stats_sd(rvtd, 1, (size_t) np);
270 for (iq = 0; iq < ctl.nq; iq++) {
271 aqtdm[iq] = gsl_stats_sd(&aqtd[iq * NP], 1, (size_t) np);
272 rqtdm[iq] = gsl_stats_sd(&rqtd[iq * NP], 1, (size_t) np);
273 }
274 } else if (strcasecmp(argv[3], "min") == 0) {
275 ahtdm = gsl_stats_min(ahtd, 1, (size_t) np);
276 rhtdm = gsl_stats_min(rhtd, 1, (size_t) np);
277 avtdm = gsl_stats_min(avtd, 1, (size_t) np);
278 rvtdm = gsl_stats_min(rvtd, 1, (size_t) np);
279 for (iq = 0; iq < ctl.nq; iq++) {
280 aqtdm[iq] = gsl_stats_min(&aqtd[iq * NP], 1, (size_t) np);
281 rqtdm[iq] = gsl_stats_min(&rqtd[iq * NP], 1, (size_t) np);
282 }
283 } else if (strcasecmp(argv[3], "max") == 0) {
284 ahtdm = gsl_stats_max(ahtd, 1, (size_t) np);
285 rhtdm = gsl_stats_max(rhtd, 1, (size_t) np);
286 avtdm = gsl_stats_max(avtd, 1, (size_t) np);
287 rvtdm = gsl_stats_max(rvtd, 1, (size_t) np);
288 for (iq = 0; iq < ctl.nq; iq++) {
289 aqtdm[iq] = gsl_stats_max(&aqtd[iq * NP], 1, (size_t) np);
290 rqtdm[iq] = gsl_stats_max(&rqtd[iq * NP], 1, (size_t) np);
291 }
292 } else if (strcasecmp(argv[3], "skew") == 0) {
293 ahtdm = gsl_stats_skew(ahtd, 1, (size_t) np);
294 rhtdm = gsl_stats_skew(rhtd, 1, (size_t) np);
295 avtdm = gsl_stats_skew(avtd, 1, (size_t) np);
296 rvtdm = gsl_stats_skew(rvtd, 1, (size_t) np);
297 for (iq = 0; iq < ctl.nq; iq++) {
298 aqtdm[iq] = gsl_stats_skew(&aqtd[iq * NP], 1, (size_t) np);
299 rqtdm[iq] = gsl_stats_skew(&rqtd[iq * NP], 1, (size_t) np);
300 }
301 } else if (strcasecmp(argv[3], "kurt") == 0) {
302 ahtdm = gsl_stats_kurtosis(ahtd, 1, (size_t) np);
303 rhtdm = gsl_stats_kurtosis(rhtd, 1, (size_t) np);
304 avtdm = gsl_stats_kurtosis(avtd, 1, (size_t) np);
305 rvtdm = gsl_stats_kurtosis(rvtd, 1, (size_t) np);
306 for (iq = 0; iq < ctl.nq; iq++) {
307 aqtdm[iq] = gsl_stats_kurtosis(&aqtd[iq * NP], 1, (size_t) np);
308 rqtdm[iq] = gsl_stats_kurtosis(&rqtd[iq * NP], 1, (size_t) np);
309 }
310 } else if (strcasecmp(argv[3], "absdev") == 0) {
311 ahtdm = gsl_stats_absdev_m(ahtd, 1, (size_t) np, 0.0);
312 rhtdm = gsl_stats_absdev_m(rhtd, 1, (size_t) np, 0.0);
313 avtdm = gsl_stats_absdev_m(avtd, 1, (size_t) np, 0.0);
314 rvtdm = gsl_stats_absdev_m(rvtd, 1, (size_t) np, 0.0);
315 for (iq = 0; iq < ctl.nq; iq++) {
316 aqtdm[iq] = gsl_stats_absdev_m(&aqtd[iq * NP], 1, (size_t) np, 0.0);
317 rqtdm[iq] = gsl_stats_absdev_m(&rqtd[iq * NP], 1, (size_t) np, 0.0);
318 }
319 } else if (strcasecmp(argv[3], "median") == 0) {
320 ahtdm = gsl_stats_median(ahtd, 1, (size_t) np);
321 rhtdm = gsl_stats_median(rhtd, 1, (size_t) np);
322 avtdm = gsl_stats_median(avtd, 1, (size_t) np);
323 rvtdm = gsl_stats_median(rvtd, 1, (size_t) np);
324 for (iq = 0; iq < ctl.nq; iq++) {
325 aqtdm[iq] = gsl_stats_median(&aqtd[iq * NP], 1, (size_t) np);
326 rqtdm[iq] = gsl_stats_median(&rqtd[iq * NP], 1, (size_t) np);
327 }
328 } else if (strcasecmp(argv[3], "mad") == 0) {
329 ahtdm = gsl_stats_mad0(ahtd, 1, (size_t) np, work);
330 rhtdm = gsl_stats_mad0(rhtd, 1, (size_t) np, work);
331 avtdm = gsl_stats_mad0(avtd, 1, (size_t) np, work);
332 rvtdm = gsl_stats_mad0(rvtd, 1, (size_t) np, work);
333 for (iq = 0; iq < ctl.nq; iq++) {
334 aqtdm[iq] = gsl_stats_mad0(&aqtd[iq * NP], 1, (size_t) np, work);
335 rqtdm[iq] = gsl_stats_mad0(&rqtd[iq * NP], 1, (size_t) np, work);
336 }
337 } else
338 ERRMSG("Unknown parameter!");
339
340 /* Write output... */
341 fprintf(out, "%.2f %.2f %g %g %g %g", t, t - t0,
342 ahtdm, rhtdm, avtdm, rvtdm);
343 for (iq = 0; iq < ctl.nq; iq++) {
344 fprintf(out, " ");
345 fprintf(out, ctl.qnt_format[iq], aqtdm[iq]);
346 fprintf(out, " ");
347 fprintf(out, ctl.qnt_format[iq], rqtdm[iq]);
348 }
349 fprintf(out, " %d\n", np);
350 }
351
352 /* Close file... */
353 fclose(out);
354
355 /* Free... */
356 free(atm1);
357 free(atm2);
358 free(lon1_old);
359 free(lat1_old);
360 free(z1_old);
361 free(lh1);
362 free(lv1);
363 free(lon2_old);
364 free(lat2_old);
365 free(z2_old);
366 free(lh2);
367 free(lv2);
368 free(ahtd);
369 free(avtd);
370 free(aqtd);
371 free(rhtd);
372 free(rvtd);
373 free(rqtd);
374 free(work);
375
376 return EXIT_SUCCESS;
377}
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:8098
time_from_filename
double time_from_filename(const char *filename, const int offset)
Extracts and converts a timestamp from a filename to Julian seconds.
Definition: mptrac.c:8413
read_ctl
void 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:4805
read_atm
int read_atm(const char *filename, const ctl_t *ctl, atm_t *atm)
Reads air parcel data from a specified file into the given atmospheric structure.
Definition: mptrac.c:4215
geo2cart
void geo2cart(const double z, const double lon, const double lat, double *x)
Converts geographic coordinates (longitude, latitude, altitude) to Cartesian coordinates.
Definition: mptrac.c:986
ERRMSG
#define ERRMSG(...)
Print an error message with contextual information and terminate the program.
Definition: mptrac.h:1901
Z
#define Z(p)
Convert pressure to altitude.
Definition: mptrac.h:1726
P
#define P(z)
Compute pressure at given altitude.
Definition: mptrac.h:1289
NQ
#define NQ
Maximum number of quantities per data point.
Definition: mptrac.h:246
ALLOC
#define ALLOC(ptr, type, n)
Allocate memory for a pointer with error handling.
Definition: mptrac.h:347
NP
#define NP
Maximum number of atmospheric data points.
Definition: mptrac.h:241
LOG
#define LOG(level,...)
Print a log message with a specified logging level.
Definition: mptrac.h:1831
DIST
#define DIST(a, b)
Calculate the distance between two points in Cartesian coordinates.
Definition: mptrac.h:572
atm_t
Air parcel data.
Definition: mptrac.h:3120
atm_t::time
double time[NP]
Time [s].
Definition: mptrac.h:3126
atm_t::lat
double lat[NP]
Latitude [deg].
Definition: mptrac.h:3135
atm_t::lon
double lon[NP]
Longitude [deg].
Definition: mptrac.h:3132
atm_t::np
int np
Number of air parcels.
Definition: mptrac.h:3123
atm_t::q
double q[NQ][NP]
Quantity data (for various, user-defined attributes).
Definition: mptrac.h:3138
atm_t::p
double p[NP]
Pressure [hPa].
Definition: mptrac.h:3129
ctl_t
Control parameters.
Definition: mptrac.h:2155
ctl_t::qnt_format
char qnt_format[NQ][LEN]
Quantity output format.
Definition: mptrac.h:2192
ctl_t::atm_type
int atm_type
Type of atmospheric data files (0=ASCII, 1=binary, 2=netCDF, 3=CLaMS_traj, 4=CLaMS_pos).
Definition: mptrac.h:2905
ctl_t::qnt_unit
char qnt_unit[NQ][LEN]
Quantity units.
Definition: mptrac.h:2189
ctl_t::qnt_name
char qnt_name[NQ][LEN]
Quantity names.
Definition: mptrac.h:2183
ctl_t::qnt_ens
int qnt_ens
Quantity array index for ensemble IDs.
Definition: mptrac.h:2198
ctl_t::qnt_idx
int qnt_idx
Quantity array index for air parcel IDs.
Definition: mptrac.h:2195
ctl_t::nq
int nq
Number of quantities.
Definition: mptrac.h:2180
Here is the call graph for this function:
Generated on Thu Nov 21 2024 13:53:30 for MPTRAC by doxygen 1.9.4