JURASSIC
Macros | Functions
invert.c File Reference

Inversion tool for MPTRAC. More...

#include "jurassic.h"
#include <gsl/gsl_fit.h>

Go to the source code of this file.

Macros

#define NLMAX   30000000
 Maximum number of data lines... More...
 
#define NMAX   1000
 Maximum number of data points... More...
 

Functions

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

Detailed Description

Inversion tool for MPTRAC.

Definition in file invert.c.

Macro Definition Documentation

◆ NLMAX

#define NLMAX   30000000

Maximum number of data lines...

Definition at line 33 of file invert.c.

◆ NMAX

#define NMAX   1000

Maximum number of data points...

Definition at line 36 of file invert.c.

Function Documentation

◆ main()

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

Definition at line 42 of file invert.c.

44 {
45
46 static ctl_t ctl;
47
48 static atm_t atm, atm2;
49
50 static obs_t obs;
51
52 static FILE *in, *out;
53
54 static char line[LEN];
55
56 static double rtime[NLMAX], rz[NLMAX], rlon[NLMAX], rlat[NLMAX], obs_meas,
57 obs_sim, scl = 1.0, scl_err, c0, c1, cov00, cov01, cov11, sumsq,
58 x[NMAX], x2[NMAX], y[NMAX], y_err[NMAX], y2[NMAX], y2_err[NMAX],
59 y2_sim[NMAX], y2_sim_err[NMAX], w2[NMAX];
60
61 static float rp[NLMAX], rt[NLMAX], rso2[NLMAX], rh2o[NLMAX],
62 ro3[NLMAX], robs[NLMAX];
63
64 static int i, ig, n, nl, ndata[NMAX], nprof;
65
66 /* Check arguments... */
67 if (argc < 6)
68 ERRMSG("Give parameters: <ctl> <prof> <inv> <atm> <kernel>");
69
70 /* Read control parameters... */
71 read_ctl(argc, argv, &ctl);
72 const double dt = scan_ctl(argc, argv, "INVERT_DT", -1, "86400", NULL);
73 const double obs_err =
74 scan_ctl(argc, argv, "INVERT_OBS_ERR", -1, "1.0", NULL);
75 const int data = (int) scan_ctl(argc, argv, "INVERT_DATA", -1, "2", NULL);
76 const int fit = (int) scan_ctl(argc, argv, "INVERT_FIT", -1, "3", NULL);
77 const int itmax =
78 (int) scan_ctl(argc, argv, "INVERT_ITMAX", -1, "10", NULL);
79 const double tol = scan_ctl(argc, argv, "INVERT_TOL", -1, "1e-4", NULL);
80
81 /* Check control parameters... */
82 if (ctl.ng != 4)
83 ERRMSG("Set NG = 4!");
84 if (strcmp(ctl.emitter[0], "SO2") != 0)
85 ERRMSG("Set EMITTER[0] = SO2!");
86 if (strcmp(ctl.emitter[1], "H2O") != 0)
87 ERRMSG("Set EMITTER[1] = H2O!");
88 if (strcmp(ctl.emitter[2], "O3") != 0)
89 ERRMSG("Set EMITTER[2] = O3!");
90 if (strcmp(ctl.emitter[3], "CO2") != 0)
91 ERRMSG("Set EMITTER[3] = CO2!");
92 if (ctl.nd != 2)
93 ERRMSG("Set ND = 2!");
94
95 /* Set control parameters... */
96 ctl.write_bbt = 1;
97 ctl.write_matrix = 1;
98
99 /* Set observation data... */
100 obs.nr = 1;
101 obs.obsz[0] = 705;
102
103 /* ------------------------------------------------------------
104 Read profiles...
105 ------------------------------------------------------------ */
106
107 /* Read profile data... */
108 LOG(1, "Read profile data: %s", argv[2]);
109
110 /* Open file... */
111 if (!(in = fopen(argv[2], "r")))
112 ERRMSG("Cannot open file!");
113
114 /* Read file... */
115 while (fgets(line, LEN, in)) {
116
117 /* Read data... */
118 if (sscanf(line, "%lg %lg %lg %lg %g %g %g %g %g %g", &rtime[nl],
119 &rz[nl], &rlon[nl], &rlat[nl], &rp[nl], &rt[nl], &rso2[nl],
120 &rh2o[nl], &ro3[nl], &robs[nl]) != 10)
121 continue;
122 if ((++nl) > NLMAX)
123 ERRMSG("Too many profile data points!");
124 }
125
126 /* Close files... */
127 fclose(in);
128
129 /* ------------------------------------------------------------
130 Fit scaling factor for total mass...
131 ------------------------------------------------------------ */
132
133 /* Iterations... */
134 for (int it = 0; it < itmax; it++) {
135
136 /* Init... */
137 atm.np = n = 0;
138 for (i = 0; i < NMAX; i++) {
139 ndata[i] = 0;
140 x[i] = y[i] = NAN;
141 }
142
143 /* Loop over lines... */
144 for (int il = 0; il < nl; il++) {
145
146 /* Check for new profile... */
147 if ((rtime[il] != atm.time[0]
148 || rlon[il] != atm.lon[0]
149 || rlat[il] != atm.lat[0])
150 && atm.np > 0) {
151
152 /* Call forward model... */
153 formod(&ctl, &atm, &obs);
154 obs_sim = obs.rad[0][0] - obs.rad[1][0];
155
156 /* Get time index... */
157 i = (int) ((atm.time[0] - rtime[0]) / dt);
158 if (i < 0 && i >= NMAX)
159 ERRMSG("Time index out of range!");
160
161 /* Get maxima... */
162 if (data == 1) {
163 x[i] = (isfinite(x[i]) ? MAX(x[i], obs_sim) : obs_sim);
164 y[i] = (isfinite(y[i]) ? MAX(y[i], obs_meas) : obs_meas);
165 y_err[i] = obs_err;
166 if (isfinite(x[i]) && isfinite(y[i]))
167 ndata[i] = 1;
168 }
169
170 /* Get means... */
171 else if (data == 2) {
172 if (ndata[i] == 0) {
173 x[i] = obs_sim;
174 y[i] = obs_meas;
175 y_err[i] = POW2(obs_meas);
176 } else {
177 x[i] += obs_sim;
178 y[i] += obs_meas;
179 y_err[i] += POW2(obs_meas);
180 }
181 ndata[i]++;
182 }
183
184 /* Calculate mean atmospheric profile... */
185 nprof++;
186 atm2.np = atm.np;
187 for (int ip = 0; ip < atm.np; ip++) {
188 atm2.time[ip] += atm.time[ip];
189 atm2.z[ip] += atm.z[ip];
190 atm2.lon[ip] += atm.lon[ip];
191 atm2.lat[ip] += atm.lat[ip];
192 atm2.p[ip] += atm.p[ip];
193 atm2.t[ip] += atm.t[ip];
194 for (ig = 1; ig < ctl.ng; ig++)
195 atm2.q[ig][ip] += atm.q[ig][ip];
196 }
197
198 /* Reset counter... */
199 atm.np = 0;
200 }
201
202 /* Save data... */
203 obs_meas = robs[il];
204 atm.time[atm.np] = rtime[il];
205 atm.z[atm.np] = rz[il];
206 atm.lon[atm.np] = rlon[il];
207 atm.lat[atm.np] = rlat[il];
208 atm.p[atm.np] = rp[il];
209 atm.t[atm.np] = rt[il];
210 atm.q[0][atm.np] = rso2[il] * scl;
211 atm.q[1][atm.np] = rh2o[il];
212 atm.q[2][atm.np] = ro3[il];
213 atm.q[3][atm.np] = 371.789948e-6 + 2.026214e-6
214 * (atm.time[atm.np] - 63158400.) / 31557600.;
215 if ((++atm.np) > NP)
216 ERRMSG("Too many data points!");
217 }
218
219 /* Calculate means... */
220 if (data == 2)
221 for (i = 0; i < NMAX; i++)
222 if (ndata[i] > 0) {
223 x[i] /= ndata[i];
224 y[i] /= ndata[i];
225 y_err[i] = sqrt(MAX(y_err[i] / ndata[i] - POW2(y[i]), 0.0))
226 / sqrt(ndata[i]); /* standard error! */
227 }
228
229 /* Filter data... */
230 n = 0;
231 for (i = 0; i < NMAX; i++)
232 if (ndata[i] > 0 && isfinite(x[i]) && isfinite(y[i])
233 && isfinite(y_err[i])) {
234 x2[n] = x[i];
235 y2[n] = y[i];
236 y2_err[n] = y_err[i];
237 w2[n] = 1. / POW2(y_err[i]);
238 n++;
239 }
240
241 /* Fit radiance data... */
242 if (fit == 1)
243 gsl_fit_mul(x2, 1, y2, 1, (size_t) n, &c1, &cov11, &sumsq);
244 else if (fit == 2)
245 gsl_fit_wmul(x2, 1, w2, 1, y2, 1, (size_t) n, &c1, &cov11, &sumsq);
246 else if (fit == 3)
247 gsl_fit_linear(x2, 1, y2, 1, (size_t) n, &c0, &c1, &cov00, &cov01,
248 &cov11, &sumsq);
249 else if (fit == 4)
250 gsl_fit_wlinear(x2, 1, w2, 1, y2, 1, (size_t) n, &c0, &c1, &cov00,
251 &cov01, &cov11, &sumsq);
252 else
253 ERRMSG("Check INVERT_FIT!");
254
255 /* Get new scaling factor... */
256 double scl_old = scl;
257 scl_err = scl * sqrt(cov11);
258 scl *= c1;
259
260 /* Write info... */
261 LOG(1, " it= %d | scl= %g +/- %g | RMSE= %g",
262 it, scl, scl_err, sqrt(sumsq / n));
263
264 /* Convergence test... */
265 if (fabs(2.0 * (scl - scl_old) / (scl + scl_old)) < tol)
266 break;
267 }
268
269 /* ------------------------------------------------------------
270 Write inversion data...
271 ------------------------------------------------------------ */
272
273 /* Write info... */
274 LOG(1, "Write inversion data: %s", argv[3]);
275
276 /* Create file... */
277 if (!(out = fopen(argv[3], "w")))
278 ERRMSG("Cannot create file!");
279
280 /* Write header... */
281 fprintf(out,
282 "# $1 = time (seconds since 2000-01-01T00:00Z)\n"
283 "# $2 = simulated SO2 index [K]\n"
284 "# $3 = scaled simulated SO2 index [K]\n"
285 "# $4 = error of scaled simulated SO2 index [K]\n"
286 "# $5 = observed SO2 index [K]\n"
287 "# $6 = error of observed SO2 index [K]\n\n");
288
289 /* Write data... */
290 for (i = 0; i < n; i++) {
291
292 /* Calculate scaled SO2 index... */
293 if (fit == 1 || fit == 2)
294 gsl_fit_mul_est(x2[i], c1, cov11, &y2_sim[i], &y2_sim_err[i]);
295 else if (fit == 3 || fit == 4)
296 gsl_fit_linear_est(x2[i], c0, c1, cov00, cov01, cov11, &y2_sim[i],
297 &y2_sim_err[i]);
298
299 /* Write output... */
300 fprintf(out, "%.2f %g %g %g %g %g\n", rtime[0] + (i + 0.5) * dt,
301 x2[i], y2_sim[i], y2_sim_err[i], y2[i], y2_err[i]);
302 }
303
304 /* Report scaling factor for total mass... */
305 fprintf(out, "\n");
306 fprintf(out, "# scl= %g +/- %g\n", scl, scl_err);
307 fprintf(out, "# c1= %g +/- %g\n", c1, sqrt(cov11));
308 if (fit == 3 || fit == 4) {
309 fprintf(out, "# c0= %g +/- %g\n", c0, sqrt(cov00));
310 fprintf(out, "# corr= %g\n", cov01 / (sqrt(cov00) * sqrt(cov11)));
311 }
312 fprintf(out, "# RMSE= %g\n", sqrt(sumsq / n));
313 fprintf(out, "# n= %d\n", n);
314
315 /* Close files... */
316 fclose(out);
317
318 /* ------------------------------------------------------------
319 Calculate kernel...
320 ------------------------------------------------------------ */
321
322 /* Set atmospheric data... */
323 for (int ip = 0; ip < atm2.np; ip++) {
324 atm2.time[ip] /= nprof;
325 atm2.z[ip] /= nprof;
326 atm2.lon[ip] /= nprof;
327 atm2.lat[ip] /= nprof;
328 atm2.p[ip] /= nprof;
329 atm2.t[ip] /= nprof;
330 for (ig = 0; ig < ctl.ng; ig++)
331 atm2.q[ig][ip] /= nprof;
332 }
333
334 /* Get sizes... */
335 const size_t nk = atm2x(&ctl, &atm2, NULL, NULL, NULL);
336 const size_t mk = obs2y(&ctl, &obs, NULL, NULL, NULL);
337
338 /* Allocate... */
339 gsl_matrix *k = gsl_matrix_alloc(mk, nk);
340
341 /* Compute kernel matrix... */
342 kernel(&ctl, &atm2, &obs, k);
343
344 /* Write atmospheric data... */
345 write_atm(NULL, argv[4], &ctl, &atm);
346
347 /* Write matrix to file... */
348 write_matrix(NULL, argv[5], &ctl, k, &atm2, &obs, "y", "x", "r");
349
350 /* Free... */
351 gsl_matrix_free(k);
352
353 return EXIT_SUCCESS;
354}
NMAX
#define NMAX
Maximum number of data points...
Definition: invert.c:36
NLMAX
#define NLMAX
Maximum number of data lines...
Definition: invert.c:33
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:5336
read_ctl
void read_ctl(int argc, char *argv[], ctl_t *ctl)
Read forward model control parameters.
Definition: jurassic.c:4547
formod
void formod(const ctl_t *ctl, atm_t *atm, obs_t *obs)
Determine ray paths and compute radiative transfer.
Definition: jurassic.c:3026
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:5114
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:4174
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
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:5492
kernel
void kernel(ctl_t *ctl, atm_t *atm, obs_t *obs, gsl_matrix *k)
Compute Jacobians.
Definition: jurassic.c:4004
LEN
#define LEN
Maximum length of ASCII data lines.
Definition: jurassic.h:383
POW2
#define POW2(x)
Compute x^2.
Definition: jurassic.h:187
ERRMSG
#define ERRMSG(...)
Print error message and quit program.
Definition: jurassic.h:237
NP
#define NP
Maximum number of atmospheric data points.
Definition: jurassic.h:363
LOG
#define LOG(level,...)
Print log message.
Definition: jurassic.h:221
MAX
#define MAX(a, b)
Macro to determine the maximum of two values.
Definition: jurassic.h:156
atm_t
Atmospheric data.
Definition: jurassic.h:488
atm_t::time
double time[NP]
Time (seconds since 2000-01-01T00:00Z).
Definition: jurassic.h:494
atm_t::lat
double lat[NP]
Latitude [deg].
Definition: jurassic.h:503
atm_t::lon
double lon[NP]
Longitude [deg].
Definition: jurassic.h:500
atm_t::t
double t[NP]
Temperature [K].
Definition: jurassic.h:509
atm_t::np
int np
Number of data points.
Definition: jurassic.h:491
atm_t::z
double z[NP]
Altitude [km].
Definition: jurassic.h:497
atm_t::q
double q[NG][NP]
Volume mixing ratio [ppv].
Definition: jurassic.h:512
atm_t::p
double p[NP]
Pressure [hPa].
Definition: jurassic.h:506
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::ng
int ng
Number of emitters.
Definition: jurassic.h:544
ctl_t::nd
int nd
Number of radiance channels.
Definition: jurassic.h:550
ctl_t::emitter
char emitter[NG][LEN]
Name of each emitter.
Definition: jurassic.h:547
ctl_t::write_bbt
int write_bbt
Use brightness temperature instead of radiance (0=no, 1=yes).
Definition: jurassic.h:658
obs_t
Observation geometry and radiance data.
Definition: jurassic.h:734
obs_t::rad
double rad[ND][NR]
Radiance [W/(m^2 sr cm^-1)].
Definition: jurassic.h:773
obs_t::obsz
double obsz[NR]
Observer altitude [km].
Definition: jurassic.h:743
obs_t::nr
int nr
Number of ray paths.
Definition: jurassic.h:737
Here is the call graph for this function:
Generated on Wed Feb 5 2025 15:21:43 for JURASSIC by doxygen 1.9.4