jurassic.c

Go to the documentation of this file.

/*
  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-2026 Forschungszentrum Juelich GmbH
*/
 
#include "jurassic.h"
#include <dirent.h>
#include <sys/wait.h>
 
/*****************************************************************************/
 
void analyze_avk(
  const ret_t *ret,
  const ctl_t *ctl,
  const atm_t *atm,
  const int *iqa,
  const int *ipa,
  const gsl_matrix *avk) {
 
  /* Allocate... */
  atm_t *atm_cont, *atm_res;
  ALLOC(atm_cont, atm_t, 1);
  ALLOC(atm_res, atm_t, 1);
 
  /* Get sizes... */
  const size_t n = avk->size1;
 
  /* Find sub-matrices for different quantities... */
  size_t n0[NQ], n1[NQ];
  for (int iq = 0; iq < NQ; iq++) {
    n0[iq] = N;
    for (size_t i = 0; i < n; i++) {
      if (iqa[i] == iq && n0[iq] == N)
        n0[iq] = i;
      if (iqa[i] == iq)
        n1[iq] = i - n0[iq] + 1;
    }
  }
 
  /* Initialize... */
  copy_atm(ctl, atm_cont, atm, 1);
  copy_atm(ctl, atm_res, atm, 1);
 
  /* Analyze quantities... */
  analyze_avk_quantity(avk, IDXP, ipa, n0, n1, atm_cont->p, atm_res->p);
  analyze_avk_quantity(avk, IDXT, ipa, n0, n1, atm_cont->t, atm_res->t);
  for (int ig = 0; ig < ctl->ng; ig++)
    analyze_avk_quantity(avk, IDXQ(ig), ipa, n0, n1,
                         atm_cont->q[ig], atm_res->q[ig]);
  for (int iw = 0; iw < ctl->nw; iw++)
    analyze_avk_quantity(avk, IDXK(iw), ipa, n0, n1,
                         atm_cont->k[iw], atm_res->k[iw]);
  analyze_avk_quantity(avk, IDXCLZ, ipa, n0, n1, &atm_cont->clz,
                       &atm_res->clz);
  analyze_avk_quantity(avk, IDXCLDZ, ipa, n0, n1, &atm_cont->cldz,
                       &atm_res->cldz);
  for (int icl = 0; icl < ctl->ncl; icl++)
    analyze_avk_quantity(avk, IDXCLK(icl), ipa, n0, n1,
                         &atm_cont->clk[icl], &atm_res->clk[icl]);
  analyze_avk_quantity(avk, IDXSFT, ipa, n0, n1, &atm_cont->sft,
                       &atm_res->sft);
  for (int isf = 0; isf < ctl->nsf; isf++)
    analyze_avk_quantity(avk, IDXSFEPS(isf), ipa, n0, n1,
                         &atm_cont->sfeps[isf], &atm_res->sfeps[isf]);
 
  /* Write results to disk... */
  const char *dirname;
  int profile;
  const char *filename =
    shared_io_output_target(ret, ret->shared_io_atm_cont_file, "atm_cont.tab",
                            &dirname, &profile);
  write_atm(dirname, filename, ctl, atm_cont, profile);
  filename = shared_io_output_target(ret, ret->shared_io_atm_res_file,
                                     "atm_res.tab", &dirname, &profile);
  write_atm(dirname, filename, ctl, atm_res, profile);
 
  /* Free... */
  free(atm_cont);
  free(atm_res);
}
 
/*****************************************************************************/
 
void analyze_avk_quantity(
  const gsl_matrix *avk,
  const int iq,
  const int *ipa,
  const size_t *n0,
  const size_t *n1,
  double *cont,
  double *res) {
 
  /* Loop over state vector elements... */
  if (n0[iq] < N)
    for (size_t i = 0; i < n1[iq]; i++) {
 
      /* Get area of averaging kernel... */
      for (size_t j = 0; j < n1[iq]; j++)
        cont[ipa[n0[iq] + i]] += gsl_matrix_get(avk, n0[iq] + i, n0[iq] + j);
 
      /* Get information density... */
      res[ipa[n0[iq] + i]] = 1 / gsl_matrix_get(avk, n0[iq] + i, n0[iq] + i);
    }
}
 
/*****************************************************************************/
 
size_t atm2x(
  const ctl_t *ctl,
  const atm_t *atm,
  gsl_vector *x,
  int *iqa,
  int *ipa) {
 
  size_t n = 0;
 
  /* Add pressure... */
  for (int ip = 0; ip < atm->np; ip++)
    if (atm->z[ip] >= ctl->retp_zmin && atm->z[ip] <= ctl->retp_zmax)
      atm2x_help(atm->p[ip], IDXP, ip, x, iqa, ipa, &n);
 
  /* Add temperature... */
  for (int ip = 0; ip < atm->np; ip++)
    if (atm->z[ip] >= ctl->rett_zmin && atm->z[ip] <= ctl->rett_zmax)
      atm2x_help(atm->t[ip], IDXT, ip, x, iqa, ipa, &n);
 
  /* Add volume mixing ratios... */
  for (int ig = 0; ig < ctl->ng; ig++)
    for (int ip = 0; ip < atm->np; ip++)
      if (atm->z[ip] >= ctl->retq_zmin[ig]
          && atm->z[ip] <= ctl->retq_zmax[ig])
        atm2x_help(atm->q[ig][ip], IDXQ(ig), ip, x, iqa, ipa, &n);
 
  /* Add extinction... */
  for (int iw = 0; iw < ctl->nw; iw++)
    for (int ip = 0; ip < atm->np; ip++)
      if (atm->z[ip] >= ctl->retk_zmin[iw]
          && atm->z[ip] <= ctl->retk_zmax[iw])
        atm2x_help(atm->k[iw][ip], IDXK(iw), ip, x, iqa, ipa, &n);
 
  /* Add cloud variables... */
  if (ctl->ret_clz)
    atm2x_help(atm->clz, IDXCLZ, 0, x, iqa, ipa, &n);
  if (ctl->ret_cldz)
    atm2x_help(atm->cldz, IDXCLDZ, 0, x, iqa, ipa, &n);
  if (ctl->ret_clk)
    for (int icl = 0; icl < ctl->ncl; icl++)
      atm2x_help(atm->clk[icl], IDXCLK(icl), 0, x, iqa, ipa, &n);
 
  /* Add surface variables... */
  if (ctl->ret_sft)
    atm2x_help(atm->sft, IDXSFT, 0, x, iqa, ipa, &n);
  if (ctl->ret_sfeps)
    for (int isf = 0; isf < ctl->nsf; isf++)
      atm2x_help(atm->sfeps[isf], IDXSFEPS(isf), 0, x, iqa, ipa, &n);
 
  return n;
}
 
/*****************************************************************************/
 
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... */
  if (x != NULL)
    gsl_vector_set(x, *n, value);
  if (iqa != NULL)
    iqa[*n] = value_iqa;
  if (ipa != NULL)
    ipa[*n] = value_ip;
  (*n)++;
}
 
/*****************************************************************************/
 
void cart2geo(
  const double *x,
  double *z,
  double *lon,
  double *lat) {
 
  const double radius = NORM(x);
 
  *lat = RAD2DEG(asin(x[2] / radius));
  *lon = RAD2DEG(atan2(x[1], x[0]));
  *z = radius - RE;
}
 
/*****************************************************************************/
 
void climatology(
  const ctl_t *ctl,
  const clim_t *clim,
  atm_t *atm) {
 
  static const double z[121] = {
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
    20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
    38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
    56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
    74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
    92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
    108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120
  };
 
  static const double pre[121] = {
    1017, 901.083, 796.45, 702.227, 617.614, 541.644, 473.437, 412.288,
    357.603, 308.96, 265.994, 228.348, 195.619, 167.351, 143.039, 122.198,
    104.369, 89.141, 76.1528, 65.0804, 55.641, 47.591, 40.7233, 34.8637,
    29.8633, 25.5956, 21.9534, 18.8445, 16.1909, 13.9258, 11.9913,
    10.34, 8.92988, 7.72454, 6.6924, 5.80701, 5.04654, 4.39238, 3.82902,
    3.34337, 2.92413, 2.56128, 2.2464, 1.97258, 1.73384, 1.52519, 1.34242,
    1.18197, 1.04086, 0.916546, 0.806832, 0.709875, 0.624101, 0.548176,
    0.480974, 0.421507, 0.368904, 0.322408, 0.281386, 0.245249, 0.213465,
    0.185549, 0.161072, 0.139644, 0.120913, 0.104568, 0.0903249, 0.0779269,
    0.0671493, 0.0577962, 0.0496902, 0.0426736, 0.0366093, 0.0313743,
    0.0268598, 0.0229699, 0.0196206, 0.0167399, 0.0142646, 0.0121397,
    0.0103181, 0.00875775, 0.00742226, 0.00628076, 0.00530519, 0.00447183,
    0.00376124, 0.00315632, 0.00264248, 0.00220738, 0.00184003, 0.00153095,
    0.00127204, 0.00105608, 0.000876652, 0.00072798, 0.00060492,
    0.000503201, 0.000419226, 0.000349896, 0.000292659, 0.000245421,
    0.000206394, 0.000174125, 0.000147441, 0.000125333, 0.000106985,
    9.173e-05, 7.90172e-05, 6.84172e-05, 5.95574e-05, 5.21183e-05,
    4.58348e-05, 4.05127e-05, 3.59987e-05, 3.21583e-05, 2.88718e-05,
    2.60322e-05, 2.35687e-05, 2.14263e-05, 1.95489e-05
  };
 
  static const double tem[121] = {
    285.14, 279.34, 273.91, 268.3, 263.24, 256.55, 250.2, 242.82, 236.17,
    229.87, 225.04, 221.19, 218.85, 217.19, 216.2, 215.68, 215.42, 215.55,
    215.92, 216.4, 216.93, 217.45, 218, 218.68, 219.39, 220.25, 221.3,
    222.41, 223.88, 225.42, 227.2, 229.52, 231.89, 234.51, 236.85, 239.42,
    241.94, 244.57, 247.36, 250.32, 253.34, 255.82, 258.27, 260.39,
    262.03, 263.45, 264.2, 264.78, 264.67, 264.38, 263.24, 262.03, 260.02,
    258.09, 255.63, 253.28, 250.43, 247.81, 245.26, 242.77, 240.38,
    237.94, 235.79, 233.53, 231.5, 229.53, 227.6, 225.62, 223.77, 222.06,
    220.33, 218.69, 217.18, 215.64, 214.13, 212.52, 210.86, 209.25,
    207.49, 205.81, 204.11, 202.22, 200.32, 198.39, 195.92, 193.46,
    190.94, 188.31, 185.82, 183.57, 181.43, 179.74, 178.64, 178.1, 178.25,
    178.7, 179.41, 180.67, 182.31, 184.18, 186.6, 189.53, 192.66, 196.54,
    201.13, 205.93, 211.73, 217.86, 225, 233.53, 242.57, 252.14, 261.48,
    272.97, 285.26, 299.12, 312.2, 324.17, 338.34, 352.56, 365.28
  };
 
  static const double c2h2[121] = {
    1.352e-09, 2.83e-10, 1.269e-10, 6.926e-11, 4.346e-11, 2.909e-11,
    2.014e-11, 1.363e-11, 8.71e-12, 5.237e-12, 2.718e-12, 1.375e-12,
    5.786e-13, 2.16e-13, 7.317e-14, 2.551e-14, 1.055e-14, 4.758e-15,
    2.056e-15, 7.703e-16, 2.82e-16, 1.035e-16, 4.382e-17, 1.946e-17,
    9.638e-18, 5.2e-18, 2.811e-18, 1.494e-18, 7.925e-19, 4.213e-19,
    1.998e-19, 8.78e-20, 3.877e-20, 1.728e-20, 7.743e-21, 3.536e-21,
    1.623e-21, 7.508e-22, 3.508e-22, 1.65e-22, 7.837e-23, 3.733e-23,
    1.808e-23, 8.77e-24, 4.285e-24, 2.095e-24, 1.032e-24, 5.082e-25,
    2.506e-25, 1.236e-25, 6.088e-26, 2.996e-26, 1.465e-26, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  };
 
  static const double c2h6[121] = {
    2.667e-09, 2.02e-09, 1.658e-09, 1.404e-09, 1.234e-09, 1.109e-09,
    1.012e-09, 9.262e-10, 8.472e-10, 7.71e-10, 6.932e-10, 6.216e-10,
    5.503e-10, 4.87e-10, 4.342e-10, 3.861e-10, 3.347e-10, 2.772e-10,
    2.209e-10, 1.672e-10, 1.197e-10, 8.536e-11, 5.783e-11, 3.846e-11,
    2.495e-11, 1.592e-11, 1.017e-11, 6.327e-12, 3.895e-12, 2.403e-12,
    1.416e-12, 8.101e-13, 4.649e-13, 2.686e-13, 1.557e-13, 9.14e-14,
    5.386e-14, 3.19e-14, 1.903e-14, 1.14e-14, 6.875e-15, 4.154e-15,
    2.538e-15, 1.553e-15, 9.548e-16, 5.872e-16, 3.63e-16, 2.244e-16,
    1.388e-16, 8.587e-17, 5.308e-17, 3.279e-17, 2.017e-17, 1.238e-17,
    7.542e-18, 4.585e-18, 2.776e-18, 1.671e-18, 9.985e-19, 5.937e-19,
    3.518e-19, 2.07e-19, 1.215e-19, 7.06e-20, 4.097e-20, 2.37e-20,
    1.363e-20, 7.802e-21, 4.441e-21, 2.523e-21, 1.424e-21, 8.015e-22,
    4.497e-22, 2.505e-22, 1.391e-22, 7.691e-23, 4.238e-23, 2.331e-23,
    1.274e-23, 6.929e-24, 3.752e-24, 2.02e-24, 1.083e-24, 5.774e-25,
    3.041e-25, 1.593e-25, 8.308e-26, 4.299e-26, 2.195e-26, 1.112e-26,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0
  };
 
  static const double ccl4[121] = {
    1.075e-10, 1.075e-10, 1.075e-10, 1.075e-10, 1.075e-10, 1.075e-10,
    1.075e-10, 1.075e-10, 1.075e-10, 1.06e-10, 1.024e-10, 9.69e-11,
    8.93e-11, 8.078e-11, 7.213e-11, 6.307e-11, 5.383e-11, 4.49e-11,
    3.609e-11, 2.705e-11, 1.935e-11, 1.385e-11, 8.35e-12, 5.485e-12,
    3.853e-12, 2.22e-12, 5.875e-13, 3.445e-13, 1.015e-13, 6.075e-14,
    4.383e-14, 2.692e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14, 1e-14,
    1e-14, 1e-14, 1e-14
  };
 
  static const double ch3oh[121] = {
    5.01099e-10, 5.01099e-10, 5.01099e-10, 5.01099e-10, 5.01099e-10,
    5.01099e-10, 5.50999e-10, 5.7313e-10, 5.75638e-10, 5.4086e-10,
    4.77601e-10, 4.12907e-10, 3.6274e-10, 3.26448e-10, 2.9706e-10,
    2.27698e-10, 1.96999e-10, 1.66212e-10, 1.17941e-10, 1.19844e-10,
    1.11211e-10, 1.02714e-10, 9.86138e-11, 9.45133e-11, 9.04127e-11,
    8.05243e-11, 6.3678e-11, 4.68317e-11, 4.00618e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11, 3.95786e-11,
    3.95786e-11
  };
 
  static const double ch4[121] = {
    1.864e-06, 1.835e-06, 1.819e-06, 1.805e-06, 1.796e-06, 1.788e-06,
    1.782e-06, 1.776e-06, 1.769e-06, 1.761e-06, 1.749e-06, 1.734e-06,
    1.716e-06, 1.692e-06, 1.654e-06, 1.61e-06, 1.567e-06, 1.502e-06,
    1.433e-06, 1.371e-06, 1.323e-06, 1.277e-06, 1.232e-06, 1.188e-06,
    1.147e-06, 1.108e-06, 1.07e-06, 1.027e-06, 9.854e-07, 9.416e-07,
    8.933e-07, 8.478e-07, 7.988e-07, 7.515e-07, 7.07e-07, 6.64e-07,
    6.239e-07, 5.864e-07, 5.512e-07, 5.184e-07, 4.87e-07, 4.571e-07,
    4.296e-07, 4.04e-07, 3.802e-07, 3.578e-07, 3.383e-07, 3.203e-07,
    3.032e-07, 2.889e-07, 2.76e-07, 2.635e-07, 2.519e-07, 2.409e-07,
    2.302e-07, 2.219e-07, 2.144e-07, 2.071e-07, 1.999e-07, 1.93e-07,
    1.862e-07, 1.795e-07, 1.731e-07, 1.668e-07, 1.607e-07, 1.548e-07,
    1.49e-07, 1.434e-07, 1.38e-07, 1.328e-07, 1.277e-07, 1.227e-07,
    1.18e-07, 1.134e-07, 1.089e-07, 1.046e-07, 1.004e-07, 9.635e-08,
    9.245e-08, 8.867e-08, 8.502e-08, 8.15e-08, 7.809e-08, 7.48e-08,
    7.159e-08, 6.849e-08, 6.55e-08, 6.262e-08, 5.98e-08, 5.708e-08,
    5.448e-08, 5.194e-08, 4.951e-08, 4.72e-08, 4.5e-08, 4.291e-08,
    4.093e-08, 3.905e-08, 3.729e-08, 3.563e-08, 3.408e-08, 3.265e-08,
    3.128e-08, 2.996e-08, 2.87e-08, 2.76e-08, 2.657e-08, 2.558e-08,
    2.467e-08, 2.385e-08, 2.307e-08, 2.234e-08, 2.168e-08, 2.108e-08,
    2.05e-08, 1.998e-08, 1.947e-08, 1.902e-08, 1.86e-08, 1.819e-08,
    1.782e-08
  };
 
  static const double clo[121] = {
    7.419e-15, 1.061e-14, 1.518e-14, 2.195e-14, 3.175e-14, 4.666e-14,
    6.872e-14, 1.03e-13, 1.553e-13, 2.375e-13, 3.664e-13, 5.684e-13,
    8.915e-13, 1.402e-12, 2.269e-12, 4.125e-12, 7.501e-12, 1.257e-11,
    2.048e-11, 3.338e-11, 5.44e-11, 8.846e-11, 1.008e-10, 1.082e-10,
    1.157e-10, 1.232e-10, 1.312e-10, 1.539e-10, 1.822e-10, 2.118e-10,
    2.387e-10, 2.687e-10, 2.875e-10, 3.031e-10, 3.23e-10, 3.648e-10,
    4.117e-10, 4.477e-10, 4.633e-10, 4.794e-10, 4.95e-10, 5.104e-10,
    5.259e-10, 5.062e-10, 4.742e-10, 4.443e-10, 4.051e-10, 3.659e-10,
    3.305e-10, 2.911e-10, 2.54e-10, 2.215e-10, 1.927e-10, 1.675e-10,
    1.452e-10, 1.259e-10, 1.09e-10, 9.416e-11, 8.119e-11, 6.991e-11,
    6.015e-11, 5.163e-11, 4.43e-11, 3.789e-11, 3.24e-11, 2.769e-11,
    2.361e-11, 2.011e-11, 1.71e-11, 1.453e-11, 1.233e-11, 1.045e-11,
    8.851e-12, 7.48e-12, 6.316e-12, 5.326e-12, 4.487e-12, 3.778e-12,
    3.176e-12, 2.665e-12, 2.234e-12, 1.87e-12, 1.563e-12, 1.304e-12,
    1.085e-12, 9.007e-13, 7.468e-13, 6.179e-13, 5.092e-13, 4.188e-13,
    3.442e-13, 2.816e-13, 2.304e-13, 1.885e-13, 1.542e-13, 1.263e-13,
    1.035e-13, 8.5e-14, 7.004e-14, 5.783e-14, 4.795e-14, 4.007e-14,
    3.345e-14, 2.792e-14, 2.33e-14, 1.978e-14, 1.686e-14, 1.438e-14,
    1.234e-14, 1.07e-14, 9.312e-15, 8.131e-15, 7.164e-15, 6.367e-15,
    5.67e-15, 5.088e-15, 4.565e-15, 4.138e-15, 3.769e-15, 3.432e-15,
    3.148e-15
  };
 
  static const double clono2[121] = {
    1.011e-13, 1.515e-13, 2.272e-13, 3.446e-13, 5.231e-13, 8.085e-13,
    1.253e-12, 1.979e-12, 3.149e-12, 5.092e-12, 8.312e-12, 1.366e-11,
    2.272e-11, 3.791e-11, 6.209e-11, 9.101e-11, 1.334e-10, 1.951e-10,
    2.853e-10, 3.94e-10, 4.771e-10, 5.771e-10, 6.675e-10, 7.665e-10,
    8.504e-10, 8.924e-10, 9.363e-10, 8.923e-10, 8.411e-10, 7.646e-10,
    6.525e-10, 5.576e-10, 4.398e-10, 3.403e-10, 2.612e-10, 1.915e-10,
    1.407e-10, 1.028e-10, 7.455e-11, 5.42e-11, 3.708e-11, 2.438e-11,
    1.618e-11, 1.075e-11, 7.17e-12, 4.784e-12, 3.205e-12, 2.147e-12,
    1.44e-12, 9.654e-13, 6.469e-13, 4.332e-13, 2.891e-13, 1.926e-13,
    1.274e-13, 8.422e-14, 5.547e-14, 3.636e-14, 2.368e-14, 1.536e-14,
    9.937e-15, 6.39e-15, 4.101e-15, 2.61e-15, 1.659e-15, 1.052e-15,
    6.638e-16, 4.172e-16, 2.61e-16, 1.63e-16, 1.013e-16, 6.275e-17,
    3.879e-17, 2.383e-17, 1.461e-17, 8.918e-18, 5.43e-18, 3.301e-18,
    1.997e-18, 1.203e-18, 7.216e-19, 4.311e-19, 2.564e-19, 1.519e-19,
    8.911e-20, 5.203e-20, 3.026e-20, 1.748e-20, 9.99e-21, 5.673e-21,
    3.215e-21, 1.799e-21, 1.006e-21, 5.628e-22, 3.146e-22, 1.766e-22,
    9.94e-23, 5.614e-23, 3.206e-23, 1.841e-23, 1.071e-23, 6.366e-24,
    3.776e-24, 2.238e-24, 1.326e-24, 8.253e-25, 5.201e-25, 3.279e-25,
    2.108e-25, 1.395e-25, 9.326e-26, 6.299e-26, 4.365e-26, 3.104e-26,
    2.219e-26, 1.621e-26, 1.185e-26, 8.92e-27, 6.804e-27, 5.191e-27,
    4.041e-27
  };
 
  static const double co[121] = {
    1.907e-07, 1.553e-07, 1.362e-07, 1.216e-07, 1.114e-07, 1.036e-07,
    9.737e-08, 9.152e-08, 8.559e-08, 7.966e-08, 7.277e-08, 6.615e-08,
    5.884e-08, 5.22e-08, 4.699e-08, 4.284e-08, 3.776e-08, 3.274e-08,
    2.845e-08, 2.479e-08, 2.246e-08, 2.054e-08, 1.991e-08, 1.951e-08,
    1.94e-08, 2.009e-08, 2.1e-08, 2.201e-08, 2.322e-08, 2.45e-08,
    2.602e-08, 2.73e-08, 2.867e-08, 2.998e-08, 3.135e-08, 3.255e-08,
    3.352e-08, 3.426e-08, 3.484e-08, 3.53e-08, 3.593e-08, 3.671e-08,
    3.759e-08, 3.945e-08, 4.192e-08, 4.49e-08, 5.03e-08, 5.703e-08,
    6.538e-08, 7.878e-08, 9.644e-08, 1.196e-07, 1.498e-07, 1.904e-07,
    2.422e-07, 3.055e-07, 3.804e-07, 4.747e-07, 5.899e-07, 7.272e-07,
    8.91e-07, 1.071e-06, 1.296e-06, 1.546e-06, 1.823e-06, 2.135e-06,
    2.44e-06, 2.714e-06, 2.967e-06, 3.189e-06, 3.391e-06, 3.58e-06,
    3.773e-06, 4.022e-06, 4.346e-06, 4.749e-06, 5.199e-06, 5.668e-06,
    6.157e-06, 6.688e-06, 7.254e-06, 7.867e-06, 8.539e-06, 9.26e-06,
    1.009e-05, 1.119e-05, 1.228e-05, 1.365e-05, 1.506e-05, 1.641e-05,
    1.784e-05, 1.952e-05, 2.132e-05, 2.323e-05, 2.531e-05, 2.754e-05,
    3.047e-05, 3.459e-05, 3.922e-05, 4.439e-05, 4.825e-05, 5.077e-05,
    5.34e-05, 5.618e-05, 5.909e-05, 6.207e-05, 6.519e-05, 6.845e-05,
    6.819e-05, 6.726e-05, 6.622e-05, 6.512e-05, 6.671e-05, 6.862e-05,
    7.048e-05, 7.264e-05, 7.3e-05, 7.3e-05, 7.3e-05, 7.3e-05, 7.3e-05
  };
 
  static const double cof2[121] = {
    7.5e-14, 1.055e-13, 1.485e-13, 2.111e-13, 3.001e-13, 4.333e-13,
    6.269e-13, 9.221e-13, 1.364e-12, 2.046e-12, 3.093e-12, 4.703e-12,
    7.225e-12, 1.113e-11, 1.66e-11, 2.088e-11, 2.626e-11, 3.433e-11,
    4.549e-11, 5.886e-11, 7.21e-11, 8.824e-11, 1.015e-10, 1.155e-10,
    1.288e-10, 1.388e-10, 1.497e-10, 1.554e-10, 1.606e-10, 1.639e-10,
    1.64e-10, 1.64e-10, 1.596e-10, 1.542e-10, 1.482e-10, 1.382e-10,
    1.289e-10, 1.198e-10, 1.109e-10, 1.026e-10, 9.484e-11, 8.75e-11,
    8.086e-11, 7.49e-11, 6.948e-11, 6.446e-11, 5.961e-11, 5.505e-11,
    5.085e-11, 4.586e-11, 4.1e-11, 3.665e-11, 3.235e-11, 2.842e-11,
    2.491e-11, 2.11e-11, 1.769e-11, 1.479e-11, 1.197e-11, 9.631e-12,
    7.74e-12, 6.201e-12, 4.963e-12, 3.956e-12, 3.151e-12, 2.507e-12,
    1.99e-12, 1.576e-12, 1.245e-12, 9.83e-13, 7.742e-13, 6.088e-13,
    4.782e-13, 3.745e-13, 2.929e-13, 2.286e-13, 1.782e-13, 1.388e-13,
    1.079e-13, 8.362e-14, 6.471e-14, 4.996e-14, 3.85e-14, 2.96e-14,
    2.265e-14, 1.729e-14, 1.317e-14, 9.998e-15, 7.549e-15, 5.683e-15,
    4.273e-15, 3.193e-15, 2.385e-15, 1.782e-15, 1.331e-15, 9.957e-16,
    7.461e-16, 5.601e-16, 4.228e-16, 3.201e-16, 2.438e-16, 1.878e-16,
    1.445e-16, 1.111e-16, 8.544e-17, 6.734e-17, 5.341e-17, 4.237e-17,
    3.394e-17, 2.759e-17, 2.254e-17, 1.851e-17, 1.54e-17, 1.297e-17,
    1.096e-17, 9.365e-18, 8e-18, 6.938e-18, 6.056e-18, 5.287e-18,
    4.662e-18
  };
 
  static const double f11[121] = {
    2.65e-10, 2.65e-10, 2.65e-10, 2.65e-10, 2.65e-10, 2.65e-10, 2.65e-10,
    2.65e-10, 2.65e-10, 2.65e-10, 2.65e-10, 2.65e-10, 2.635e-10, 2.536e-10,
    2.44e-10, 2.348e-10, 2.258e-10, 2.153e-10, 2.046e-10, 1.929e-10,
    1.782e-10, 1.648e-10, 1.463e-10, 1.291e-10, 1.1e-10, 8.874e-11,
    7.165e-11, 5.201e-11, 3.744e-11, 2.577e-11, 1.64e-11, 1.048e-11,
    5.993e-12, 3.345e-12, 1.839e-12, 9.264e-13, 4.688e-13, 2.329e-13,
    1.129e-13, 5.505e-14, 2.825e-14, 1.492e-14, 7.997e-15, 5.384e-15,
    3.988e-15, 2.955e-15, 2.196e-15, 1.632e-15, 1.214e-15, 9.025e-16,
    6.708e-16, 4.984e-16, 3.693e-16, 2.733e-16, 2.013e-16, 1.481e-16,
    1.087e-16, 7.945e-17, 5.782e-17, 4.195e-17, 3.038e-17, 2.19e-17,
    1.577e-17, 1.128e-17, 8.063e-18, 5.753e-18, 4.09e-18, 2.899e-18,
    2.048e-18, 1.444e-18, 1.015e-18, 7.12e-19, 4.985e-19, 3.474e-19,
    2.417e-19, 1.677e-19, 1.161e-19, 8.029e-20, 5.533e-20, 3.799e-20,
    2.602e-20, 1.776e-20, 1.209e-20, 8.202e-21, 5.522e-21, 3.707e-21,
    2.48e-21, 1.652e-21, 1.091e-21, 7.174e-22, 4.709e-22, 3.063e-22,
    1.991e-22, 1.294e-22, 8.412e-23, 5.483e-23, 3.581e-23, 2.345e-23,
    1.548e-23, 1.027e-23, 6.869e-24, 4.673e-24, 3.173e-24, 2.153e-24,
    1.461e-24, 1.028e-24, 7.302e-25, 5.188e-25, 3.739e-25, 2.753e-25,
    2.043e-25, 1.528e-25, 1.164e-25, 9.041e-26, 7.051e-26, 5.587e-26,
    4.428e-26, 3.588e-26, 2.936e-26, 2.402e-26, 1.995e-26
  };
 
  static const double f113[121] = {
    1.9e-11, 1.9e-11, 1.899e-11, 1.899e-11, 1.898e-11, 1.898e-11,
    1.897e-11, 1.896e-11, 1.895e-11, 1.894e-11, 1.893e-11, 1.89e-11,
    1.887e-11, 1.871e-11, 1.854e-11, 1.803e-11, 1.751e-11, 1.664e-11,
    1.576e-11, 1.466e-11, 1.356e-11, 1.236e-11, 1.116e-11, 9.931e-12,
    8.702e-12, 7.515e-12, 6.4238e-12, 5.3326e-12, 4.3652e-12, 3.5216e-12,
    2.678e-12, 2.1532e-12, 1.6284e-12, 1.2202e-12, 9.286e-13, 6.37e-13,
    4.95e-13, 3.53e-13, 2.5004e-13, 1.8612e-13, 1.222e-13, 9.704e-14,
    7.188e-14, 5.3338e-14, 4.1414e-14, 2.949e-14, 2.3722e-14, 1.7954e-14,
    1.37794e-14, 1.11982e-14, 8.617e-15, 7.6036e-15, 6.5902e-15,
    5.5768e-15, 4.5634e-15, 3.55e-15, 3.1008e-15, 2.6516e-15, 2.2024e-15,
    1.7532e-15, 1.304e-15, 1.1354e-15, 9.668e-16, 7.982e-16, 6.296e-16,
    4.61e-16, 3.9734e-16, 3.3368e-16, 2.7002e-16, 2.0636e-16, 1.427e-16,
    1.22804e-16, 1.02908e-16, 8.3012e-17, 6.3116e-17, 4.322e-17,
    3.6838e-17, 3.0456e-17, 2.4074e-17, 1.7692e-17, 1.131e-17,
    9.6202e-18, 7.9304e-18, 6.2406e-18, 4.5508e-18, 2.861e-18,
    2.40476e-18, 1.94852e-18, 1.49228e-18, 1.03604e-18, 5.798e-19,
    4.8502e-19, 3.9024e-19, 2.9546e-19, 2.0068e-19, 1.059e-19,
    8.7084e-20, 6.8268e-20, 4.9452e-20, 3.0636e-20, 1.182e-20,
    9.64344e-21, 7.46688e-21, 5.29032e-21, 3.11376e-21, 9.372e-22,
    7.5685e-22, 5.765e-22, 3.9615e-22, 2.158e-22, 3.545e-23,
    2.86046e-23, 2.17592e-23, 1.49138e-23, 8.0684e-24, 1.223e-24,
    9.92358e-25, 7.61716e-25, 5.31074e-25, 3.00432e-25, 6.979e-26
  };
 
  static const double f114[121] = {
    1.2e-11, 1.2e-11, 1.2e-11, 1.2e-11, 1.199e-11, 1.199e-11,
    1.199e-11, 1.199e-11, 1.198e-11, 1.198e-11, 1.198e-11, 1.197e-11,
    1.196e-11, 1.191e-11, 1.185e-11, 1.167e-11, 1.149e-11, 1.12e-11,
    1.09e-11, 1.053e-11, 1.015e-11, 9.731e-12, 9.311e-12, 8.865e-12,
    8.419e-12, 7.949e-12, 7.4774e-12, 7.0058e-12, 6.54e-12, 6.08e-12,
    5.62e-12, 5.1908e-12, 4.7616e-12, 4.3622e-12, 3.9926e-12, 3.623e-12,
    3.3274e-12, 3.0318e-12, 2.7702e-12, 2.5426e-12, 2.315e-12, 2.1514e-12,
    1.9878e-12, 1.8448e-12, 1.7224e-12, 1.6e-12, 1.51e-12, 1.42e-12,
    1.3462e-12, 1.2886e-12, 1.231e-12, 1.1922e-12, 1.1534e-12, 1.1146e-12,
    1.0758e-12, 1.037e-12, 1.0025e-12, 9.68e-13, 9.335e-13, 8.99e-13,
    8.645e-13, 8.344e-13, 8.043e-13, 7.742e-13, 7.441e-13, 7.14e-13,
    6.8718e-13, 6.6036e-13, 6.3354e-13, 6.0672e-13, 5.799e-13, 5.5612e-13,
    5.3234e-13, 5.0856e-13, 4.8478e-13, 4.61e-13, 4.394e-13, 4.178e-13,
    3.962e-13, 3.746e-13, 3.53e-13, 3.3288e-13, 3.1276e-13, 2.9264e-13,
    2.7252e-13, 2.524e-13, 2.3368e-13, 2.1496e-13, 1.9624e-13, 1.7752e-13,
    1.588e-13, 1.4221e-13, 1.2562e-13, 1.0903e-13, 9.244e-14, 7.585e-14,
    6.4942e-14, 5.4034e-14, 4.3126e-14, 3.2218e-14, 2.131e-14, 1.76694e-14,
    1.40288e-14, 1.03882e-14, 6.7476e-15, 3.107e-15, 2.52738e-15,
    1.94776e-15, 1.36814e-15, 7.8852e-16, 2.089e-16, 1.69288e-16,
    1.29676e-16, 9.0064e-17, 5.0452e-17, 1.084e-17, 8.85136e-18,
    6.86272e-18, 4.87408e-18, 2.88544e-18, 8.968e-19
  };
 
  static const double f12[121] = {
    5.45e-10, 5.45e-10, 5.45e-10, 5.45e-10, 5.45e-10, 5.45e-10, 5.45e-10,
    5.45e-10, 5.45e-10, 5.45e-10, 5.45e-10, 5.45e-10, 5.429e-10, 5.291e-10,
    5.155e-10, 5.022e-10, 4.893e-10, 4.772e-10, 4.655e-10, 4.497e-10,
    4.249e-10, 4.015e-10, 3.632e-10, 3.261e-10, 2.858e-10, 2.408e-10,
    2.03e-10, 1.685e-10, 1.4e-10, 1.163e-10, 9.65e-11, 8.02e-11, 6.705e-11,
    5.624e-11, 4.764e-11, 4.249e-11, 3.792e-11, 3.315e-11, 2.819e-11,
    2.4e-11, 1.999e-11, 1.64e-11, 1.352e-11, 1.14e-11, 9.714e-12,
    8.28e-12, 7.176e-12, 6.251e-12, 5.446e-12, 4.72e-12, 4.081e-12,
    3.528e-12, 3.08e-12, 2.699e-12, 2.359e-12, 2.111e-12, 1.901e-12,
    1.709e-12, 1.534e-12, 1.376e-12, 1.233e-12, 1.103e-12, 9.869e-13,
    8.808e-13, 7.859e-13, 7.008e-13, 6.241e-13, 5.553e-13, 4.935e-13,
    4.383e-13, 3.889e-13, 3.447e-13, 3.054e-13, 2.702e-13, 2.389e-13,
    2.11e-13, 1.862e-13, 1.643e-13, 1.448e-13, 1.274e-13, 1.121e-13,
    9.844e-14, 8.638e-14, 7.572e-14, 6.62e-14, 5.782e-14, 5.045e-14,
    4.394e-14, 3.817e-14, 3.311e-14, 2.87e-14, 2.48e-14, 2.142e-14,
    1.851e-14, 1.599e-14, 1.383e-14, 1.196e-14, 1.036e-14, 9e-15,
    7.828e-15, 6.829e-15, 5.992e-15, 5.254e-15, 4.606e-15, 4.037e-15,
    3.583e-15, 3.19e-15, 2.841e-15, 2.542e-15, 2.291e-15, 2.07e-15,
    1.875e-15, 1.71e-15, 1.57e-15, 1.442e-15, 1.333e-15, 1.232e-15,
    1.147e-15, 1.071e-15, 1.001e-15, 9.396e-16
  };
 
  static const double f14[121] = {
    9e-11, 9e-11, 9e-11, 9e-11, 9e-11, 9e-11, 9e-11, 9e-11, 9e-11, 9e-11,
    9e-11, 9e-11, 9e-11, 9e-11, 9e-11, 8.91e-11, 8.73e-11, 8.46e-11,
    8.19e-11, 7.92e-11, 7.74e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11,
    7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11, 7.65e-11
  };
 
  static const double f22[121] = {
    1.4e-10, 1.4e-10, 1.4e-10, 1.4e-10, 1.4e-10, 1.4e-10, 1.4e-10,
    1.4e-10, 1.4e-10, 1.4e-10, 1.372e-10, 1.317e-10, 1.235e-10, 1.153e-10,
    1.075e-10, 1.002e-10, 9.332e-11, 8.738e-11, 8.194e-11, 7.7e-11,
    7.165e-11, 6.753e-11, 6.341e-11, 5.971e-11, 5.6e-11, 5.229e-11,
    4.859e-11, 4.488e-11, 4.118e-11, 3.83e-11, 3.568e-11, 3.308e-11,
    3.047e-11, 2.82e-11, 2.594e-11, 2.409e-11, 2.237e-11, 2.065e-11,
    1.894e-11, 1.771e-11, 1.647e-11, 1.532e-11, 1.416e-11, 1.332e-11,
    1.246e-11, 1.161e-11, 1.087e-11, 1.017e-11, 9.471e-12, 8.853e-12,
    8.235e-12, 7.741e-12, 7.247e-12, 6.836e-12, 6.506e-12, 6.176e-12,
    5.913e-12, 5.65e-12, 5.419e-12, 5.221e-12, 5.024e-12, 4.859e-12,
    4.694e-12, 4.546e-12, 4.414e-12, 4.282e-12, 4.15e-12, 4.019e-12,
    3.903e-12, 3.805e-12, 3.706e-12, 3.607e-12, 3.508e-12, 3.41e-12,
    3.31e-12, 3.212e-12, 3.129e-12, 3.047e-12, 2.964e-12, 2.882e-12,
    2.8e-12, 2.734e-12, 2.668e-12, 2.602e-12, 2.537e-12, 2.471e-12,
    2.421e-12, 2.372e-12, 2.322e-12, 2.273e-12, 2.224e-12, 2.182e-12,
    2.141e-12, 2.1e-12, 2.059e-12, 2.018e-12, 1.977e-12, 1.935e-12,
    1.894e-12, 1.853e-12, 1.812e-12, 1.77e-12, 1.73e-12, 1.688e-12,
    1.647e-12, 1.606e-12, 1.565e-12, 1.524e-12, 1.483e-12, 1.441e-12,
    1.4e-12, 1.359e-12, 1.317e-12, 1.276e-12, 1.235e-12, 1.194e-12,
    1.153e-12, 1.112e-12, 1.071e-12, 1.029e-12, 9.883e-13
  };
 
  static const double h2co[121] = {
    8.71857e-11, 8.71857e-11, 8.71857e-11, 8.71857e-11, 8.71857e-11,
    8.71857e-11, 7.72315e-11, 6.85464e-11, 6.0758e-11, 5.32087e-11,
    4.5719e-11, 3.79458e-11, 3.07607e-11, 2.46025e-11, 1.94038e-11,
    1.40882e-11, 1.0623e-11, 8.35457e-12, 6.87427e-12, 7.09071e-12,
    8.96183e-12, 1.09012e-11, 1.50545e-11, 1.92077e-11, 2.3361e-11,
    2.7054e-11, 3.01936e-11, 3.33333e-11, 3.69281e-11, 4.08069e-11,
    4.57318e-11, 5.1348e-11, 5.69642e-11, 6.33173e-11, 6.98984e-11,
    7.63144e-11, 8.22774e-11, 8.82405e-11, 9.3746e-11, 9.92074e-11,
    1.04669e-10, 1.10055e-10, 1.15293e-10, 1.20531e-10, 1.26293e-10,
    1.32585e-10, 1.35966e-10, 1.36242e-10, 1.36519e-10, 1.61155e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10, 1.99157e-10,
    1.99157e-10
  };
 
  static const double h2o[121] = {
    0.01166, 0.008269, 0.005742, 0.003845, 0.00277, 0.001897, 0.001272,
    0.000827, 0.000539, 0.0003469, 0.0001579, 3.134e-05, 1.341e-05,
    6.764e-06, 4.498e-06, 3.703e-06, 3.724e-06, 3.899e-06, 4.002e-06,
    4.122e-06, 4.277e-06, 4.438e-06, 4.558e-06, 4.673e-06, 4.763e-06,
    4.809e-06, 4.856e-06, 4.936e-06, 5.021e-06, 5.114e-06, 5.222e-06,
    5.331e-06, 5.414e-06, 5.488e-06, 5.563e-06, 5.633e-06, 5.704e-06,
    5.767e-06, 5.819e-06, 5.872e-06, 5.914e-06, 5.949e-06, 5.984e-06,
    6.015e-06, 6.044e-06, 6.073e-06, 6.104e-06, 6.136e-06, 6.167e-06,
    6.189e-06, 6.208e-06, 6.226e-06, 6.212e-06, 6.185e-06, 6.158e-06,
    6.114e-06, 6.066e-06, 6.018e-06, 5.877e-06, 5.728e-06, 5.582e-06,
    5.437e-06, 5.296e-06, 5.156e-06, 5.02e-06, 4.886e-06, 4.754e-06,
    4.625e-06, 4.498e-06, 4.374e-06, 4.242e-06, 4.096e-06, 3.955e-06,
    3.817e-06, 3.683e-06, 3.491e-06, 3.204e-06, 2.94e-06, 2.696e-06,
    2.47e-06, 2.252e-06, 2.019e-06, 1.808e-06, 1.618e-06, 1.445e-06,
    1.285e-06, 1.105e-06, 9.489e-07, 8.121e-07, 6.938e-07, 5.924e-07,
    5.04e-07, 4.288e-07, 3.648e-07, 3.103e-07, 2.642e-07, 2.252e-07,
    1.921e-07, 1.643e-07, 1.408e-07, 1.211e-07, 1.048e-07, 9.063e-08,
    7.835e-08, 6.774e-08, 5.936e-08, 5.221e-08, 4.592e-08, 4.061e-08,
    3.62e-08, 3.236e-08, 2.902e-08, 2.62e-08, 2.383e-08, 2.171e-08,
    1.989e-08, 1.823e-08, 1.684e-08, 1.562e-08, 1.449e-08, 1.351e-08
  };
 
  static const double h2o2[121] = {
    1.779e-10, 7.938e-10, 8.953e-10, 8.032e-10, 6.564e-10, 5.159e-10,
    4.003e-10, 3.026e-10, 2.222e-10, 1.58e-10, 1.044e-10, 6.605e-11,
    3.413e-11, 1.453e-11, 1.062e-11, 1.009e-11, 9.597e-12, 1.175e-11,
    1.572e-11, 2.091e-11, 2.746e-11, 3.603e-11, 4.791e-11, 6.387e-11,
    8.239e-11, 1.007e-10, 1.23e-10, 1.363e-10, 1.489e-10, 1.585e-10,
    1.608e-10, 1.632e-10, 1.576e-10, 1.502e-10, 1.423e-10, 1.302e-10,
    1.192e-10, 1.085e-10, 9.795e-11, 8.854e-11, 8.057e-11, 7.36e-11,
    6.736e-11, 6.362e-11, 6.087e-11, 5.825e-11, 5.623e-11, 5.443e-11,
    5.27e-11, 5.098e-11, 4.931e-11, 4.769e-11, 4.611e-11, 4.458e-11,
    4.308e-11, 4.102e-11, 3.887e-11, 3.682e-11, 3.521e-11, 3.369e-11,
    3.224e-11, 3.082e-11, 2.946e-11, 2.814e-11, 2.687e-11, 2.566e-11,
    2.449e-11, 2.336e-11, 2.227e-11, 2.123e-11, 2.023e-11, 1.927e-11,
    1.835e-11, 1.746e-11, 1.661e-11, 1.58e-11, 1.502e-11, 1.428e-11,
    1.357e-11, 1.289e-11, 1.224e-11, 1.161e-11, 1.102e-11, 1.045e-11,
    9.895e-12, 9.369e-12, 8.866e-12, 8.386e-12, 7.922e-12, 7.479e-12,
    7.06e-12, 6.656e-12, 6.274e-12, 5.914e-12, 5.575e-12, 5.257e-12,
    4.959e-12, 4.679e-12, 4.42e-12, 4.178e-12, 3.954e-12, 3.75e-12,
    3.557e-12, 3.372e-12, 3.198e-12, 3.047e-12, 2.908e-12, 2.775e-12,
    2.653e-12, 2.544e-12, 2.442e-12, 2.346e-12, 2.26e-12, 2.183e-12,
    2.11e-12, 2.044e-12, 1.98e-12, 1.924e-12, 1.871e-12, 1.821e-12,
    1.775e-12
  };
 
  static const double hcl[121] = {
    3.70385e-11, 3.70385e-11, 3.70385e-11, 3.70385e-11, 3.70385e-11,
    3.70385e-11, 2.21247e-11, 1.88117e-11, 2.36957e-11, 3.72192e-11,
    5.79399e-11, 8.04158e-11, 1.01779e-10, 1.2301e-10, 1.53924e-10,
    1.93737e-10, 2.5561e-10, 3.84228e-10, 6.18248e-10, 6.31222e-10,
    7.84907e-10, 9.36932e-10, 1.03508e-09, 1.13323e-09, 1.23138e-09,
    1.31985e-09, 1.39669e-09, 1.47352e-09, 1.56375e-09, 1.66234e-09,
    1.78086e-09, 1.91256e-09, 2.04425e-09, 2.16629e-09, 2.28535e-09,
    2.39439e-09, 2.47597e-09, 2.55755e-09, 2.60873e-09, 2.65696e-09,
    2.70519e-09, 2.75658e-09, 2.81422e-09, 2.87187e-09, 2.94013e-09,
    3.01911e-09, 3.09497e-09, 3.16749e-09, 3.24001e-09, 3.30525e-09,
    3.3665e-09, 3.42424e-09, 3.4619e-09, 3.49956e-09, 3.52273e-09,
    3.54214e-09, 3.56154e-09, 3.57918e-09, 3.59049e-09, 3.6018e-09,
    3.6132e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09, 3.62476e-09,
    3.62476e-09
  };
 
  static const double hcn[121] = {
    5.5e-10, 5.5e-10, 5.5e-10, 5.5e-10, 5.5e-10, 5.5e-10, 5.5e-10,
    5.5e-10, 5.5e-10, 5.5e-10, 5.5e-10, 5.498e-10, 5.495e-10, 5.493e-10,
    5.49e-10, 5.488e-10, 4.717e-10, 3.946e-10, 3.174e-10, 2.4e-10,
    1.626e-10, 1.619e-10, 1.612e-10, 1.602e-10, 1.593e-10, 1.582e-10,
    1.572e-10, 1.56e-10, 1.549e-10, 1.539e-10, 1.53e-10, 1.519e-10,
    1.506e-10, 1.487e-10, 1.467e-10, 1.449e-10, 1.43e-10, 1.413e-10,
    1.397e-10, 1.382e-10, 1.368e-10, 1.354e-10, 1.337e-10, 1.315e-10,
    1.292e-10, 1.267e-10, 1.241e-10, 1.215e-10, 1.19e-10, 1.165e-10,
    1.141e-10, 1.118e-10, 1.096e-10, 1.072e-10, 1.047e-10, 1.021e-10,
    9.968e-11, 9.739e-11, 9.539e-11, 9.339e-11, 9.135e-11, 8.898e-11,
    8.664e-11, 8.439e-11, 8.249e-11, 8.075e-11, 7.904e-11, 7.735e-11,
    7.565e-11, 7.399e-11, 7.245e-11, 7.109e-11, 6.982e-11, 6.863e-11,
    6.755e-11, 6.657e-11, 6.587e-11, 6.527e-11, 6.476e-11, 6.428e-11,
    6.382e-11, 6.343e-11, 6.307e-11, 6.272e-11, 6.238e-11, 6.205e-11,
    6.17e-11, 6.137e-11, 6.102e-11, 6.072e-11, 6.046e-11, 6.03e-11,
    6.018e-11, 6.01e-11, 6.001e-11, 5.992e-11, 5.984e-11, 5.975e-11,
    5.967e-11, 5.958e-11, 5.95e-11, 5.941e-11, 5.933e-11, 5.925e-11,
    5.916e-11, 5.908e-11, 5.899e-11, 5.891e-11, 5.883e-11, 5.874e-11,
    5.866e-11, 5.858e-11, 5.85e-11, 5.841e-11, 5.833e-11, 5.825e-11,
    5.817e-11, 5.808e-11, 5.8e-11, 5.792e-11, 5.784e-11
  };
 
  static const double hf[121] = {
    2.64279e-11, 2.64279e-11, 2.64279e-11, 2.64279e-11, 2.64279e-11,
    2.64279e-11, 2.64279e-11, 2.64279e-11, 2.64279e-11, 2.64279e-11,
    2.64279e-11, 2.64279e-11, 2.64279e-11, 3.86691e-11, 5.22002e-11,
    6.92471e-11, 9.13979e-11, 1.37918e-10, 2.24918e-10, 2.29824e-10,
    2.94241e-10, 3.58363e-10, 4.12881e-10, 4.67399e-10, 5.21917e-10,
    5.74229e-10, 6.23889e-10, 6.73549e-10, 7.24119e-10, 7.75256e-10,
    8.319e-10, 8.92185e-10, 9.52469e-10, 1.01325e-09, 1.07419e-09,
    1.13565e-09, 1.19856e-09, 1.26146e-09, 1.31439e-09, 1.36635e-09,
    1.41831e-09, 1.46549e-09, 1.50321e-09, 1.54093e-09, 1.57986e-09,
    1.62e-09, 1.66286e-09, 1.70863e-09, 1.75439e-09, 1.79827e-09,
    1.84111e-09, 1.88125e-09, 1.90603e-09, 1.93081e-09, 1.9413e-09,
    1.94807e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09, 1.95485e-09,
    1.95485e-09
  };
 
  static const double hno3[121] = {
    1.809e-10, 7.234e-10, 5.899e-10, 4.342e-10, 3.277e-10, 2.661e-10,
    2.35e-10, 2.267e-10, 2.389e-10, 2.651e-10, 3.255e-10, 4.099e-10,
    5.42e-10, 6.978e-10, 8.807e-10, 1.112e-09, 1.405e-09, 2.04e-09,
    3.111e-09, 4.5e-09, 5.762e-09, 7.37e-09, 7.852e-09, 8.109e-09,
    8.067e-09, 7.554e-09, 7.076e-09, 6.268e-09, 5.524e-09, 4.749e-09,
    3.909e-09, 3.223e-09, 2.517e-09, 1.942e-09, 1.493e-09, 1.122e-09,
    8.449e-10, 6.361e-10, 4.787e-10, 3.611e-10, 2.804e-10, 2.215e-10,
    1.758e-10, 1.441e-10, 1.197e-10, 9.953e-11, 8.505e-11, 7.334e-11,
    6.325e-11, 5.625e-11, 5.058e-11, 4.548e-11, 4.122e-11, 3.748e-11,
    3.402e-11, 3.088e-11, 2.8e-11, 2.536e-11, 2.293e-11, 2.072e-11,
    1.871e-11, 1.687e-11, 1.52e-11, 1.368e-11, 1.23e-11, 1.105e-11,
    9.922e-12, 8.898e-12, 7.972e-12, 7.139e-12, 6.385e-12, 5.708e-12,
    5.099e-12, 4.549e-12, 4.056e-12, 3.613e-12, 3.216e-12, 2.862e-12,
    2.544e-12, 2.259e-12, 2.004e-12, 1.776e-12, 1.572e-12, 1.391e-12,
    1.227e-12, 1.082e-12, 9.528e-13, 8.379e-13, 7.349e-13, 6.436e-13,
    5.634e-13, 4.917e-13, 4.291e-13, 3.745e-13, 3.267e-13, 2.854e-13,
    2.494e-13, 2.181e-13, 1.913e-13, 1.68e-13, 1.479e-13, 1.31e-13,
    1.159e-13, 1.025e-13, 9.067e-14, 8.113e-14, 7.281e-14, 6.535e-14,
    5.892e-14, 5.348e-14, 4.867e-14, 4.439e-14, 4.073e-14, 3.76e-14,
    3.476e-14, 3.229e-14, 3e-14, 2.807e-14, 2.635e-14, 2.473e-14,
    2.332e-14
  };
 
  static const double hno4[121] = {
    6.118e-12, 3.594e-12, 2.807e-12, 3.04e-12, 4.458e-12, 7.986e-12,
    1.509e-11, 2.661e-11, 3.738e-11, 4.652e-11, 4.429e-11, 3.992e-11,
    3.347e-11, 3.005e-11, 3.173e-11, 4.055e-11, 5.812e-11, 8.489e-11,
    1.19e-10, 1.482e-10, 1.766e-10, 2.103e-10, 2.35e-10, 2.598e-10,
    2.801e-10, 2.899e-10, 3e-10, 2.817e-10, 2.617e-10, 2.332e-10,
    1.933e-10, 1.605e-10, 1.232e-10, 9.285e-11, 6.941e-11, 4.951e-11,
    3.539e-11, 2.402e-11, 1.522e-11, 9.676e-12, 6.056e-12, 3.745e-12,
    2.34e-12, 1.463e-12, 9.186e-13, 5.769e-13, 3.322e-13, 1.853e-13,
    1.035e-13, 7.173e-14, 5.382e-14, 4.036e-14, 3.401e-14, 2.997e-14,
    2.635e-14, 2.316e-14, 2.034e-14, 1.783e-14, 1.56e-14, 1.363e-14,
    1.19e-14, 1.037e-14, 9.032e-15, 7.846e-15, 6.813e-15, 5.912e-15,
    5.121e-15, 4.431e-15, 3.829e-15, 3.306e-15, 2.851e-15, 2.456e-15,
    2.114e-15, 1.816e-15, 1.559e-15, 1.337e-15, 1.146e-15, 9.811e-16,
    8.389e-16, 7.162e-16, 6.109e-16, 5.203e-16, 4.425e-16, 3.76e-16,
    3.184e-16, 2.692e-16, 2.274e-16, 1.917e-16, 1.61e-16, 1.35e-16,
    1.131e-16, 9.437e-17, 7.874e-17, 6.57e-17, 5.481e-17, 4.579e-17,
    3.828e-17, 3.204e-17, 2.691e-17, 2.264e-17, 1.912e-17, 1.626e-17,
    1.382e-17, 1.174e-17, 9.972e-18, 8.603e-18, 7.45e-18, 6.453e-18,
    5.623e-18, 4.944e-18, 4.361e-18, 3.859e-18, 3.443e-18, 3.096e-18,
    2.788e-18, 2.528e-18, 2.293e-18, 2.099e-18, 1.929e-18, 1.773e-18,
    1.64e-18
  };
 
  static const double hocl[121] = {
    1.056e-12, 1.194e-12, 1.35e-12, 1.531e-12, 1.737e-12, 1.982e-12,
    2.263e-12, 2.599e-12, 2.991e-12, 3.459e-12, 4.012e-12, 4.662e-12,
    5.438e-12, 6.35e-12, 7.425e-12, 8.686e-12, 1.016e-11, 1.188e-11,
    1.389e-11, 1.659e-11, 2.087e-11, 2.621e-11, 3.265e-11, 4.064e-11,
    4.859e-11, 5.441e-11, 6.09e-11, 6.373e-11, 6.611e-11, 6.94e-11,
    7.44e-11, 7.97e-11, 8.775e-11, 9.722e-11, 1.064e-10, 1.089e-10,
    1.114e-10, 1.106e-10, 1.053e-10, 1.004e-10, 9.006e-11, 7.778e-11,
    6.739e-11, 5.636e-11, 4.655e-11, 3.845e-11, 3.042e-11, 2.368e-11,
    1.845e-11, 1.442e-11, 1.127e-11, 8.814e-12, 6.544e-12, 4.763e-12,
    3.449e-12, 2.612e-12, 1.999e-12, 1.526e-12, 1.16e-12, 8.793e-13,
    6.655e-13, 5.017e-13, 3.778e-13, 2.829e-13, 2.117e-13, 1.582e-13,
    1.178e-13, 8.755e-14, 6.486e-14, 4.799e-14, 3.54e-14, 2.606e-14,
    1.916e-14, 1.403e-14, 1.026e-14, 7.48e-15, 5.446e-15, 3.961e-15,
    2.872e-15, 2.076e-15, 1.498e-15, 1.077e-15, 7.726e-16, 5.528e-16,
    3.929e-16, 2.785e-16, 1.969e-16, 1.386e-16, 9.69e-17, 6.747e-17,
    4.692e-17, 3.236e-17, 2.232e-17, 1.539e-17, 1.061e-17, 7.332e-18,
    5.076e-18, 3.522e-18, 2.461e-18, 1.726e-18, 1.22e-18, 8.75e-19,
    6.264e-19, 4.482e-19, 3.207e-19, 2.368e-19, 1.762e-19, 1.312e-19,
    9.891e-20, 7.595e-20, 5.87e-20, 4.567e-20, 3.612e-20, 2.904e-20,
    2.343e-20, 1.917e-20, 1.568e-20, 1.308e-20, 1.1e-20, 9.25e-21,
    7.881e-21
  };
 
  static const double n2o[121] = {
    3.17e-07, 3.17e-07, 3.17e-07, 3.17e-07, 3.17e-07, 3.17e-07, 3.17e-07,
    3.17e-07, 3.17e-07, 3.17e-07, 3.124e-07, 3.077e-07, 3.03e-07,
    2.984e-07, 2.938e-07, 2.892e-07, 2.847e-07, 2.779e-07, 2.705e-07,
    2.631e-07, 2.557e-07, 2.484e-07, 2.345e-07, 2.201e-07, 2.01e-07,
    1.754e-07, 1.532e-07, 1.329e-07, 1.154e-07, 1.003e-07, 8.735e-08,
    7.617e-08, 6.512e-08, 5.547e-08, 4.709e-08, 3.915e-08, 3.259e-08,
    2.738e-08, 2.327e-08, 1.98e-08, 1.711e-08, 1.493e-08, 1.306e-08,
    1.165e-08, 1.049e-08, 9.439e-09, 8.375e-09, 7.391e-09, 6.525e-09,
    5.759e-09, 5.083e-09, 4.485e-09, 3.953e-09, 3.601e-09, 3.27e-09,
    2.975e-09, 2.757e-09, 2.556e-09, 2.37e-09, 2.195e-09, 2.032e-09,
    1.912e-09, 1.79e-09, 1.679e-09, 1.572e-09, 1.482e-09, 1.402e-09,
    1.326e-09, 1.254e-09, 1.187e-09, 1.127e-09, 1.071e-09, 1.02e-09,
    9.673e-10, 9.193e-10, 8.752e-10, 8.379e-10, 8.017e-10, 7.66e-10,
    7.319e-10, 7.004e-10, 6.721e-10, 6.459e-10, 6.199e-10, 5.942e-10,
    5.703e-10, 5.488e-10, 5.283e-10, 5.082e-10, 4.877e-10, 4.696e-10,
    4.52e-10, 4.355e-10, 4.198e-10, 4.039e-10, 3.888e-10, 3.754e-10,
    3.624e-10, 3.499e-10, 3.381e-10, 3.267e-10, 3.163e-10, 3.058e-10,
    2.959e-10, 2.864e-10, 2.77e-10, 2.686e-10, 2.604e-10, 2.534e-10,
    2.462e-10, 2.386e-10, 2.318e-10, 2.247e-10, 2.189e-10, 2.133e-10,
    2.071e-10, 2.014e-10, 1.955e-10, 1.908e-10, 1.86e-10, 1.817e-10
  };
 
  static const double n2o5[121] = {
    1.231e-11, 3.035e-12, 1.702e-12, 9.877e-13, 8.081e-13, 9.039e-13,
    1.169e-12, 1.474e-12, 1.651e-12, 1.795e-12, 1.998e-12, 2.543e-12,
    4.398e-12, 7.698e-12, 1.28e-11, 2.131e-11, 3.548e-11, 5.894e-11,
    7.645e-11, 1.089e-10, 1.391e-10, 1.886e-10, 2.386e-10, 2.986e-10,
    3.487e-10, 3.994e-10, 4.5e-10, 4.6e-10, 4.591e-10, 4.1e-10, 3.488e-10,
    2.846e-10, 2.287e-10, 1.696e-10, 1.011e-10, 6.428e-11, 4.324e-11,
    2.225e-11, 6.214e-12, 3.608e-12, 8.793e-13, 4.491e-13, 1.04e-13,
    6.1e-14, 3.436e-14, 6.671e-15, 1.171e-15, 5.848e-16, 1.212e-16,
    1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16,
    1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16,
    1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16,
    1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16,
    1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16,
    1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16,
    1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16, 1e-16,
    1e-16, 1e-16
  };
 
  static const double nh3[121] = {
    1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10,
    1e-10, 1e-10, 1e-10, 1e-10, 9.444e-11, 8.488e-11, 7.241e-11, 5.785e-11,
    4.178e-11, 3.018e-11, 2.18e-11, 1.574e-11, 1.137e-11, 8.211e-12,
    5.973e-12, 4.327e-12, 3.118e-12, 2.234e-12, 1.573e-12, 1.04e-12,
    6.762e-13, 4.202e-13, 2.406e-13, 1.335e-13, 6.938e-14, 3.105e-14,
    1.609e-14, 1.033e-14, 6.432e-15, 4.031e-15, 2.555e-15, 1.656e-15,
    1.115e-15, 7.904e-16, 5.63e-16, 4.048e-16, 2.876e-16, 2.004e-16,
    1.356e-16, 9.237e-17, 6.235e-17, 4.223e-17, 3.009e-17, 2.328e-17,
    2.002e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17, 1.914e-17,
    1.914e-17
  };
 
  static const double no[121] = {
    2.586e-10, 4.143e-11, 1.566e-11, 9.591e-12, 8.088e-12, 8.462e-12,
    1.013e-11, 1.328e-11, 1.855e-11, 2.678e-11, 3.926e-11, 5.464e-11,
    7.012e-11, 8.912e-11, 1.127e-10, 1.347e-10, 1.498e-10, 1.544e-10,
    1.602e-10, 1.824e-10, 2.078e-10, 2.366e-10, 2.691e-10, 5.141e-10,
    8.259e-10, 1.254e-09, 1.849e-09, 2.473e-09, 3.294e-09, 4.16e-09,
    5.095e-09, 6.11e-09, 6.93e-09, 7.888e-09, 8.903e-09, 9.713e-09,
    1.052e-08, 1.115e-08, 1.173e-08, 1.21e-08, 1.228e-08, 1.239e-08,
    1.231e-08, 1.213e-08, 1.192e-08, 1.138e-08, 1.085e-08, 1.008e-08,
    9.224e-09, 8.389e-09, 7.262e-09, 6.278e-09, 5.335e-09, 4.388e-09,
    3.589e-09, 2.761e-09, 2.129e-09, 1.633e-09, 1.243e-09, 9.681e-10,
    8.355e-10, 7.665e-10, 7.442e-10, 8.584e-10, 9.732e-10, 1.063e-09,
    1.163e-09, 1.286e-09, 1.472e-09, 1.707e-09, 2.032e-09, 2.474e-09,
    2.977e-09, 3.506e-09, 4.102e-09, 5.013e-09, 6.493e-09, 8.414e-09,
    1.077e-08, 1.367e-08, 1.777e-08, 2.625e-08, 3.926e-08, 5.545e-08,
    7.195e-08, 9.464e-08, 1.404e-07, 2.183e-07, 3.329e-07, 4.535e-07,
    6.158e-07, 8.187e-07, 1.075e-06, 1.422e-06, 1.979e-06, 2.71e-06,
    3.58e-06, 4.573e-06, 5.951e-06, 7.999e-06, 1.072e-05, 1.372e-05,
    1.697e-05, 2.112e-05, 2.643e-05, 3.288e-05, 3.994e-05, 4.794e-05,
    5.606e-05, 6.383e-05, 7.286e-05, 8.156e-05, 8.883e-05, 9.469e-05,
    9.848e-05, 0.0001023, 0.0001066, 0.0001115, 0.0001145, 0.0001142,
    0.0001133
  };
 
  static const double no2[121] = {
    3.036e-09, 2.945e-10, 9.982e-11, 5.069e-11, 3.485e-11, 2.982e-11,
    2.947e-11, 3.164e-11, 3.714e-11, 4.586e-11, 6.164e-11, 8.041e-11,
    9.982e-11, 1.283e-10, 1.73e-10, 2.56e-10, 3.909e-10, 5.959e-10,
    9.081e-10, 1.384e-09, 1.788e-09, 2.189e-09, 2.686e-09, 3.091e-09,
    3.49e-09, 3.796e-09, 4.2e-09, 5.103e-09, 6.005e-09, 6.3e-09, 6.706e-09,
    7.07e-09, 7.434e-09, 7.663e-09, 7.788e-09, 7.8e-09, 7.597e-09,
    7.482e-09, 7.227e-09, 6.403e-09, 5.585e-09, 4.606e-09, 3.703e-09,
    2.984e-09, 2.183e-09, 1.48e-09, 8.441e-10, 5.994e-10, 3.799e-10,
    2.751e-10, 1.927e-10, 1.507e-10, 1.102e-10, 6.971e-11, 5.839e-11,
    3.904e-11, 3.087e-11, 2.176e-11, 1.464e-11, 1.209e-11, 8.497e-12,
    6.477e-12, 4.371e-12, 2.914e-12, 2.424e-12, 1.753e-12, 1.35e-12,
    9.417e-13, 6.622e-13, 5.148e-13, 3.841e-13, 3.446e-13, 3.01e-13,
    2.551e-13, 2.151e-13, 1.829e-13, 1.64e-13, 1.475e-13, 1.352e-13,
    1.155e-13, 9.963e-14, 9.771e-14, 9.577e-14, 9.384e-14, 9.186e-14,
    9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14,
    9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14,
    9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14,
    9e-14, 9e-14, 9e-14, 9e-14, 9e-14, 9e-14
  };
 
  static const double o3[121] = {
    2.218e-08, 3.394e-08, 3.869e-08, 4.219e-08, 4.501e-08, 4.778e-08,
    5.067e-08, 5.402e-08, 5.872e-08, 6.521e-08, 7.709e-08, 9.461e-08,
    1.269e-07, 1.853e-07, 2.723e-07, 3.964e-07, 5.773e-07, 8.2e-07,
    1.155e-06, 1.59e-06, 2.076e-06, 2.706e-06, 3.249e-06, 3.848e-06,
    4.459e-06, 4.986e-06, 5.573e-06, 5.958e-06, 6.328e-06, 6.661e-06,
    6.9e-06, 7.146e-06, 7.276e-06, 7.374e-06, 7.447e-06, 7.383e-06,
    7.321e-06, 7.161e-06, 6.879e-06, 6.611e-06, 6.216e-06, 5.765e-06,
    5.355e-06, 4.905e-06, 4.471e-06, 4.075e-06, 3.728e-06, 3.413e-06,
    3.125e-06, 2.856e-06, 2.607e-06, 2.379e-06, 2.17e-06, 1.978e-06,
    1.8e-06, 1.646e-06, 1.506e-06, 1.376e-06, 1.233e-06, 1.102e-06,
    9.839e-07, 8.771e-07, 7.814e-07, 6.947e-07, 6.102e-07, 5.228e-07,
    4.509e-07, 3.922e-07, 3.501e-07, 3.183e-07, 2.909e-07, 2.686e-07,
    2.476e-07, 2.284e-07, 2.109e-07, 2.003e-07, 2.013e-07, 2.022e-07,
    2.032e-07, 2.042e-07, 2.097e-07, 2.361e-07, 2.656e-07, 2.989e-07,
    3.37e-07, 3.826e-07, 4.489e-07, 5.26e-07, 6.189e-07, 7.312e-07,
    8.496e-07, 8.444e-07, 8.392e-07, 8.339e-07, 8.286e-07, 8.234e-07,
    8.181e-07, 8.129e-07, 8.077e-07, 8.026e-07, 6.918e-07, 5.176e-07,
    3.865e-07, 2.885e-07, 2.156e-07, 1.619e-07, 1.219e-07, 9.161e-08,
    6.972e-08, 5.399e-08, 3.498e-08, 2.111e-08, 1.322e-08, 8.482e-09,
    5.527e-09, 3.423e-09, 2.071e-09, 1.314e-09, 8.529e-10, 5.503e-10,
    3.665e-10
  };
 
  static const double ocs[121] = {
    6e-10, 6e-10, 6e-10, 6e-10, 6e-10, 6e-10, 6e-10, 6e-10, 6e-10, 5.997e-10,
    5.989e-10, 5.881e-10, 5.765e-10, 5.433e-10, 5.074e-10, 4.567e-10,
    4.067e-10, 3.601e-10, 3.093e-10, 2.619e-10, 2.232e-10, 1.805e-10,
    1.46e-10, 1.187e-10, 8.03e-11, 5.435e-11, 3.686e-11, 2.217e-11,
    1.341e-11, 8.756e-12, 4.511e-12, 2.37e-12, 1.264e-12, 8.28e-13,
    5.263e-13, 3.209e-13, 1.717e-13, 9.068e-14, 4.709e-14, 2.389e-14,
    1.236e-14, 1.127e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14, 1.091e-14,
    1.091e-14, 1.091e-14, 1.091e-14
  };
 
  static const double sf6[121] = {
    4.103e-12, 4.103e-12, 4.103e-12, 4.103e-12, 4.103e-12, 4.103e-12,
    4.103e-12, 4.103e-12, 4.103e-12, 4.087e-12, 4.064e-12, 4.023e-12,
    3.988e-12, 3.941e-12, 3.884e-12, 3.755e-12, 3.622e-12, 3.484e-12,
    3.32e-12, 3.144e-12, 2.978e-12, 2.811e-12, 2.653e-12, 2.489e-12,
    2.332e-12, 2.199e-12, 2.089e-12, 2.013e-12, 1.953e-12, 1.898e-12,
    1.859e-12, 1.826e-12, 1.798e-12, 1.776e-12, 1.757e-12, 1.742e-12,
    1.728e-12, 1.717e-12, 1.707e-12, 1.698e-12, 1.691e-12, 1.685e-12,
    1.679e-12, 1.675e-12, 1.671e-12, 1.668e-12, 1.665e-12, 1.663e-12,
    1.661e-12, 1.659e-12, 1.658e-12, 1.657e-12, 1.656e-12, 1.655e-12,
    1.654e-12, 1.653e-12, 1.653e-12, 1.652e-12, 1.652e-12, 1.652e-12,
    1.651e-12, 1.651e-12, 1.651e-12, 1.651e-12, 1.651e-12, 1.651e-12,
    1.651e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12,
    1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12,
    1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12,
    1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12,
    1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12,
    1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12,
    1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12,
    1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12, 1.65e-12
  };
 
  static const double so2[121] = {
    1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10, 1e-10,
    1e-10, 1e-10, 9.867e-11, 9.537e-11, 9e-11, 8.404e-11, 7.799e-11,
    7.205e-11, 6.616e-11, 6.036e-11, 5.475e-11, 5.007e-11, 4.638e-11,
    4.346e-11, 4.055e-11, 3.763e-11, 3.471e-11, 3.186e-11, 2.905e-11,
    2.631e-11, 2.358e-11, 2.415e-11, 2.949e-11, 3.952e-11, 5.155e-11,
    6.76e-11, 8.741e-11, 1.099e-10, 1.278e-10, 1.414e-10, 1.512e-10,
    1.607e-10, 1.699e-10, 1.774e-10, 1.832e-10, 1.871e-10, 1.907e-10,
    1.943e-10, 1.974e-10, 1.993e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10,
    2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10,
    2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10,
    2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10,
    2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10,
    2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10,
    2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10,
    2e-10, 2e-10, 2e-10, 2e-10, 2e-10, 2e-10
  };
 
  const double *q[NG] = { NULL };
 
  /* Identify variable... */
  for (int ig = 0; ig < ctl->ng; ig++) {
    q[ig] = NULL;
    if (strcasecmp(ctl->emitter[ig], "C2H2") == 0)
      q[ig] = c2h2;
    if (strcasecmp(ctl->emitter[ig], "C2H6") == 0)
      q[ig] = c2h6;
    if (strcasecmp(ctl->emitter[ig], "CCl4") == 0)
      q[ig] = ccl4;
    if (strcasecmp(ctl->emitter[ig], "CH3OH") == 0)
      q[ig] = ch3oh;
    if (strcasecmp(ctl->emitter[ig], "CH4") == 0)
      q[ig] = ch4;
    if (strcasecmp(ctl->emitter[ig], "ClO") == 0)
      q[ig] = clo;
    if (strcasecmp(ctl->emitter[ig], "ClONO2") == 0)
      q[ig] = clono2;
    if (strcasecmp(ctl->emitter[ig], "CO") == 0)
      q[ig] = co;
    if (strcasecmp(ctl->emitter[ig], "COF2") == 0)
      q[ig] = cof2;
    if (strcasecmp(ctl->emitter[ig], "F11") == 0)
      q[ig] = f11;
    if (strcasecmp(ctl->emitter[ig], "F113") == 0)
      q[ig] = f113;
    if (strcasecmp(ctl->emitter[ig], "F114") == 0)
      q[ig] = f114;
    if (strcasecmp(ctl->emitter[ig], "F12") == 0)
      q[ig] = f12;
    if (strcasecmp(ctl->emitter[ig], "F14") == 0)
      q[ig] = f14;
    if (strcasecmp(ctl->emitter[ig], "F22") == 0)
      q[ig] = f22;
    if (strcasecmp(ctl->emitter[ig], "H2CO") == 0)
      q[ig] = h2co;
    if (strcasecmp(ctl->emitter[ig], "H2O") == 0)
      q[ig] = h2o;
    if (strcasecmp(ctl->emitter[ig], "H2O2") == 0)
      q[ig] = h2o2;
    if (strcasecmp(ctl->emitter[ig], "HCl") == 0)
      q[ig] = hcl;
    if (strcasecmp(ctl->emitter[ig], "HCN") == 0)
      q[ig] = hcn;
    if (strcasecmp(ctl->emitter[ig], "HF") == 0)
      q[ig] = hf;
    if (strcasecmp(ctl->emitter[ig], "HNO3") == 0)
      q[ig] = hno3;
    if (strcasecmp(ctl->emitter[ig], "HNO4") == 0)
      q[ig] = hno4;
    if (strcasecmp(ctl->emitter[ig], "HOCl") == 0)
      q[ig] = hocl;
    if (strcasecmp(ctl->emitter[ig], "N2O") == 0)
      q[ig] = n2o;
    if (strcasecmp(ctl->emitter[ig], "N2O5") == 0)
      q[ig] = n2o5;
    if (strcasecmp(ctl->emitter[ig], "NH3") == 0)
      q[ig] = nh3;
    if (strcasecmp(ctl->emitter[ig], "NO") == 0)
      q[ig] = no;
    if (strcasecmp(ctl->emitter[ig], "NO2") == 0)
      q[ig] = no2;
    if (strcasecmp(ctl->emitter[ig], "O3") == 0)
      q[ig] = o3;
    if (strcasecmp(ctl->emitter[ig], "OCS") == 0)
      q[ig] = ocs;
    if (strcasecmp(ctl->emitter[ig], "SF6") == 0)
      q[ig] = sf6;
    if (strcasecmp(ctl->emitter[ig], "SO2") == 0)
      q[ig] = so2;
  }
 
  /* Loop over atmospheric data points... */
  for (int ip = 0; ip < atm->np; ip++) {
 
    /* Get altitude index... */
    const int iz = locate_reg(z, 121, atm->z[ip]);
 
    /* Interpolate pressure... */
    atm->p[ip] = LOGY(z[iz], pre[iz], z[iz + 1], pre[iz + 1], atm->z[ip]);
 
    /* Interpolate temperature and trace gases, holding them constant
       above the top of the built-in climatology table... */
    const double zt = MIN(atm->z[ip], z[120]);
 
    atm->t[ip] = LIN(z[iz], tem[iz], z[iz + 1], tem[iz + 1], zt);
 
    for (int ig = 0; ig < ctl->ng; ig++)
      if (q[ig] != NULL)
        atm->q[ig][ip] =
          LIN(z[iz], q[ig][iz], z[iz + 1], q[ig][iz + 1], zt);
      else
        atm->q[ig][ip] = 0;
 
    /* Set CO2... */
    if (ctl->ig_co2 >= 0)
      atm->q[ctl->ig_co2][ip] = CO2_FIT(atm->time[ip]);
 
    /* Set N2... */
    if (ctl->ig_n2 >= 0)
      atm->q[ctl->ig_n2][ip] = N2;
 
    /* Set O2... */
    if (ctl->ig_o2 >= 0)
      atm->q[ctl->ig_o2][ip] = O2;
 
    /* Set extinction to zero... */
    for (int iw = 0; iw < ctl->nw; iw++)
      atm->k[iw][ip] = 0;
 
    /* Set cloud layer... */
    atm->clz = atm->cldz = 0;
    for (int icl = 0; icl < ctl->ncl; icl++)
      atm->clk[icl] = 0;
 
    /* Set surface... */
    atm->sft = 0;
    for (int isf = 0; isf < ctl->nsf; isf++)
      atm->sfeps[isf] = 1;
  }
 
  /* Overwrite with JuMACS climatology... */
  if (clim != NULL)
    climatology_external(ctl, clim, atm);
  else
    LOG(1, "Use built-in climatology...");
 
  /* Ensure non-negative trace-gas mixing ratios... */
  for (int ip = 0; ip < atm->np; ip++)
    for (int ig = 0; ig < ctl->ng; ig++)
      atm->q[ig][ip] = MAX(atm->q[ig][ip], 0.0);
}
 
/*****************************************************************************/
 
int read_clim_field(
  const char *filename,
  const char *varname,
  const int ncid,
  const int dim_month,
  const int dim_alt,
  const int dim_lat,
  const int nalt,
  const int nlat,
  double field[CT][CZ][CLAT],
  double *vmin,
  double *vmax) {
 
  int varid;
 
  /* Skip missing variables... */
  if (nc_inq_varid(ncid, varname, &varid) != NC_NOERR)
    return 0;
 
  /* Check dimensions... */
  int ndims = 0;
  int dims[3] = { -1, -1, -1 };
  NC(nc_inq_varndims(ncid, varid, &ndims));
  if (ndims != 3)
    ERRMSG("NetCDF variable %s in climatology file %s has wrong number of "
           "dimensions!", varname, filename);
  NC(nc_inq_vardimid(ncid, varid, dims));
  if (dims[0] != dim_month || dims[1] != dim_alt || dims[2] != dim_lat)
    ERRMSG("NetCDF variable %s in climatology file %s has wrong dimensions!",
           varname, filename);
 
  /* Read the whole field in a single call into a compact temporary buffer
     and copy it into the padded target array, checking for non-finite
     values... */
  double *tmp;
  ALLOC(tmp, double, (size_t) CT * (size_t) nalt * (size_t) nlat);
  NC(nc_get_var_double(ncid, varid, tmp));
  double min = 1e100;
  double max = -1e100;
  for (int m = 0; m < CT; m++)
    for (int iz = 0; iz < nalt; iz++)
      for (int il = 0; il < nlat; il++) {
        const size_t idx = ((size_t) m * (size_t) nalt + (size_t) iz)
          * (size_t) nlat + (size_t) il;
        if (!isfinite(tmp[idx]))
          ERRMSG("Non-finite value in NetCDF variable %s of climatology "
                 "file %s!", varname, filename);
        min = MIN(min, tmp[idx]);
        max = MAX(max, tmp[idx]);
        field[m][iz][il] = tmp[idx];
      }
  free(tmp);
 
  *vmin = min;
  *vmax = max;
 
  return 1;
}
 
/*****************************************************************************/
 
/* Width of transition region towards built-in climatology [km]. */
#define CLIM_TRANSITION 20.
 
/* Top-boundary policies for blending back to the built-in climatology
   above the JuMACS model top. Default is a cosine blend of the mixing
   ratio itself. Gases for which such a blend is scientifically less
   appropriate instead keep the top-level JuMACS value constant with
   altitude... */
#define CLIM_TOP_CONSTANT 1
#define CLIM_TOP_LOG      2
 
static int climatology_external_top_policy(
  const char *emitter) {
  static const char *constant_gases[] = {
    "C2H6", "CCl4", "F11", "F12", "F22", "H2CO", "HNO3", "HNO4",
    "N2O", "N2O5", "NO2", "OCS"
  };
  static const char *log_gases[] = { "ClONO2" };
 
  for (size_t i = 0; i < sizeof(constant_gases) / sizeof(constant_gases[0]);
       i++)
    if (strcasecmp(emitter, constant_gases[i]) == 0)
      return CLIM_TOP_CONSTANT;
 
  for (size_t i = 0; i < sizeof(log_gases) / sizeof(log_gases[0]); i++)
    if (strcasecmp(emitter, log_gases[i]) == 0)
      return CLIM_TOP_LOG;
 
  return 0;
}
 
void climatology_external_interp(
  const clim_t *clim,
  const atm_t *atm,
  const double field[CT][CZ][CLAT],
  const int top_policy,
  double *out) {
 
  const double *alt = clim->alt;
  const double *latg = clim->lat;
  const int nalt = clim->nalt;
  const int nlat = clim->nlat;
 
  /* JuMACS model top... */
  const double ztop = alt[nalt - 1];
 
  /* Length of a climatological year [s]... */
  const double year = 365.25 * 86400.;
 
  for (int ip = 0; ip < atm->np; ip++) {
 
    /* Keep built-in climatology above the transition region, except for
       fields with constant extrapolation... */
    if (top_policy != CLIM_TOP_CONSTANT &&
        atm->z[ip] >= ztop + CLIM_TRANSITION)
      continue;
 
    /* Position within the climatological year... */
    double sec = FMOD(atm->time[ip], year);
    while (sec < 0)
      sec += year;
 
    /* Determine climatological time interval, cyclically interpolating
       between December and January across the turn of the year... */
    int it;
    double t0, t1;
    if (sec < clim->time[0]) {
      it = clim->ntime - 1;
      t0 = clim->time[it] - year;
      t1 = clim->time[0];
    } else if (sec >= clim->time[clim->ntime - 1]) {
      it = clim->ntime - 1;
      t0 = clim->time[it];
      t1 = clim->time[0] + year;
    } else {
      it = locate_irr(clim->time, clim->ntime, sec);
      t0 = clim->time[it];
      t1 = clim->time[it + 1];
    }
    const int it2 = (it + 1) % clim->ntime;
 
    /* Latitude index (clamped at the polar band centers)... */
    double latq = atm->lat[ip];
    if (latq < latg[0])
      latq = latg[0];
    else if (latq > latg[nlat - 1])
      latq = latg[nlat - 1];
    const int il = locate_reg(latg, nlat, latq);
 
    /* Altitude index (clamped at the JuMACS grid boundaries)... */
    double zq = atm->z[ip];
    if (zq < alt[0])
      zq = alt[0];
    else if (zq > ztop)
      zq = ztop;
    const int iz = locate_reg(alt, nalt, zq);
 
    /* Trilinear interpolation (linear in all directions)... */
    const double v0 = LIN(alt[iz],
                          LIN(latg[il], field[it][iz][il], latg[il + 1],
                              field[it][iz][il + 1], latq),
                          alt[iz + 1],
                          LIN(latg[il], field[it][iz + 1][il], latg[il + 1],
                              field[it][iz + 1][il + 1], latq), zq);
    const double v1 = LIN(alt[iz],
                          LIN(latg[il], field[it2][iz][il], latg[il + 1],
                              field[it2][iz][il + 1], latq),
                          alt[iz + 1],
                          LIN(latg[il], field[it2][iz + 1][il], latg[il + 1],
                              field[it2][iz + 1][il + 1], latq), zq);
 
    const double jumacs = LIN(t0, v0, t1, v1, sec);
 
    /* Blend smoothly towards the built-in climatology above the model
       top, using a cosine taper over the transition region; before
       overwriting, out[] holds the built-in climatology. For gases with
       constant extrapolation, keep the top-level JuMACS value. For gases
       with logarithmic blending, taper the logarithms of the mixing
       ratios if both are strictly positive, falling back to the ordinary
       blend otherwise... */
    if (atm->z[ip] > ztop && top_policy != CLIM_TOP_CONSTANT) {
      const double x = (atm->z[ip] - ztop) / CLIM_TRANSITION;
      const double w = 0.5 * (1. + cos(M_PI * x));
      if (top_policy == CLIM_TOP_LOG && jumacs > 0. && out[ip] > 0.)
        out[ip] = exp(w * log(jumacs) + (1. - w) * log(out[ip]));
      else
        out[ip] = w * jumacs + (1. - w) * out[ip];
    } else
      out[ip] = jumacs;
  }
}
 
/*****************************************************************************/
 
clim_t *read_clim(
  const ctl_t *ctl) {
 
  /* No JuMACS climatology requested... */
  if (strcmp(ctl->climfile, "-") == 0)
    return NULL;
 
  /* Allocate... */
  clim_t *clim;
  ALLOC(clim, clim_t, 1);
 
  /* Start with an empty climatology... */
  memset(clim, 0, sizeof(clim_t));
 
  /* Set climatological time coordinates as seconds into a year of 365.25
     days, matching the centers of the twelve monthly fields... */
  static const double jumacs_time[CT] = { 1209600.0, 3888000.0, 6393600.0,
    9072000.0, 11664000.0, 14342400.0,
    16934400.0, 19612800.0, 22291200.0,
    24883200.0, 27561600.0, 30153600.0
  };
  clim->ntime = CT;
  memcpy(clim->time, jumacs_time, sizeof(clim->time));
 
  LOG(1, "Read JuMACS climatology: %s", ctl->climfile);
 
  /* Open climatology file... */
  int ncid;
  const int status = nc_open(ctl->climfile, NC_NOWRITE, &ncid);
  if (status != NC_NOERR)
    ERRMSG("Cannot open climatology file %s: %s",
           ctl->climfile, nc_strerror(status));
 
  /* Check dimensions... */
  int dim_month, dim_alt, dim_lat;
  size_t len;
  if (nc_inq_dimid(ncid, "month", &dim_month) != NC_NOERR ||
      nc_inq_dimlen(ncid, dim_month, &len) != NC_NOERR || (int) len != 12)
    ERRMSG("Climatology file %s has no dimension 'month' of length 12 - "
           "not a JuMACS climatology file?", ctl->climfile);
  if (nc_inq_dimid(ncid, "altitude", &dim_alt) != NC_NOERR ||
      nc_inq_dimlen(ncid, dim_alt, &len) != NC_NOERR || (int) len < 2)
    ERRMSG("Climatology file %s has no dimension 'altitude' - "
           "not a JuMACS climatology file?", ctl->climfile);
  if ((int) len > CZ)
    ERRMSG("Climatology file %s has %d altitude levels, exceeding the "
           "maximum of %d supported by this version of JURASSIC!",
           ctl->climfile, (int) len, CZ);
  clim->nalt = (int) len;
  if (nc_inq_dimid(ncid, "lat", &dim_lat) != NC_NOERR ||
      nc_inq_dimlen(ncid, dim_lat, &len) != NC_NOERR || (int) len < 2)
    ERRMSG("Climatology file %s has no dimension 'lat' - "
           "not a JuMACS climatology file?", ctl->climfile);
  if ((int) len > CLAT)
    ERRMSG("Climatology file %s has %d latitude bands, exceeding the "
           "maximum of %d supported by this version of JURASSIC!",
           ctl->climfile, (int) len, CLAT);
  clim->nlat = (int) len;
 
  /* Read and check coordinates... */
  int varid;
  int ndims;
  int dims[4];
  if (nc_inq_varid(ncid, "altitude", &varid) != NC_NOERR)
    ERRMSG("Cannot find coordinate 'altitude' in climatology file %s!",
           ctl->climfile);
  ndims = 0;
  NC(nc_inq_varndims(ncid, varid, &ndims));
  if (ndims != 1)
    ERRMSG("Coordinate 'altitude' in climatology file %s is not a "
           "one-dimensional variable!", ctl->climfile);
  NC(nc_inq_vardimid(ncid, varid, dims));
  if (dims[0] != dim_alt)
    ERRMSG("Coordinate 'altitude' in climatology file %s does not use the "
           "dimension 'altitude'!", ctl->climfile);
  NC(nc_get_var_double(ncid, varid, clim->alt));
  if (nc_inq_varid(ncid, "lat", &varid) != NC_NOERR)
    ERRMSG("Cannot find coordinate 'lat' in climatology file %s!",
           ctl->climfile);
  ndims = 0;
  NC(nc_inq_varndims(ncid, varid, &ndims));
  if (ndims != 1)
    ERRMSG("Coordinate 'lat' in climatology file %s is not a "
           "one-dimensional variable!", ctl->climfile);
  NC(nc_inq_vardimid(ncid, varid, dims));
  if (dims[0] != dim_lat)
    ERRMSG("Coordinate 'lat' in climatology file %s does not use the "
           "dimension 'lat'!", ctl->climfile);
  NC(nc_get_var_double(ncid, varid, clim->lat));
  for (int i = 0; i < clim->nalt; i++) {
    if (!isfinite(clim->alt[i]))
      ERRMSG("Non-finite coordinate 'altitude' in climatology file %s!",
             ctl->climfile);
    if (i > 0 && clim->alt[i] <= clim->alt[i - 1])
      ERRMSG("Coordinate 'altitude' not strictly increasing in climatology "
             "file %s!", ctl->climfile);
  }
  for (int i = 0; i < clim->nlat; i++) {
    if (!isfinite(clim->lat[i]))
      ERRMSG("Non-finite coordinate 'lat' in climatology file %s!",
             ctl->climfile);
    if (i > 0 && clim->lat[i] <= clim->lat[i - 1])
      ERRMSG("Coordinate 'lat' not strictly increasing in climatology file "
             "%s!", ctl->climfile);
  }
 
  /* Check that the coordinates are equally spaced, since the interpolation
     locates grid cells by index arithmetic rather than by searching... */
  const double dz = clim->alt[1] - clim->alt[0];
  for (int i = 2; i < clim->nalt; i++)
    if (fabs(clim->alt[i] - clim->alt[i - 1] - dz) > 1e-6 * fabs(dz))
      ERRMSG("Coordinate 'altitude' not equally spaced in climatology "
             "file %s - interpolation requires a regular grid!",
             ctl->climfile);
  const double dy = clim->lat[1] - clim->lat[0];
  for (int i = 2; i < clim->nlat; i++)
    if (fabs(clim->lat[i] - clim->lat[i - 1] - dy) > 1e-6 * fabs(dy))
      ERRMSG("Coordinate 'lat' not equally spaced in climatology "
             "file %s - interpolation requires a regular grid!",
             ctl->climfile);
 
  LOG(2, "Number of time steps: %d", clim->ntime);
  LOG(2, "Altitude grid: %d levels, %g ... %g km | dz = %g km",
      clim->nalt, clim->alt[0], clim->alt[clim->nalt - 1], dz);
  LOG(2, "Latitude grid: %d bands, %g ... %g deg | dy = %g deg",
      clim->nlat, clim->lat[0], clim->lat[clim->nlat - 1], dy);
 
  /* Read and check temperature... */
  double vmin;
  double vmax;
  if (!read_clim_field(ctl->climfile, "temperature_mean", ncid,
                       dim_month, dim_alt, dim_lat, clim->nalt,
                       clim->nlat, clim->t, &vmin, &vmax))
    ERRMSG("Climatology file %s has no variable 'temperature_mean' - "
           "not a complete JuMACS climatology file?", ctl->climfile);
  clim->has_t = 1;
  LOG(2, "Temperature: JuMACS temperature_mean, %g ... %g K", vmin, vmax);
 
  /* Read trace gases... */
  /* Mapping of JURASSIC emitter names to JuMACS climatology variable base
     names. Species without an entry keep their built-in climatological
     values. CO2, N2, and O2 are deliberately not mapped, since they are
     handled specially by the built-in climatology. */
  const struct {
    const char *emitter;
    const char *varname;
  } jumacs_map[] = {
    {"C2H2", "c2h2"},
    {"C2H6", "c2h6"},
    {"CCl4", "ccl4"},
    {"CH4", "ch4"},
    {"ClO", "clo"},
    {"ClONO2", "clono2"},
    {"CO", "co"},
    {"F11", "cfc_11"},
    {"F12", "cfc_12"},
    {"F22", "hcfc_22"},
    {"H2CO", "ch2o"},
    {"H2O", "h2o"},
    {"H2O2", "h2o2"},
    {"HCl", "hcl"},
    {"HNO3", "hno3"},
    {"HNO4", "hno4"},
    {"HOCl", "hocl"},
    {"N2O", "n2o"},
    {"N2O5", "n2o5"},
    {"NO", "no"},
    {"NO2", "no2"},
    {"O3", "o3"},
    {"OCS", "cos"},
    {"SO2", "so2"}
  };
 
  char varname[LEN];
  for (int ig = 0; ig < ctl->ng; ig++) {
    const char *base = NULL;
    for (size_t i = 0; i < sizeof(jumacs_map) / sizeof(jumacs_map[0]); i++)
      if (strcasecmp(ctl->emitter[ig], jumacs_map[i].emitter) == 0) {
        base = jumacs_map[i].varname;
        break;
      }
    if (base == NULL) {
      if (ig == ctl->ig_co2) {
        LOG(2, "%s: built-in CO2 fit", ctl->emitter[ig]);
      } else if (ig == ctl->ig_n2 || ig == ctl->ig_o2) {
        LOG(2, "%s: constant", ctl->emitter[ig]);
      } else {
        LOG(2, "%s: built-in climatology", ctl->emitter[ig]);
      }
      continue;
    }
    sprintf(varname, "%s_mean", base);
    clim->has_q[ig] = read_clim_field(ctl->climfile, varname,
                                      ncid, dim_month, dim_alt,
                                      dim_lat, clim->nalt,
                                      clim->nlat, clim->q[ig],
                                      &vmin, &vmax);
    if (clim->has_q[ig]) {
      LOG(2, "%s: JuMACS %s, %g ... %g ppv", ctl->emitter[ig], varname,
          vmin, vmax);
    } else {
      LOG(2, "%s: built-in climatology (JuMACS variable %s not found)",
          ctl->emitter[ig], varname);
    }
  }
 
  LOG(2, "Pressure: built-in climatology");
 
  /* Close climatology file... */
  NC(nc_close(ncid));
 
  /* Return pointer... */
  return clim;
}
 
/*****************************************************************************/
 
void climatology_external(
  const ctl_t *ctl,
  const clim_t *clim,
  atm_t *atm) {
 
  /* Overwrite temperature... */
  if (clim->has_t)
    climatology_external_interp(clim, atm, clim->t, 0, atm->t);
 
  /* Overwrite trace gases... */
  for (int ig = 0; ig < ctl->ng; ig++)
    if (clim->has_q[ig])
      climatology_external_interp(clim, atm, clim->q[ig],
                                  climatology_external_top_policy(
                                    ctl->emitter[ig]),
                                  atm->q[ig]);
}
 
/*****************************************************************************/
 
double cos_sza(
  const double sec,
  const double lon,
  const double lat) {
 
  /* Number of days and fraction with respect to 2000-01-01T12:00Z... */
  const double D = sec / 86400 - 0.5;
 
  /* Geocentric apparent ecliptic longitude [rad]... */
  const double g = DEG2RAD(357.529 + 0.98560028 * D);
  const double q = 280.459 + 0.98564736 * D;
  const double L = DEG2RAD(q + 1.915 * sin(g) + 0.020 * sin(2 * g));
 
  /* Mean obliquity of the ecliptic [rad]... */
  const double e = DEG2RAD(23.439 - 0.00000036 * D);
 
  /* Declination [rad]... */
  const double sindec = sin(e) * sin(L);
 
  /* Right ascension [rad]... */
  const double ra = atan2(cos(e) * sin(L), cos(L));
 
  /* Greenwich Mean Sidereal Time [h]... */
  const double GMST = 18.697374558 + 24.06570982441908 * D;
 
  /* Local Sidereal Time [h]... */
  const double LST = GMST + lon / 15;
 
  /* Hour angle [rad]... */
  const double h = LST / 12 * M_PI - ra;
 
  /* Convert latitude... */
  const double lat_help = DEG2RAD(lat);
 
  /* Return cosine of solar zenith angle... */
  return sin(lat_help) * sindec + cos(lat_help)
    * sqrt(1 - POW2(sindec)) * cos(h);
}
 
/*****************************************************************************/
 
double cost_function(
  const gsl_vector *dx,
  const gsl_vector *dy,
  const gsl_matrix *s_a_inv,
  const gsl_vector *sig_eps_inv) {
 
  double chisq_a, chisq_m = 0;
 
  /* Get sizes... */
  const size_t m = dy->size;
  const size_t n = dx->size;
 
  /* Allocate... */
  gsl_vector *x_aux = gsl_vector_alloc(n);
 
  /* Determine normalized cost function...
     (chi^2 = 1/m * [dy^T * S_eps^{-1} * dy + dx^T * S_a^{-1} * dx]) */
  for (size_t i = 0; i < m; i++)
    chisq_m += POW2(gsl_vector_get(dy, i) * gsl_vector_get(sig_eps_inv, i));
  gsl_blas_dgemv(CblasNoTrans, 1.0, s_a_inv, dx, 0.0, x_aux);
  gsl_blas_ddot(dx, x_aux, &chisq_a);
 
  /* Free... */
  gsl_vector_free(x_aux);
 
  /* Return cost function value... */
  return (chisq_m + chisq_a) / (double) m;
}
 
/*****************************************************************************/
 
double ctmco2(
  const double nu,
  const double p,
  const double t,
  const double u) {
 
  static const double co2296[2001] =
    { 9.3388e-5, 9.7711e-5, 1.0224e-4, 1.0697e-4,
    1.1193e-4, 1.1712e-4, 1.2255e-4, 1.2824e-4, 1.3419e-4, 1.4043e-4,
    1.4695e-4, 1.5378e-4, 1.6094e-4, 1.6842e-4, 1.7626e-4, 1.8447e-4,
    1.9307e-4, 2.0207e-4, 2.1149e-4, 2.2136e-4, 2.3169e-4, 2.4251e-4,
    2.5384e-4, 2.657e-4, 2.7813e-4, 2.9114e-4, 3.0477e-4, 3.1904e-4,
    3.3399e-4, 3.4965e-4, 3.6604e-4, 3.8322e-4, 4.0121e-4, 4.2006e-4,
    4.398e-4, 4.6047e-4, 4.8214e-4, 5.0483e-4, 5.286e-4, 5.535e-4,
    5.7959e-4, 6.0693e-4, 6.3557e-4, 6.6558e-4, 6.9702e-4, 7.2996e-4,
    7.6449e-4, 8.0066e-4, 8.3856e-4, 8.7829e-4, 9.1991e-4, 9.6354e-4,
    .0010093, .0010572, .0011074, .00116, .0012152, .001273,
    .0013336, .0013972, .0014638, .0015336, .0016068, .0016835,
    .001764, .0018483, .0019367, .0020295, .0021267, .0022286,
    .0023355, .0024476, .0025652, .0026885, .0028178, .0029534,
    .0030956, .0032448, .0034012, .0035654, .0037375, .0039181,
    .0041076, .0043063, .0045148, .0047336, .0049632, .005204,
    .0054567, .0057219, .0060002, .0062923, .0065988, .0069204,
    .007258, .0076123, .0079842, .0083746, .0087844, .0092146,
    .0096663, .01014, .010638, .011161, .01171, .012286, .012891,
    .013527, .014194, .014895, .015631, .016404, .017217, .01807,
    .018966, .019908, .020897, .021936, .023028, .024176, .025382,
    .026649, .027981, .02938, .030851, .032397, .034023, .035732,
    .037528, .039416, .041402, .04349, .045685, .047994, .050422,
    .052975, .055661, .058486, .061458, .064584, .067873, .071334,
    .074975, .078807, .082839, .087082, .091549, .096249, .1012,
    .10641, .11189, .11767, .12375, .13015, .13689, .14399, .15147,
    .15935, .16765, .17639, .18561, .19531, .20554, .21632, .22769,
    .23967, .25229, .2656, .27964, .29443, .31004, .3265, .34386,
    .36218, .3815, .40188, .42339, .44609, .47004, .49533, .52202,
    .5502, .57995, .61137, .64455, .6796, .71663, .75574, .79707,
    .84075, .88691, .9357, .98728, 1.0418, 1.0995, 1.1605, 1.225,
    1.2932, 1.3654, 1.4418, 1.5227, 1.6083, 1.6989, 1.7948, 1.8964,
    2.004, 2.118, 2.2388, 2.3668, 2.5025, 2.6463, 2.7988, 2.9606,
    3.1321, 3.314, 3.5071, 3.712, 3.9296, 4.1605, 4.4058, 4.6663,
    4.9431, 5.2374, 5.5501, 5.8818, 6.2353, 6.6114, 7.0115, 7.4372,
    7.8905, 8.3731, 8.8871, 9.4349, 10.019, 10.641, 11.305, 12.013,
    12.769, 13.576, 14.437, 15.358, 16.342, 17.39, 18.513, 19.716,
    21.003, 22.379, 23.854, 25.436, 27.126, 28.942, 30.89, 32.973,
    35.219, 37.634, 40.224, 43.021, 46.037, 49.29, 52.803, 56.447,
    60.418, 64.792, 69.526, 74.637, 80.182, 86.193, 92.713, 99.786,
    107.47, 115.84, 124.94, 134.86, 145.69, 157.49, 170.3, 184.39,
    199.83, 216.4, 234.55, 254.72, 276.82, 299.85, 326.16, 354.99,
    386.51, 416.68, 449.89, 490.12, 534.35, 578.25, 632.26, 692.61,
    756.43, 834.75, 924.11, 1016.9, 996.96, 1102.7, 1219.2, 1351.9,
    1494.3, 1654.1, 1826.5, 2027.9, 2249., 2453.8, 2714.4, 2999.4,
    3209.5, 3509., 3840.4, 3907.5, 4190.7, 4533.5, 4648.3, 5059.1,
    5561.6, 6191.4, 6820.8, 7905.9, 9362.2, 2431.3, 2211.3, 2046.8,
    2023.8, 1985.9, 1905.9, 1491.1, 1369.8, 1262.2, 1200.7, 887.74,
    820.25, 885.23, 887.21, 816.73, 1126.9, 1216.2, 1272.4, 1579.5,
    1634.2, 1656.3, 1657.9, 1789.5, 1670.8, 1509.5, 8474.6, 7489.2,
    6793.6, 6117., 5574.1, 5141.2, 5084.6, 4745.1, 4413.2, 4102.8,
    4024.7, 3715., 3398.6, 3100.8, 2900.4, 2629.2, 2374., 2144.7,
    1955.8, 1760.8, 1591.2, 1435.2, 1296.2, 1174., 1065.1, 967.76,
    999.48, 897.45, 809.23, 732.77, 670.26, 611.93, 560.11, 518.77,
    476.84, 438.8, 408.48, 380.21, 349.24, 322.71, 296.65, 272.85,
    251.96, 232.04, 213.88, 197.69, 182.41, 168.41, 155.79, 144.05,
    133.31, 123.48, 114.5, 106.21, 98.591, 91.612, 85.156, 79.204,
    73.719, 68.666, 63.975, 59.637, 56.35, 52.545, 49.042, 45.788,
    42.78, 39.992, 37.441, 35.037, 32.8, 30.744, 28.801, 26.986,
    25.297, 23.731, 22.258, 20.883, 19.603, 18.403, 17.295, 16.249,
    15.271, 14.356, 13.501, 12.701, 11.954, 11.254, 10.6, 9.9864,
    9.4118, 8.8745, 8.3714, 7.8997, 7.4578, 7.0446, 6.6573, 6.2949,
    5.9577, 5.6395, 5.3419, 5.063, 4.8037, 4.5608, 4.3452, 4.1364,
    3.9413, 3.7394, 3.562, 3.3932, 3.2325, 3.0789, 2.9318, 2.7898,
    2.6537, 2.5225, 2.3958, 2.2305, 2.1215, 2.0245, 1.9427, 1.8795,
    1.8336, 1.7604, 1.7016, 1.6419, 1.5282, 1.4611, 1.3443, 1.27,
    1.1675, 1.0824, 1.0534, .99833, .95854, .92981, .90887, .89346,
    .88113, .87068, .86102, .85096, .88262, .86151, .83565, .80518,
    .77045, .73736, .74744, .74954, .75773, .82267, .83493, .89402,
    .89725, .93426, .95564, .94045, .94174, .93404, .92035, .90456,
    .88621, .86673, .78117, .7515, .72056, .68822, .65658, .62764,
    .55984, .55598, .57407, .60963, .63763, .66198, .61132, .60972,
    .52496, .50649, .41872, .3964, .32422, .27276, .24048, .23772,
    .2286, .22711, .23999, .32038, .34371, .36621, .38561, .39953,
    .40636, .44913, .42716, .3919, .35477, .33935, .3351, .39746,
    .40993, .49398, .49956, .56157, .54742, .57295, .57386, .55417,
    .50745, .471, .43446, .39102, .34993, .31269, .27888, .24912,
    .22291, .19994, .17972, .16197, .14633, .13252, .12029, .10942,
    .099745, .091118, .083404, .076494, .070292, .064716, .059697,
    .055173, .051093, .047411, .044089, .041092, .038392, .035965,
    .033789, .031846, .030122, .028607, .02729, .026169, .025209,
    .024405, .023766, .023288, .022925, .022716, .022681, .022685,
    .022768, .023133, .023325, .023486, .024004, .024126, .024083,
    .023785, .024023, .023029, .021649, .021108, .019454, .017809,
    .017292, .016635, .017037, .018068, .018977, .018756, .017847,
    .016557, .016142, .014459, .012869, .012381, .010875, .0098701,
    .009285, .0091698, .0091701, .0096145, .010553, .01106, .012613,
    .014362, .015017, .016507, .017741, .01768, .017784, .0171,
    .016357, .016172, .017257, .018978, .020935, .021741, .023567,
    .025183, .025589, .026732, .027648, .028278, .028215, .02856,
    .029015, .029062, .028851, .028497, .027825, .027801, .026523,
    .02487, .022967, .022168, .020194, .018605, .017903, .018439,
    .019697, .020311, .020855, .020057, .018608, .016738, .015963,
    .013844, .011801, .011134, .0097573, .0086007, .0086226,
    .0083721, .0090978, .0097616, .0098426, .011317, .012853, .01447,
    .014657, .015771, .016351, .016079, .014829, .013431, .013185,
    .013207, .01448, .016176, .017971, .018265, .019526, .020455,
    .019797, .019802, .0194, .018176, .017505, .016197, .015339,
    .014401, .013213, .012203, .011186, .010236, .0093288, .0084854,
    .0076837, .0069375, .0062614, .0056628, .0051153, .0046015,
    .0041501, .003752, .0033996, .0030865, .0028077, .0025586,
    .0023355, .0021353, .0019553, .0017931, .0016466, .0015141,
    .0013941, .0012852, .0011862, .0010962, .0010142, 9.3935e-4,
    8.71e-4, 8.0851e-4, 7.5132e-4, 6.9894e-4, 6.5093e-4, 6.0689e-4,
    5.6647e-4, 5.2935e-4, 4.9525e-4, 4.6391e-4, 4.3509e-4, 4.086e-4,
    3.8424e-4, 3.6185e-4, 3.4126e-4, 3.2235e-4, 3.0498e-4, 2.8904e-4,
    2.7444e-4, 2.6106e-4, 2.4883e-4, 2.3766e-4, 2.275e-4, 2.1827e-4,
    2.0992e-4, 2.0239e-4, 1.9563e-4, 1.896e-4, 1.8427e-4, 1.796e-4,
    1.7555e-4, 1.7209e-4, 1.692e-4, 1.6687e-4, 1.6505e-4, 1.6375e-4,
    1.6294e-4, 1.6261e-4, 1.6274e-4, 1.6334e-4, 1.6438e-4, 1.6587e-4,
    1.678e-4, 1.7017e-4, 1.7297e-4, 1.762e-4, 1.7988e-4, 1.8399e-4,
    1.8855e-4, 1.9355e-4, 1.9902e-4, 2.0494e-4, 2.1134e-4, 2.1823e-4,
    2.2561e-4, 2.335e-4, 2.4192e-4, 2.5088e-4, 2.604e-4, 2.705e-4,
    2.8119e-4, 2.9251e-4, 3.0447e-4, 3.171e-4, 3.3042e-4, 3.4447e-4,
    3.5927e-4, 3.7486e-4, 3.9127e-4, 4.0854e-4, 4.267e-4, 4.4579e-4,
    4.6586e-4, 4.8696e-4, 5.0912e-4, 5.324e-4, 5.5685e-4, 5.8253e-4,
    6.0949e-4, 6.378e-4, 6.6753e-4, 6.9873e-4, 7.3149e-4, 7.6588e-4,
    8.0198e-4, 8.3987e-4, 8.7964e-4, 9.2139e-4, 9.6522e-4, .0010112,
    .0010595, .0011102, .0011634, .0012193, .001278, .0013396,
    .0014043, .0014722, .0015436, .0016185, .0016972, .0017799,
    .0018668, .001958, .0020539, .0021547, .0022606, .0023719,
    .002489, .002612, .0027414, .0028775, .0030206, .0031712,
    .0033295, .0034962, .0036716, .0038563, .0040506, .0042553,
    .0044709, .004698, .0049373, .0051894, .0054552, .0057354,
    .006031, .0063427, .0066717, .0070188, .0073854, .0077726,
    .0081816, .0086138, .0090709, .0095543, .010066, .010607,
    .011181, .011789, .012433, .013116, .013842, .014613, .015432,
    .016304, .017233, .018224, .019281, .020394, .021574, .022836,
    .024181, .025594, .027088, .028707, .030401, .032245, .034219,
    .036262, .038539, .040987, .043578, .04641, .04949, .052726,
    .056326, .0602, .064093, .068521, .073278, .077734, .083064,
    .088731, .093885, .1003, .1072, .11365, .12187, .13078, .13989,
    .15095, .16299, .17634, .19116, .20628, .22419, .24386, .26587,
    .28811, .31399, .34321, .36606, .39675, .42742, .44243, .47197,
    .49993, .49027, .51147, .52803, .48931, .49729, .5026, .43854,
    .441, .44766, .43414, .46151, .50029, .55247, .43855, .32115,
    .32607, .3431, .36119, .38029, .41179, .43996, .47144, .51853,
    .55362, .59122, .66338, .69877, .74001, .82923, .86907, .90361,
    1.0025, 1.031, 1.0559, 1.104, 1.1178, 1.1341, 1.1547, 1.351,
    1.4772, 1.4812, 1.4907, 1.512, 1.5442, 1.5853, 1.6358, 1.6963,
    1.7674, 1.8474, 1.9353, 2.0335, 2.143, 2.2592, 2.3853, 2.5217,
    2.6686, 2.8273, 2.9998, 3.183, 3.3868, 3.6109, 3.8564, 4.1159,
    4.4079, 4.7278, 5.0497, 5.3695, 5.758, 6.0834, 6.4976, 6.9312,
    7.38, 7.5746, 7.9833, 8.3791, 8.3956, 8.7501, 9.1067, 9.072,
    9.4649, 9.9112, 10.402, 10.829, 11.605, 12.54, 12.713, 10.443,
    10.825, 11.375, 11.955, 12.623, 13.326, 14.101, 15.041, 15.547,
    16.461, 17.439, 18.716, 19.84, 21.036, 22.642, 23.901, 25.244,
    27.03, 28.411, 29.871, 31.403, 33.147, 34.744, 36.456, 39.239,
    43.605, 45.162, 47.004, 49.093, 51.391, 53.946, 56.673, 59.629,
    63.167, 66.576, 70.254, 74.222, 78.477, 83.034, 87.914, 93.18,
    98.77, 104.74, 111.15, 117.95, 125.23, 133.01, 141.33, 150.21,
    159.71, 169.89, 180.93, 192.54, 204.99, 218.34, 232.65, 248.,
    264.47, 282.14, 301.13, 321.53, 343.48, 367.08, 392.5, 419.88,
    449.4, 481.26, 515.64, 552.79, 592.99, 636.48, 683.61, 734.65,
    789.99, 850.02, 915.14, 985.81, 1062.5, 1147.1, 1237.8, 1336.4,
    1443.2, 1558.9, 1684.2, 1819.2, 1965.2, 2122.6, 2291.7, 2470.8,
    2665.7, 2874.9, 3099.4, 3337.9, 3541., 3813.3, 4111.9, 4439.3,
    4798.9, 5196., 5639.2, 6087.5, 6657.7, 7306.7, 8040.7, 8845.5,
    9702.2, 10670., 11739., 12842., 14141., 15498., 17068., 18729.,
    20557., 22559., 25248., 27664., 30207., 32915., 35611., 38081.,
    40715., 43191., 41651., 42750., 43785., 44353., 44366., 44189.,
    43618., 42862., 41878., 35133., 35215., 36383., 39420., 44055.,
    44155., 45850., 46853., 39197., 38274., 29942., 28553., 21792.,
    21228., 17106., 14955., 18181., 19557., 21427., 23728., 26301.,
    28584., 30775., 32536., 33867., 40089., 39204., 37329., 34452.,
    31373., 33921., 34800., 36043., 44415., 45162., 52181., 50895.,
    54140., 50840., 50468., 48302., 44915., 40910., 36754., 32755.,
    29093., 25860., 22962., 20448., 18247., 16326., 14645., 13165.,
    11861., 10708., 9686.9, 8779.7, 7971.9, 7250.8, 6605.7, 6027.2,
    5507.3, 5039.1, 4616.6, 4234.8, 3889., 3575.4, 3290.5, 3031.3,
    2795.2, 2579.9, 2383.1, 2203.3, 2038.6, 1887.6, 1749.1, 1621.9,
    1505., 1397.4, 1298.3, 1207., 1122.8, 1045., 973.1, 906.64,
    845.16, 788.22, 735.48, 686.57, 641.21, 599.1, 559.99, 523.64,
    489.85, 458.42, 429.16, 401.92, 376.54, 352.88, 330.82, 310.24,
    291.03, 273.09, 256.34, 240.69, 226.05, 212.37, 199.57, 187.59,
    176.37, 165.87, 156.03, 146.82, 138.17, 130.07, 122.47, 115.34,
    108.65, 102.37, 96.473, 90.934, 85.73, 80.84, 76.243, 71.922,
    67.858, 64.034, 60.438, 57.052, 53.866, 50.866, 48.04, 45.379,
    42.872, 40.51, 38.285, 36.188, 34.211, 32.347, 30.588, 28.929,
    27.362, 25.884, 24.489, 23.171, 21.929, 20.755, 19.646, 18.599,
    17.61, 16.677, 15.795, 14.961, 14.174, 13.43, 12.725, 12.06,
    11.431, 10.834, 10.27, 9.7361, 9.2302, 8.7518, 8.2997, 7.8724,
    7.4674, 7.0848, 6.7226, 6.3794, 6.054, 5.745, 5.4525, 5.1752,
    4.9121, 4.6625, 4.4259, 4.2015, 3.9888, 3.7872, 3.5961, 3.4149,
    3.2431, 3.0802, 2.9257, 2.7792, 2.6402, 2.5084, 2.3834, 2.2648,
    2.1522, 2.0455, 1.9441, 1.848, 1.7567, 1.6701, 1.5878, 1.5097,
    1.4356, 1.3651, 1.2981, 1.2345, 1.174, 1.1167, 1.062, 1.0101,
    .96087, .91414, .86986, .82781, .78777, .74971, .71339, .67882,
    .64604, .61473, .58507, .55676, .52987, .5044, .48014, .45715,
    .43527, .41453, .3948, .37609, .35831, .34142, .32524, .30995,
    .29536, .28142, .26807, .25527, .24311, .23166, .22077, .21053,
    .20081, .19143, .18261, .17407, .16603, .15833, .15089, .14385,
    .13707, .13065, .12449, .11865, .11306, .10774, .10266, .097818,
    .093203, .088815, .084641, .080671, .076892, .073296, .069873,
    .066613, .06351, .060555, .05774, .055058, .052504, .050071,
    .047752, .045543, .043438, .041432, .039521, .037699, .035962,
    .034307, .032729, .031225, .029791, .028423, .02712, .025877,
    .024692, .023563, .022485, .021458, .020478, .019543, .018652,
    .017802, .016992, .016219, .015481, .014778, .014107, .013467,
    .012856, .012274, .011718, .011188, .010682, .0102, .0097393,
    .0093001, .008881, .0084812, .0080997, .0077358, .0073885,
    .0070571, .0067409, .0064393, .0061514, .0058768, .0056147,
    .0053647, .0051262, .0048987, .0046816, .0044745, .0042769,
    .0040884, .0039088, .0037373, .0035739, .003418, .0032693,
    .0031277, .0029926, .0028639, .0027413, .0026245, .0025133,
    .0024074, .0023066, .0022108, .0021196, .002033, .0019507,
    .0018726, .0017985, .0017282, .0016617, .0015988, .0015394,
    .0014834, .0014306, .0013811, .0013346, .0012911, .0012506,
    .0012131, .0011784, .0011465, .0011175, .0010912, .0010678,
    .0010472, .0010295, .0010147, .001003, 9.9428e-4, 9.8883e-4,
    9.8673e-4, 9.8821e-4, 9.9343e-4, .0010027, .0010164, .0010348,
    .0010586, .0010882, .0011245, .0011685, .0012145, .0012666,
    .0013095, .0013688, .0014048, .0014663, .0015309, .0015499,
    .0016144, .0016312, .001705, .0017892, .0018499, .0019715,
    .0021102, .0022442, .0024284, .0025893, .0027703, .0029445,
    .0031193, .003346, .0034552, .0036906, .0037584, .0040084,
    .0041934, .0044587, .0047093, .0049759, .0053421, .0055134,
    .0059048, .0058663, .0061036, .0063259, .0059657, .0060653,
    .0060972, .0055539, .0055653, .0055772, .005331, .0054953,
    .0055919, .0058684, .006183, .0066675, .0069808, .0075142,
    .0078536, .0084282, .0089454, .0094625, .0093703, .0095857,
    .0099283, .010063, .010521, .0097778, .0098175, .010379, .010447,
    .0105, .010617, .010706, .01078, .011177, .011212, .011304,
    .011446, .011603, .011816, .012165, .012545, .013069, .013539,
    .01411, .014776, .016103, .017016, .017994, .018978, .01998,
    .021799, .022745, .023681, .024627, .025562, .026992, .027958,
    .029013, .030154, .031402, .03228, .033651, .035272, .037088,
    .039021, .041213, .043597, .045977, .04877, .051809, .054943,
    .058064, .061528, .06537, .069309, .071928, .075752, .079589,
    .083352, .084096, .087497, .090817, .091198, .094966, .099045,
    .10429, .10867, .11518, .12269, .13126, .14087, .15161, .16388,
    .16423, .1759, .18721, .19994, .21275, .22513, .23041, .24231,
    .25299, .25396, .26396, .27696, .27929, .2908, .30595, .31433,
    .3282, .3429, .35944, .37467, .39277, .41245, .43326, .45649,
    .48152, .51897, .54686, .57877, .61263, .64962, .68983, .73945,
    .78619, .83537, .89622, .95002, 1.0067, 1.0742, 1.1355, 1.2007,
    1.2738, 1.347, 1.4254, 1.5094, 1.6009, 1.6976, 1.8019, 1.9148,
    2.0357, 2.166, 2.3066, 2.4579, 2.6208, 2.7966, 2.986, 3.188,
    3.4081, 3.6456, 3.9, 4.1747, 4.4712, 4.7931, 5.1359, 5.5097,
    5.9117, 6.3435, 6.8003, 7.3001, 7.8385, 8.3945, 9.011, 9.6869,
    10.392, 11.18, 12.036, 12.938, 13.944, 14.881, 16.029, 17.255,
    18.574, 19.945, 21.38, 22.9, 24.477, 26.128, 27.87, 29.037,
    30.988, 33.145, 35.506, 37.76, 40.885, 44.487, 48.505, 52.911,
    57.56, 61.964, 67.217, 72.26, 78.343, 85.08, 91.867, 99.435,
    107.68, 116.97, 127.12, 138.32, 150.26, 163.04, 174.81, 189.26,
    205.61, 224.68, 240.98, 261.88, 285.1, 307.58, 334.35, 363.53,
    394.68, 427.85, 458.85, 489.25, 472.87, 486.93, 496.27, 501.52,
    501.57, 497.14, 488.09, 476.32, 393.76, 388.51, 393.42, 414.45,
    455.12, 514.62, 520.38, 547.42, 562.6, 487.47, 480.83, 391.06,
    376.92, 303.7, 295.91, 256.03, 236.73, 280.38, 310.71, 335.53,
    367.88, 401.94, 435.52, 469.13, 497.94, 588.82, 597.94, 597.2,
    588.28, 571.2, 555.75, 603.56, 638.15, 680.75, 801.72, 848.01,
    962.15, 990.06, 1068.1, 1076.2, 1115.3, 1134.2, 1136.6, 1119.1,
    1108.9, 1090.6, 1068.7, 1041.9, 1005.4, 967.98, 927.08, 780.1,
    751.41, 733.12, 742.65, 785.56, 855.16, 852.45, 878.1, 784.59,
    777.81, 765.13, 622.93, 498.09, 474.89, 386.9, 378.48, 336.17,
    322.04, 329.57, 350.5, 383.38, 420.02, 462.39, 499.71, 531.98,
    654.99, 653.43, 639.99, 605.16, 554.16, 504.42, 540.64, 552.33,
    679.46, 699.51, 713.91, 832.17, 919.91, 884.96, 907.57, 846.56,
    818.56, 768.93, 706.71, 642.17, 575.95, 515.38, 459.07, 409.02,
    364.61, 325.46, 291.1, 260.89, 234.39, 211.01, 190.38, 172.11,
    155.91, 141.49, 128.63, 117.13, 106.84, 97.584, 89.262, 81.756,
    74.975, 68.842, 63.28, 58.232, 53.641, 49.46, 45.649, 42.168,
    38.991, 36.078, 33.409, 30.96, 28.71, 26.642, 24.737, 22.985,
    21.37, 19.882, 18.512, 17.242, 16.073, 14.987, 13.984, 13.05,
    12.186, 11.384, 10.637, 9.9436, 9.2988, 8.6991, 8.141, 7.6215,
    7.1378, 6.6872, 6.2671, 5.8754, 5.51, 5.1691, 4.851, 4.5539,
    4.2764, 4.0169, 3.7742, 3.5472, 3.3348, 3.1359, 2.9495, 2.7749,
    2.6113, 2.4578, 2.3139, 2.1789, 2.0523, 1.9334, 1.8219, 1.7171,
    1.6188, 1.5263, 1.4395, 1.3579, 1.2812, 1.209, 1.1411, 1.0773,
    1.0171, .96048, .90713, .85684, .80959, .76495, .72282, .68309,
    .64563, .61035, .57707, .54573, .51622, .48834, .46199, .43709,
    .41359, .39129, .37034, .35064, .33198, .31442, .29784, .28218,
    .26732, .25337, .24017, .22774, .21601, .20479, .19426
  };
 
  static const double co2260[2001] =
    { 5.7971e-5, 6.0733e-5, 6.3628e-5, 6.6662e-5,
    6.9843e-5, 7.3176e-5, 7.6671e-5, 8.0334e-5, 8.4175e-5, 8.8201e-5,
    9.2421e-5, 9.6846e-5, 1.0149e-4, 1.0635e-4, 1.1145e-4, 1.1679e-4,
    1.224e-4, 1.2828e-4, 1.3444e-4, 1.409e-4, 1.4768e-4, 1.5479e-4,
    1.6224e-4, 1.7006e-4, 1.7826e-4, 1.8685e-4, 1.9587e-4, 2.0532e-4,
    2.1524e-4, 2.2565e-4, 2.3656e-4, 2.48e-4, 2.6001e-4, 2.7261e-4,
    2.8582e-4, 2.9968e-4, 3.1422e-4, 3.2948e-4, 3.4548e-4, 3.6228e-4,
    3.799e-4, 3.9838e-4, 4.1778e-4, 4.3814e-4, 4.595e-4, 4.8191e-4,
    5.0543e-4, 5.3012e-4, 5.5603e-4, 5.8321e-4, 6.1175e-4, 6.417e-4,
    6.7314e-4, 7.0614e-4, 7.4078e-4, 7.7714e-4, 8.1531e-4, 8.5538e-4,
    8.9745e-4, 9.4162e-4, 9.8798e-4, .0010367, .0010878, .0011415,
    .0011978, .001257, .0013191, .0013844, .001453, .0015249,
    .0016006, .00168, .0017634, .001851, .001943, .0020397, .0021412,
    .0022479, .00236, .0024778, .0026015, .0027316, .0028682,
    .0030117, .0031626, .0033211, .0034877, .0036628, .0038469,
    .0040403, .0042436, .0044574, .004682, .0049182, .0051665,
    .0054276, .0057021, .0059907, .0062942, .0066133, .0069489,
    .0073018, .0076729, .0080632, .0084738, .0089056, .0093599,
    .0098377, .01034, .010869, .011426, .012011, .012627, .013276,
    .013958, .014676, .015431, .016226, .017063, .017944, .018872,
    .019848, .020876, .021958, .023098, .024298, .025561, .026892,
    .028293, .029769, .031323, .032961, .034686, .036503, .038418,
    .040435, .042561, .044801, .047161, .049649, .052271, .055035,
    .057948, .061019, .064256, .06767, .07127, .075066, .079069,
    .083291, .087744, .092441, .097396, .10262, .10814, .11396,
    .1201, .12658, .13342, .14064, .14826, .1563, .1648, .17376,
    .18323, .19324, .2038, .21496, .22674, .23919, .25234, .26624,
    .28093, .29646, .31287, .33021, .34855, .36794, .38844, .41012,
    .43305, .45731, .48297, .51011, .53884, .56924, .60141, .63547,
    .67152, .70969, .75012, .79292, .83826, .8863, .93718, .99111,
    1.0482, 1.1088, 1.173, 1.2411, 1.3133, 1.3898, 1.471, 1.5571,
    1.6485, 1.7455, 1.8485, 1.9577, 2.0737, 2.197, 2.3278, 2.4668,
    2.6145, 2.7715, 2.9383, 3.1156, 3.3042, 3.5047, 3.7181, 3.9451,
    4.1866, 4.4437, 4.7174, 5.0089, 5.3192, 5.65, 6.0025, 6.3782,
    6.7787, 7.206, 7.6617, 8.1479, 8.6669, 9.221, 9.8128, 10.445,
    11.12, 11.843, 12.615, 13.441, 14.325, 15.271, 16.283, 17.367,
    18.529, 19.776, 21.111, 22.544, 24.082, 25.731, 27.504, 29.409,
    31.452, 33.654, 36.024, 38.573, 41.323, 44.29, 47.492, 50.951,
    54.608, 58.588, 62.929, 67.629, 72.712, 78.226, 84.207, 90.699,
    97.749, 105.42, 113.77, 122.86, 132.78, 143.61, 155.44, 168.33,
    182.48, 198.01, 214.87, 233.39, 253.86, 276.34, 300.3, 327.28,
    356.89, 389.48, 422.29, 458.99, 501.39, 548.13, 595.62, 652.74,
    716.54, 784.57, 866.78, 960.59, 1062.8, 1072.5, 1189.5, 1319.4,
    1467.6, 1630.2, 1813.7, 2016.9, 2253., 2515.3, 2773.5, 3092.8,
    3444.4, 3720.4, 4104.3, 4527.5, 4645.9, 5021.7, 5462.2, 5597.,
    6110.6, 6732.5, 7513.8, 8270.6, 9640.6, 11487., 2796.1, 2680.1,
    2441.6, 2404.2, 2334.8, 2215.2, 1642.5, 1477.9, 1328.1, 1223.5,
    843.34, 766.96, 831.65, 834.84, 774.85, 1156.3, 1275.6, 1366.1,
    1795.6, 1885., 1936.5, 1953.4, 2154.4, 2002.7, 1789.8, 10381.,
    9040., 8216.5, 7384.7, 6721.9, 6187.7, 6143.8, 5703.9, 5276.6,
    4873.1, 4736., 4325.3, 3927., 3554.1, 3286.1, 2950.1, 2642.4,
    2368.7, 2138.9, 1914., 1719.6, 1543.9, 1388.6, 1252.1, 1132.2,
    1024.1, 1025.4, 920.58, 829.59, 750.54, 685.01, 624.25, 570.14,
    525.81, 481.85, 441.95, 408.71, 377.23, 345.86, 318.51, 292.26,
    268.34, 247.04, 227.14, 209.02, 192.69, 177.59, 163.78, 151.26,
    139.73, 129.19, 119.53, 110.7, 102.57, 95.109, 88.264, 81.948,
    76.13, 70.768, 65.827, 61.251, 57.022, 53.495, 49.824, 46.443,
    43.307, 40.405, 37.716, 35.241, 32.923, 30.77, 28.78, 26.915,
    25.177, 23.56, 22.059, 20.654, 19.345, 18.126, 16.988, 15.93,
    14.939, 14.014, 13.149, 12.343, 11.589, 10.884, 10.225, 9.6093,
    9.0327, 8.4934, 7.9889, 7.5166, 7.0744, 6.6604, 6.2727, 5.9098,
    5.5701, 5.2529, 4.955, 4.676, 4.4148, 4.171, 3.9426, 3.7332,
    3.5347, 3.3493, 3.1677, 3.0025, 2.8466, 2.6994, 2.5601, 2.4277,
    2.3016, 2.1814, 2.0664, 1.9564, 1.8279, 1.7311, 1.6427, 1.5645,
    1.4982, 1.443, 1.374, 1.3146, 1.2562, 1.17, 1.1105, 1.0272,
    .96863, .89718, .83654, .80226, .75908, .72431, .69573, .67174,
    .65126, .63315, .61693, .60182, .58715, .59554, .57649, .55526,
    .53177, .50622, .48176, .4813, .47642, .47492, .50273, .50293,
    .52687, .52239, .53419, .53814, .52626, .52211, .51492, .50622,
    .49746, .48841, .4792, .43534, .41999, .40349, .38586, .36799,
    .35108, .31089, .30803, .3171, .33599, .35041, .36149, .32924,
    .32462, .27309, .25961, .20922, .19504, .15683, .13098, .11588,
    .11478, .11204, .11363, .12135, .16423, .17785, .19094, .20236,
    .21084, .2154, .24108, .22848, .20871, .18797, .17963, .17834,
    .21552, .22284, .26945, .27052, .30108, .28977, .29772, .29224,
    .27658, .24956, .22777, .20654, .18392, .16338, .1452, .12916,
    .1152, .10304, .092437, .083163, .075031, .067878, .061564,
    .055976, .051018, .046609, .042679, .03917, .036032, .033223,
    .030706, .02845, .026428, .024617, .022998, .021554, .02027,
    .019136, .018141, .017278, .016541, .015926, .015432, .015058,
    .014807, .014666, .014635, .014728, .014947, .01527, .015728,
    .016345, .017026, .017798, .018839, .019752, .020636, .021886,
    .022695, .02327, .023478, .024292, .023544, .022222, .021932,
    .020052, .018143, .017722, .017031, .017782, .01938, .020734,
    .020476, .019255, .017477, .016878, .014617, .012489, .011765,
    .0099077, .0086446, .0079446, .0078644, .0079763, .008671,
    .01001, .0108, .012933, .015349, .016341, .018484, .020254,
    .020254, .020478, .019591, .018595, .018385, .019913, .022254,
    .024847, .025809, .028053, .029924, .030212, .031367, .03222,
    .032739, .032537, .03286, .033344, .033507, .033499, .033339,
    .032809, .033041, .031723, .029837, .027511, .026603, .024032,
    .021914, .020948, .021701, .023425, .024259, .024987, .023818,
    .021768, .019223, .018144, .015282, .012604, .01163, .0097907,
    .008336, .0082473, .0079582, .0088077, .009779, .010129, .012145,
    .014378, .016761, .01726, .018997, .019998, .019809, .01819,
    .016358, .016099, .01617, .017939, .020223, .022521, .02277,
    .024279, .025247, .024222, .023989, .023224, .021493, .020362,
    .018596, .017309, .015975, .014466, .013171, .011921, .01078,
    .0097229, .0087612, .0078729, .0070682, .0063494, .0057156,
    .0051459, .0046273, .0041712, .0037686, .0034119, .003095,
    .0028126, .0025603, .0023342, .0021314, .0019489, .0017845,
    .001636, .0015017, .00138, .0012697, .0011694, .0010782,
    9.9507e-4, 9.1931e-4, 8.5013e-4, 7.869e-4, 7.2907e-4, 6.7611e-4,
    6.2758e-4, 5.8308e-4, 5.4223e-4, 5.0473e-4, 4.7027e-4, 4.3859e-4,
    4.0946e-4, 3.8265e-4, 3.5798e-4, 3.3526e-4, 3.1436e-4, 2.9511e-4,
    2.7739e-4, 2.6109e-4, 2.4609e-4, 2.3229e-4, 2.1961e-4, 2.0797e-4,
    1.9729e-4, 1.875e-4, 1.7855e-4, 1.7038e-4, 1.6294e-4, 1.5619e-4,
    1.5007e-4, 1.4456e-4, 1.3961e-4, 1.3521e-4, 1.3131e-4, 1.2789e-4,
    1.2494e-4, 1.2242e-4, 1.2032e-4, 1.1863e-4, 1.1733e-4, 1.1641e-4,
    1.1585e-4, 1.1565e-4, 1.158e-4, 1.1629e-4, 1.1712e-4, 1.1827e-4,
    1.1976e-4, 1.2158e-4, 1.2373e-4, 1.262e-4, 1.2901e-4, 1.3214e-4,
    1.3562e-4, 1.3944e-4, 1.4361e-4, 1.4814e-4, 1.5303e-4, 1.5829e-4,
    1.6394e-4, 1.6999e-4, 1.7644e-4, 1.8332e-4, 1.9063e-4, 1.984e-4,
    2.0663e-4, 2.1536e-4, 2.246e-4, 2.3436e-4, 2.4468e-4, 2.5558e-4,
    2.6708e-4, 2.7921e-4, 2.92e-4, 3.0548e-4, 3.1968e-4, 3.3464e-4,
    3.5039e-4, 3.6698e-4, 3.8443e-4, 4.0281e-4, 4.2214e-4, 4.4248e-4,
    4.6389e-4, 4.864e-4, 5.1009e-4, 5.3501e-4, 5.6123e-4, 5.888e-4,
    6.1781e-4, 6.4833e-4, 6.8043e-4, 7.142e-4, 7.4973e-4, 7.8711e-4,
    8.2644e-4, 8.6783e-4, 9.1137e-4, 9.5721e-4, .0010054, .0010562,
    .0011096, .0011659, .0012251, .0012875, .0013532, .0014224,
    .0014953, .001572, .0016529, .0017381, .0018279, .0019226,
    .0020224, .0021277, .0022386, .0023557, .0024792, .0026095,
    .002747, .0028921, .0030453, .0032071, .003378, .0035586,
    .0037494, .003951, .0041642, .0043897, .0046282, .0048805,
    .0051476, .0054304, .00573, .0060473, .0063837, .0067404,
    .0071188, .0075203, .0079466, .0083994, .0088806, .0093922,
    .0099366, .010516, .011134, .011792, .012494, .013244, .014046,
    .014898, .015808, .016781, .017822, .018929, .020108, .02138,
    .022729, .02419, .02576, .027412, .029233, .031198, .033301,
    .035594, .038092, .040767, .04372, .046918, .050246, .053974,
    .058009, .061976, .066586, .071537, .076209, .081856, .087998,
    .093821, .10113, .10913, .11731, .12724, .13821, .15025, .1639,
    .17807, .19472, .21356, .23496, .25758, .28387, .31389, .34104,
    .37469, .40989, .43309, .46845, .5042, .5023, .52981, .55275,
    .51075, .51976, .52457, .44779, .44721, .4503, .4243, .45244,
    .49491, .55399, .39021, .24802, .2501, .2618, .27475, .28879,
    .31317, .33643, .36257, .4018, .43275, .46525, .53333, .56599,
    .60557, .70142, .74194, .77736, .88567, .91182, .93294, .98407,
    .98772, .99176, .9995, 1.2405, 1.3602, 1.338, 1.3255, 1.3267,
    1.3404, 1.3634, 1.3967, 1.4407, 1.4961, 1.5603, 1.6328, 1.7153,
    1.8094, 1.9091, 2.018, 2.1367, 2.264, 2.4035, 2.5562, 2.7179,
    2.9017, 3.1052, 3.3304, 3.5731, 3.8488, 4.1553, 4.4769, 4.7818,
    5.1711, 5.5204, 5.9516, 6.4097, 6.8899, 7.1118, 7.5469, 7.9735,
    7.9511, 8.3014, 8.6418, 8.4757, 8.8256, 9.2294, 9.6923, 10.033,
    10.842, 11.851, 11.78, 8.8435, 9.1381, 9.5956, 10.076, 10.629,
    11.22, 11.883, 12.69, 13.163, 13.974, 14.846, 16.027, 17.053,
    18.148, 19.715, 20.907, 22.163, 23.956, 25.235, 26.566, 27.94,
    29.576, 30.956, 32.432, 35.337, 39.911, 41.128, 42.625, 44.386,
    46.369, 48.619, 51.031, 53.674, 56.825, 59.921, 63.286, 66.929,
    70.859, 75.081, 79.618, 84.513, 89.739, 95.335, 101.35, 107.76,
    114.63, 121.98, 129.87, 138.3, 147.34, 157.04, 167.56, 178.67,
    190.61, 203.43, 217.19, 231.99, 247.88, 264.98, 283.37, 303.17,
    324.49, 347.47, 372.25, 398.98, 427.85, 459.06, 492.8, 529.31,
    568.89, 611.79, 658.35, 708.91, 763.87, 823.65, 888.72, 959.58,
    1036.8, 1121.8, 1213.9, 1314.3, 1423.8, 1543., 1672.8, 1813.4,
    1966.1, 2131.4, 2309.5, 2499.3, 2705., 2925.7, 3161.6, 3411.3,
    3611.5, 3889.2, 4191.1, 4519.3, 4877.9, 5272.9, 5712.9, 6142.7,
    6719.6, 7385., 8145., 8977.7, 9831.9, 10827., 11934., 13063.,
    14434., 15878., 17591., 19435., 21510., 23835., 26835., 29740.,
    32878., 36305., 39830., 43273., 46931., 50499., 49586., 51598.,
    53429., 54619., 55081., 55102., 54485., 53487., 52042., 42689.,
    42607., 44020., 47994., 54169., 53916., 55808., 56642., 46049.,
    44243., 32929., 30658., 21963., 20835., 15962., 13679., 17652.,
    19680., 22388., 25625., 29184., 32520., 35720., 38414., 40523.,
    49228., 48173., 45678., 41768., 37600., 41313., 42654., 44465.,
    55736., 56630., 65409., 63308., 66572., 61845., 60379., 56777.,
    51920., 46601., 41367., 36529., 32219., 28470., 25192., 22362.,
    19907., 17772., 15907., 14273., 12835., 11567., 10445., 9450.2,
    8565.1, 7776., 7070.8, 6439.2, 5872.3, 5362.4, 4903., 4488.3,
    4113.4, 3773.8, 3465.8, 3186.1, 2931.7, 2700.1, 2488.8, 2296.,
    2119.8, 1958.6, 1810.9, 1675.6, 1551.4, 1437.3, 1332.4, 1236.,
    1147.2, 1065.3, 989.86, 920.22, 855.91, 796.48, 741.53, 690.69,
    643.62, 600.02, 559.6, 522.13, 487.35, 455.06, 425.08, 397.21,
    371.3, 347.2, 324.78, 303.9, 284.46, 266.34, 249.45, 233.7,
    219.01, 205.3, 192.5, 180.55, 169.38, 158.95, 149.2, 140.07,
    131.54, 123.56, 116.09, 109.09, 102.54, 96.405, 90.655, 85.266,
    80.213, 75.475, 71.031, 66.861, 62.948, 59.275, 55.827, 52.587,
    49.544, 46.686, 43.998, 41.473, 39.099, 36.867, 34.768, 32.795,
    30.939, 29.192, 27.546, 25.998, 24.539, 23.164, 21.869, 20.65,
    19.501, 18.419, 17.399, 16.438, 15.532, 14.678, 13.874, 13.115,
    12.4, 11.726, 11.088, 10.488, 9.921, 9.3846, 8.8784, 8.3996,
    7.9469, 7.5197, 7.1174, 6.738, 6.379, 6.0409, 5.7213, 5.419,
    5.1327, 4.8611, 4.6046, 4.3617, 4.1316, 3.9138, 3.7077, 3.5125,
    3.3281, 3.1536, 2.9885, 2.8323, 2.6846, 2.5447, 2.4124, 2.2871,
    2.1686, 2.0564, 1.9501, 1.8495, 1.7543, 1.6641, 1.5787, 1.4978,
    1.4212, 1.3486, 1.2799, 1.2147, 1.1529, 1.0943, 1.0388, .98602,
    .93596, .8886, .84352, .80078, .76029, .722, .68585, .65161,
    .61901, .58808, .55854, .53044, .5039, .47853, .45459, .43173,
    .41008, .38965, .37021, .35186, .33444, .31797, .30234, .28758,
    .2736, .26036, .24764, .2357, .22431, .21342, .20295, .19288,
    .18334, .17444, .166, .15815, .15072, .14348, .13674, .13015,
    .12399, .11807, .11231, .10689, .10164, .096696, .091955,
    .087476, .083183, .079113, .075229, .071536, .068026, .064698,
    .06154, .058544, .055699, .052997, .050431, .047993, .045676,
    .043475, .041382, .039392, .037501, .035702, .033991, .032364,
    .030817, .029345, .027945, .026613, .025345, .024139, .022991,
    .021899, .02086, .019871, .018929, .018033, .01718, .016368,
    .015595, .014859, .014158, .013491, .012856, .012251, .011675,
    .011126, .010604, .010107, .0096331, .009182, .0087523, .0083431,
    .0079533, .0075821, .0072284, .0068915, .0065706, .0062649,
    .0059737, .0056963, .005432, .0051802, .0049404, .0047118,
    .0044941, .0042867, .0040891, .0039009, .0037216, .0035507,
    .003388, .0032329, .0030852, .0029445, .0028105, .0026829,
    .0025613, .0024455, .0023353, .0022303, .0021304, .0020353,
    .0019448, .0018587, .0017767, .0016988, .0016247, .0015543,
    .0014874, .0014238, .0013635, .0013062, .0012519, .0012005,
    .0011517, .0011057, .0010621, .001021, 9.8233e-4, 9.4589e-4,
    9.1167e-4, 8.7961e-4, 8.4964e-4, 8.2173e-4, 7.9582e-4, 7.7189e-4,
    7.499e-4, 7.2983e-4, 7.1167e-4, 6.9542e-4, 6.8108e-4, 6.6866e-4,
    6.5819e-4, 6.4971e-4, 6.4328e-4, 6.3895e-4, 6.3681e-4, 6.3697e-4,
    6.3956e-4, 6.4472e-4, 6.5266e-4, 6.6359e-4, 6.778e-4, 6.9563e-4,
    7.1749e-4, 7.4392e-4, 7.7556e-4, 8.1028e-4, 8.4994e-4, 8.8709e-4,
    9.3413e-4, 9.6953e-4, .0010202, .0010738, .0010976, .0011507,
    .0011686, .0012264, .001291, .0013346, .0014246, .0015293,
    .0016359, .0017824, .0019255, .0020854, .002247, .0024148,
    .0026199, .0027523, .0029704, .0030702, .0033047, .0035013,
    .0037576, .0040275, .0043089, .0046927, .0049307, .0053486,
    .0053809, .0056699, .0059325, .0055488, .005634, .0056392,
    .004946, .0048855, .0048208, .0044386, .0045498, .0046377,
    .0048939, .0052396, .0057324, .0060859, .0066906, .0071148,
    .0077224, .0082687, .008769, .0084471, .008572, .0087729,
    .008775, .0090742, .0080704, .0080288, .0085747, .0086087,
    .0086408, .0088752, .0089381, .0089757, .0093532, .0092824,
    .0092566, .0092645, .0092735, .009342, .0095806, .0097991,
    .010213, .010611, .011129, .011756, .013237, .01412, .015034,
    .015936, .01682, .018597, .019315, .019995, .020658, .021289,
    .022363, .022996, .023716, .024512, .025434, .026067, .027118,
    .028396, .029865, .031442, .033253, .03525, .037296, .039701,
    .042356, .045154, .048059, .051294, .054893, .058636, .061407,
    .065172, .068974, .072676, .073379, .076547, .079556, .079134,
    .082308, .085739, .090192, .09359, .099599, .10669, .11496,
    .1244, .13512, .14752, .14494, .15647, .1668, .17863, .19029,
    .20124, .20254, .21179, .21982, .21625, .22364, .23405, .23382,
    .2434, .25708, .26406, .27621, .28909, .30395, .31717, .33271,
    .3496, .36765, .38774, .40949, .446, .46985, .49846, .5287, .562,
    .59841, .64598, .68834, .7327, .78978, .8373, .88708, .94744,
    1.0006, 1.0574, 1.1215, 1.1856, 1.2546, 1.3292, 1.4107, 1.4974,
    1.5913, 1.6931, 1.8028, 1.9212, 2.0492, 2.1874, 2.3365, 2.4978,
    2.6718, 2.8588, 3.062, 3.2818, 3.5188, 3.7752, 4.0527, 4.3542,
    4.6782, 5.0312, 5.4123, 5.8246, 6.2639, 6.7435, 7.2636, 7.8064,
    8.4091, 9.0696, 9.7677, 10.548, 11.4, 12.309, 13.324, 14.284,
    15.445, 16.687, 18.019, 19.403, 20.847, 22.366, 23.925, 25.537,
    27.213, 28.069, 29.864, 31.829, 33.988, 35.856, 38.829, 42.321,
    46.319, 50.606, 55.126, 59.126, 64.162, 68.708, 74.615, 81.176,
    87.739, 95.494, 103.83, 113.38, 123.99, 135.8, 148.7, 162.58,
    176.32, 192.6, 211.47, 232.7, 252.64, 277.41, 305.38, 333.44,
    366.42, 402.66, 442.14, 484.53, 526.42, 568.15, 558.78, 582.6,
    600.98, 613.94, 619.44, 618.24, 609.84, 595.96, 484.86, 475.59,
    478.49, 501.56, 552.19, 628.44, 630.39, 658.92, 671.96, 562.7,
    545.88, 423.43, 400.14, 306.59, 294.13, 246.8, 226.51, 278.21,
    314.39, 347.22, 389.13, 433.16, 477.48, 521.67, 560.54, 683.6,
    696.37, 695.91, 683.1, 658.24, 634.89, 698.85, 742.87, 796.66,
    954.49, 1009.5, 1150.5, 1179.1, 1267.9, 1272.4, 1312.7, 1330.4,
    1331.6, 1315.8, 1308.3, 1293.3, 1274.6, 1249.5, 1213.2, 1172.1,
    1124.4, 930.33, 893.36, 871.27, 883.54, 940.76, 1036., 1025.6,
    1053.1, 914.51, 894.15, 865.03, 670.63, 508.41, 475.15, 370.85,
    361.06, 319.38, 312.75, 331.87, 367.13, 415., 467.94, 525.49,
    578.41, 624.66, 794.82, 796.97, 780.29, 736.49, 670.18, 603.75,
    659.67, 679.8, 857.12, 884.05, 900.65, 1046.1, 1141.9, 1083.,
    1089.2, 1e3, 947.08, 872.31, 787.91, 704.75, 624.93, 553.68,
    489.91, 434.21, 385.64, 343.3, 306.42, 274.18, 245.94, 221.11,
    199.23, 179.88, 162.73, 147.48, 133.88, 121.73, 110.86, 101.1,
    92.323, 84.417, 77.281, 70.831, 64.991, 59.694, 54.884, 50.509,
    46.526, 42.893, 39.58, 36.549, 33.776, 31.236, 28.907, 26.77,
    24.805, 23., 21.339, 19.81, 18.404, 17.105, 15.909, 14.801,
    13.778, 12.83, 11.954, 11.142, 10.389, 9.691, 9.0434, 8.4423,
    7.8842, 7.3657, 6.8838, 6.4357, 6.0189, 5.6308, 5.2696, 4.9332,
    4.6198, 4.3277, 4.0553, 3.8012, 3.5639, 3.3424, 3.1355, 2.9422,
    2.7614, 2.5924, 2.4343, 2.2864, 2.148, 2.0184, 1.8971, 1.7835,
    1.677, 1.5773, 1.4838, 1.3961, 1.3139, 1.2369, 1.1645, 1.0966,
    1.0329, .97309, .91686, .86406, .81439, .76767, .72381, .68252,
    .64359, .60695, .57247, .54008, .50957, .48092, .45401, .42862,
    .40465, .38202, .36072, .34052, .3216, .30386, .28711, .27135,
    .25651, .24252, .2293, .21689, .20517, .19416, .18381, .17396,
    .16469
  };
 
  static const double co2230[2001] =
    { 2.743e-5, 2.8815e-5, 3.027e-5, 3.1798e-5,
    3.3405e-5, 3.5094e-5, 3.6869e-5, 3.8734e-5, 4.0694e-5, 4.2754e-5,
    4.492e-5, 4.7196e-5, 4.9588e-5, 5.2103e-5, 5.4747e-5, 5.7525e-5,
    6.0446e-5, 6.3516e-5, 6.6744e-5, 7.0137e-5, 7.3704e-5, 7.7455e-5,
    8.1397e-5, 8.5543e-5, 8.9901e-5, 9.4484e-5, 9.9302e-5, 1.0437e-4,
    1.097e-4, 1.153e-4, 1.2119e-4, 1.2738e-4, 1.3389e-4, 1.4074e-4,
    1.4795e-4, 1.5552e-4, 1.6349e-4, 1.7187e-4, 1.8068e-4, 1.8995e-4,
    1.997e-4, 2.0996e-4, 2.2075e-4, 2.321e-4, 2.4403e-4, 2.5659e-4,
    2.698e-4, 2.837e-4, 2.9832e-4, 3.137e-4, 3.2988e-4, 3.4691e-4,
    3.6483e-4, 3.8368e-4, 4.0351e-4, 4.2439e-4, 4.4635e-4, 4.6947e-4,
    4.9379e-4, 5.1939e-4, 5.4633e-4, 5.7468e-4, 6.0452e-4, 6.3593e-4,
    6.69e-4, 7.038e-4, 7.4043e-4, 7.79e-4, 8.1959e-4, 8.6233e-4,
    9.0732e-4, 9.5469e-4, .0010046, .0010571, .0011124, .0011706,
    .0012319, .0012964, .0013644, .001436, .0015114, .0015908,
    .0016745, .0017625, .0018553, .0019531, .002056, .0021645,
    .0022788, .0023992, .002526, .0026596, .0028004, .0029488,
    .0031052, .0032699, .0034436, .0036265, .0038194, .0040227,
    .0042369, .0044628, .0047008, .0049518, .0052164, .0054953,
    .0057894, .0060995, .0064265, .0067713, .007135, .0075184,
    .0079228, .0083494, .0087993, .0092738, .0097745, .010303,
    .01086, .011448, .012068, .012722, .013413, .014142, .014911,
    .015723, .01658, .017484, .018439, .019447, .020511, .021635,
    .022821, .024074, .025397, .026794, .02827, .029829, .031475,
    .033215, .035052, .036994, .039045, .041213, .043504, .045926,
    .048485, .05119, .05405, .057074, .060271, .063651, .067225,
    .071006, .075004, .079233, .083708, .088441, .093449, .098749,
    .10436, .11029, .11657, .12322, .13026, .13772, .14561, .15397,
    .16282, .1722, .18214, .19266, .20381, .21563, .22816, .24143,
    .2555, .27043, .28625, .30303, .32082, .3397, .35972, .38097,
    .40352, .42746, .45286, .47983, .50847, .53888, .57119, .6055,
    .64196, .6807, .72187, .76564, .81217, .86165, .91427, .97025,
    1.0298, 1.0932, 1.1606, 1.2324, 1.3088, 1.3902, 1.477, 1.5693,
    1.6678, 1.7727, 1.8845, 2.0038, 2.131, 2.2666, 2.4114, 2.5659,
    2.7309, 2.907, 3.0951, 3.2961, 3.5109, 3.7405, 3.986, 4.2485,
    4.5293, 4.8299, 5.1516, 5.4961, 5.8651, 6.2605, 6.6842, 7.1385,
    7.6256, 8.1481, 8.7089, 9.3109, 9.9573, 10.652, 11.398, 12.2,
    13.063, 13.992, 14.99, 16.064, 17.222, 18.469, 19.813, 21.263,
    22.828, 24.516, 26.34, 28.31, 30.437, 32.738, 35.226, 37.914,
    40.824, 43.974, 47.377, 51.061, 55.011, 59.299, 63.961, 69.013,
    74.492, 80.444, 86.919, 93.836, 101.23, 109.25, 117.98, 127.47,
    137.81, 149.07, 161.35, 174.75, 189.42, 205.49, 223.02, 242.26,
    263.45, 286.75, 311.94, 340.01, 370.86, 404.92, 440.44, 480.27,
    525.17, 574.71, 626.22, 686.8, 754.38, 827.07, 913.38, 1011.7,
    1121.5, 1161.6, 1289.5, 1432.2, 1595.4, 1777., 1983.3, 2216.1,
    2485.7, 2788.3, 3101.5, 3481., 3902.1, 4257.1, 4740., 5272.8,
    5457.9, 5946.2, 6505.3, 6668.4, 7302.4, 8061.6, 9015.8, 9908.3,
    11613., 13956., 3249.6, 3243., 2901.5, 2841.3, 2729.6, 2558.2,
    1797.8, 1583.2, 1386., 1233.5, 787.74, 701.46, 761.66, 767.21,
    722.83, 1180.6, 1332.1, 1461.6, 2032.9, 2166., 2255.9, 2294.7,
    2587.2, 2396.5, 2122.4, 12553., 10784., 9832.5, 8827.3, 8029.1,
    7377.9, 7347.1, 6783.8, 6239.1, 5721.1, 5503., 4975.1, 4477.8,
    4021.3, 3676.8, 3275.3, 2914.9, 2597.4, 2328.2, 2075.4, 1857.6,
    1663.6, 1493.3, 1343.8, 1213.3, 1095.6, 1066.5, 958.91, 865.15,
    783.31, 714.35, 650.77, 593.98, 546.2, 499.9, 457.87, 421.75,
    387.61, 355.25, 326.62, 299.7, 275.21, 253.17, 232.83, 214.31,
    197.5, 182.08, 167.98, 155.12, 143.32, 132.5, 122.58, 113.48,
    105.11, 97.415, 90.182, 83.463, 77.281, 71.587, 66.341, 61.493,
    57.014, 53.062, 49.21, 45.663, 42.38, 39.348, 36.547, 33.967,
    31.573, 29.357, 27.314, 25.415, 23.658, 22.03, 20.524, 19.125,
    17.829, 16.627, 15.511, 14.476, 13.514, 12.618, 11.786, 11.013,
    10.294, 9.6246, 9.0018, 8.4218, 7.8816, 7.3783, 6.9092, 6.4719,
    6.0641, 5.6838, 5.3289, 4.998, 4.6893, 4.4014, 4.1325, 3.8813,
    3.6469, 3.4283, 3.2241, 3.035, 2.8576, 2.6922, 2.5348, 2.3896,
    2.2535, 2.1258, 2.0059, 1.8929, 1.7862, 1.6854, 1.5898, 1.4992,
    1.4017, 1.3218, 1.2479, 1.1809, 1.1215, 1.0693, 1.0116, .96016,
    .9105, .84859, .80105, .74381, .69982, .65127, .60899, .57843,
    .54592, .51792, .49336, .47155, .45201, .43426, .41807, .40303,
    .38876, .3863, .37098, .35492, .33801, .32032, .30341, .29874,
    .29193, .28689, .29584, .29155, .29826, .29195, .29287, .2904,
    .28199, .27709, .27162, .26622, .26133, .25676, .25235, .23137,
    .22365, .21519, .20597, .19636, .18699, .16485, .16262, .16643,
    .17542, .18198, .18631, .16759, .16338, .13505, .1267, .10053,
    .092554, .074093, .062159, .055523, .054849, .05401, .05528,
    .058982, .07952, .08647, .093244, .099285, .10393, .10661,
    .12072, .11417, .10396, .093265, .089137, .088909, .10902,
    .11277, .13625, .13565, .14907, .14167, .1428, .13744, .12768,
    .11382, .10244, .091686, .08109, .071739, .063616, .056579,
    .050504, .045251, .040689, .036715, .033237, .030181, .027488,
    .025107, .022998, .021125, .01946, .017979, .016661, .015489,
    .014448, .013526, .012712, .011998, .011375, .010839, .010384,
    .010007, .0097053, .0094783, .0093257, .0092489, .0092504,
    .0093346, .0095077, .0097676, .01012, .01058, .011157, .011844,
    .012672, .013665, .014766, .015999, .017509, .018972, .020444,
    .022311, .023742, .0249, .025599, .026981, .026462, .025143,
    .025066, .022814, .020458, .020026, .019142, .020189, .022371,
    .024163, .023728, .02199, .019506, .018591, .015576, .012784,
    .011744, .0094777, .0079148, .0070652, .006986, .0071758,
    .008086, .0098025, .01087, .013609, .016764, .018137, .021061,
    .023498, .023576, .023965, .022828, .021519, .021283, .023364,
    .026457, .029782, .030856, .033486, .035515, .035543, .036558,
    .037198, .037472, .037045, .037284, .03777, .038085, .038366,
    .038526, .038282, .038915, .037697, .035667, .032941, .031959,
    .028692, .025918, .024596, .025592, .027873, .028935, .02984,
    .028148, .025305, .021912, .020454, .016732, .013357, .01205,
    .009731, .0079881, .0077704, .0074387, .0083895, .0096776,
    .010326, .01293, .015955, .019247, .020145, .02267, .024231,
    .024184, .022131, .019784, .01955, .01971, .022119, .025116,
    .027978, .028107, .029808, .030701, .029164, .028551, .027286,
    .024946, .023259, .020982, .019221, .017471, .015643, .014074,
    .01261, .011301, .010116, .0090582, .0081036, .0072542, .0065034,
    .0058436, .0052571, .0047321, .0042697, .0038607, .0034977,
    .0031747, .0028864, .0026284, .002397, .002189, .0020017,
    .0018326, .0016798, .0015414, .0014159, .0013019, .0011983,
    .0011039, .0010177, 9.391e-4, 8.6717e-4, 8.0131e-4, 7.4093e-4,
    6.8553e-4, 6.3464e-4, 5.8787e-4, 5.4487e-4, 5.0533e-4, 4.69e-4,
    4.3556e-4, 4.0474e-4, 3.7629e-4, 3.5e-4, 3.2569e-4, 3.032e-4,
    2.8239e-4, 2.6314e-4, 2.4535e-4, 2.2891e-4, 2.1374e-4, 1.9975e-4,
    1.8685e-4, 1.7498e-4, 1.6406e-4, 1.5401e-4, 1.4479e-4, 1.3633e-4,
    1.2858e-4, 1.2148e-4, 1.1499e-4, 1.0907e-4, 1.0369e-4, 9.8791e-5,
    9.4359e-5, 9.0359e-5, 8.6766e-5, 8.3555e-5, 8.0703e-5, 7.8192e-5,
    7.6003e-5, 7.4119e-5, 7.2528e-5, 7.1216e-5, 7.0171e-5, 6.9385e-5,
    6.8848e-5, 6.8554e-5, 6.8496e-5, 6.8669e-5, 6.9069e-5, 6.9694e-5,
    7.054e-5, 7.1608e-5, 7.2896e-5, 7.4406e-5, 7.6139e-5, 7.8097e-5,
    8.0283e-5, 8.2702e-5, 8.5357e-5, 8.8255e-5, 9.1402e-5, 9.4806e-5,
    9.8473e-5, 1.0241e-4, 1.0664e-4, 1.1115e-4, 1.1598e-4, 1.2112e-4,
    1.2659e-4, 1.3241e-4, 1.3859e-4, 1.4515e-4, 1.521e-4, 1.5947e-4,
    1.6728e-4, 1.7555e-4, 1.8429e-4, 1.9355e-4, 2.0334e-4, 2.1369e-4,
    2.2463e-4, 2.3619e-4, 2.4841e-4, 2.6132e-4, 2.7497e-4, 2.8938e-4,
    3.0462e-4, 3.2071e-4, 3.3771e-4, 3.5567e-4, 3.7465e-4, 3.947e-4,
    4.1588e-4, 4.3828e-4, 4.6194e-4, 4.8695e-4, 5.1338e-4, 5.4133e-4,
    5.7087e-4, 6.0211e-4, 6.3515e-4, 6.701e-4, 7.0706e-4, 7.4617e-4,
    7.8756e-4, 8.3136e-4, 8.7772e-4, 9.2681e-4, 9.788e-4, .0010339,
    .0010922, .001154, .0012195, .0012889, .0013626, .0014407,
    .0015235, .0016114, .0017048, .0018038, .001909, .0020207,
    .0021395, .0022657, .0023998, .0025426, .0026944, .002856,
    .0030281, .0032114, .0034068, .003615, .0038371, .004074,
    .004327, .0045971, .0048857, .0051942, .0055239, .0058766,
    .0062538, .0066573, .0070891, .007551, .0080455, .0085747,
    .0091412, .0097481, .010397, .011092, .011837, .012638, .013495,
    .014415, .01541, .016475, .017621, .018857, .020175, .02162,
    .023185, .024876, .02672, .028732, .030916, .033319, .035939,
    .038736, .041847, .04524, .048715, .052678, .056977, .061203,
    .066184, .07164, .076952, .083477, .090674, .098049, .10697,
    .1169, .1277, .14011, .15323, .1684, .18601, .20626, .22831,
    .25417, .28407, .31405, .34957, .38823, .41923, .46026, .50409,
    .51227, .54805, .57976, .53818, .55056, .557, .46741, .46403,
    .4636, .42265, .45166, .49852, .56663, .34306, .17779, .17697,
    .18346, .19129, .20014, .21778, .23604, .25649, .28676, .31238,
    .33856, .39998, .4288, .46568, .56654, .60786, .64473, .76466,
    .7897, .80778, .86443, .85736, .84798, .84157, 1.1385, 1.2446,
    1.1923, 1.1552, 1.1338, 1.1266, 1.1292, 1.1431, 1.1683, 1.2059,
    1.2521, 1.3069, 1.3712, 1.4471, 1.5275, 1.6165, 1.7145, 1.8189,
    1.9359, 2.065, 2.2007, 2.3591, 2.5362, 2.7346, 2.9515, 3.2021,
    3.4851, 3.7935, 4.0694, 4.4463, 4.807, 5.2443, 5.7178, 6.2231,
    6.4796, 6.9461, 7.4099, 7.3652, 7.7182, 8.048, 7.7373, 8.0363,
    8.3855, 8.8044, 9.0257, 9.8574, 10.948, 10.563, 6.8979, 7.0744,
    7.4121, 7.7663, 8.1768, 8.6243, 9.1437, 9.7847, 10.182, 10.849,
    11.572, 12.602, 13.482, 14.431, 15.907, 16.983, 18.11, 19.884,
    21.02, 22.18, 23.355, 24.848, 25.954, 27.13, 30.186, 34.893,
    35.682, 36.755, 38.111, 39.703, 41.58, 43.606, 45.868, 48.573,
    51.298, 54.291, 57.559, 61.116, 64.964, 69.124, 73.628, 78.471,
    83.683, 89.307, 95.341, 101.84, 108.83, 116.36, 124.46, 133.18,
    142.57, 152.79, 163.69, 175.43, 188.11, 201.79, 216.55, 232.51,
    249.74, 268.38, 288.54, 310.35, 333.97, 359.55, 387.26, 417.3,
    449.88, 485.2, 523.54, 565.14, 610.28, 659.31, 712.56, 770.43,
    833.36, 901.82, 976.36, 1057.6, 1146.8, 1243.8, 1350., 1466.3,
    1593.6, 1732.7, 1884.1, 2049.1, 2228.2, 2421.9, 2629.4, 2853.7,
    3094.4, 3351.1, 3622.3, 3829.8, 4123.1, 4438.3, 4777.2, 5144.1,
    5545.4, 5990.5, 6404.5, 6996.8, 7687.6, 8482.9, 9349.4, 10203.,
    11223., 12358., 13493., 14916., 16416., 18236., 20222., 22501.,
    25102., 28358., 31707., 35404., 39538., 43911., 48391., 53193.,
    58028., 58082., 61276., 64193., 66294., 67480., 67921., 67423.,
    66254., 64341., 51737., 51420., 53072., 58145., 66195., 65358.,
    67377., 67869., 53509., 50553., 35737., 32425., 21704., 19974.,
    14457., 12142., 16798., 19489., 23049., 27270., 31910., 36457.,
    40877., 44748., 47876., 59793., 58626., 55454., 50337., 44893.,
    50228., 52216., 54747., 69541., 70455., 81014., 77694., 80533.,
    73953., 70927., 65539., 59002., 52281., 45953., 40292., 35360.,
    31124., 27478., 24346., 21647., 19308., 17271., 15491., 13927.,
    12550., 11331., 10250., 9288.8, 8431.4, 7664.9, 6978.3, 6361.8,
    5807.4, 5307.7, 4856.8, 4449., 4079.8, 3744.9, 3440.8, 3164.2,
    2912.3, 2682.7, 2473., 2281.4, 2106., 1945.3, 1797.9, 1662.5,
    1538.1, 1423.6, 1318.1, 1221., 1131.5, 1049., 972.99, 902.87,
    838.01, 777.95, 722.2, 670.44, 622.35, 577.68, 536.21, 497.76,
    462.12, 429.13, 398.61, 370.39, 344.29, 320.16, 297.85, 277.2,
    258.08, 240.38, 223.97, 208.77, 194.66, 181.58, 169.43, 158.15,
    147.67, 137.92, 128.86, 120.44, 112.6, 105.3, 98.499, 92.166,
    86.264, 80.763, 75.632, 70.846, 66.381, 62.213, 58.321, 54.685,
    51.288, 48.114, 45.145, 42.368, 39.772, 37.341, 35.065, 32.937,
    30.943, 29.077, 27.33, 25.693, 24.158, 22.717, 21.367, 20.099,
    18.909, 17.792, 16.744, 15.761, 14.838, 13.971, 13.157, 12.393,
    11.676, 11.003, 10.369, 9.775, 9.2165, 8.6902, 8.1963, 7.7314,
    7.2923, 6.8794, 6.4898, 6.122, 5.7764, 5.4525, 5.1484, 4.8611,
    4.5918, 4.3379, 4.0982, 3.8716, 3.6567, 3.4545, 3.2634, 3.0828,
    2.9122, 2.7512, 2.5993, 2.4561, 2.3211, 2.1938, 2.0737, 1.9603,
    1.8534, 1.7525, 1.6572, 1.5673, 1.4824, 1.4022, 1.3265, 1.2551,
    1.1876, 1.1239, 1.0637, 1.0069, .9532, .90248, .85454, .80921,
    .76631, .72569, .6872, .65072, .61635, .5836, .55261, .52336,
    .49581, .46998, .44559, .42236, .40036, .37929, .35924, .34043,
    .32238, .30547, .28931, .27405, .25975, .24616, .23341, .22133,
    .20997, .19924, .18917, .17967, .17075, .16211, .15411, .14646,
    .13912, .13201, .12509, .11857, .11261, .10698, .10186, .097039,
    .092236, .087844, .083443, .07938, .075452, .071564, .067931,
    .064389, .061078, .057901, .054921, .052061, .049364, .046789,
    .04435, .042044, .039866, .037808, .035863, .034023, .032282,
    .030634, .029073, .027595, .026194, .024866, .023608, .022415,
    .021283, .02021, .019193, .018228, .017312, .016443, .015619,
    .014837, .014094, .01339, .012721, .012086, .011483, .010911,
    .010368, .009852, .0093623, .0088972, .0084556, .0080362,
    .0076379, .0072596, .0069003, .006559, .0062349, .0059269,
    .0056344, .0053565, .0050925, .0048417, .0046034, .004377,
    .0041618, .0039575, .0037633, .0035788, .0034034, .0032368,
    .0030785, .002928, .0027851, .0026492, .0025201, .0023975,
    .0022809, .0021701, .0020649, .0019649, .0018699, .0017796,
    .0016938, .0016122, .0015348, .0014612, .0013913, .001325,
    .0012619, .0012021, .0011452, .0010913, .0010401, 9.9149e-4,
    9.454e-4, 9.0169e-4, 8.6024e-4, 8.2097e-4, 7.8377e-4, 7.4854e-4,
    7.1522e-4, 6.8371e-4, 6.5393e-4, 6.2582e-4, 5.9932e-4, 5.7435e-4,
    5.5087e-4, 5.2882e-4, 5.0814e-4, 4.8881e-4, 4.7076e-4, 4.5398e-4,
    4.3843e-4, 4.2407e-4, 4.109e-4, 3.9888e-4, 3.88e-4, 3.7826e-4,
    3.6963e-4, 3.6213e-4, 3.5575e-4, 3.505e-4, 3.464e-4, 3.4346e-4,
    3.4173e-4, 3.4125e-4, 3.4206e-4, 3.4424e-4, 3.4787e-4, 3.5303e-4,
    3.5986e-4, 3.6847e-4, 3.7903e-4, 3.9174e-4, 4.0681e-4, 4.2455e-4,
    4.4527e-4, 4.6942e-4, 4.9637e-4, 5.2698e-4, 5.5808e-4, 5.9514e-4,
    6.2757e-4, 6.689e-4, 7.1298e-4, 7.3955e-4, 7.8403e-4, 8.0449e-4,
    8.5131e-4, 9.0256e-4, 9.3692e-4, .0010051, .0010846, .0011678,
    .001282, .0014016, .0015355, .0016764, .0018272, .0020055,
    .0021455, .0023421, .0024615, .0026786, .0028787, .0031259,
    .0034046, .0036985, .0040917, .0043902, .0048349, .0049531,
    .0052989, .0056148, .0052452, .0053357, .005333, .0045069,
    .0043851, .004253, .003738, .0038084, .0039013, .0041505,
    .0045372, .0050569, .0054507, .0061267, .0066122, .0072449,
    .0078012, .0082651, .0076538, .0076573, .0076806, .0075227,
    .0076269, .0063758, .006254, .0067749, .0067909, .0068231,
    .0072143, .0072762, .0072954, .007679, .0075107, .0073658,
    .0072441, .0071074, .0070378, .007176, .0072472, .0075844,
    .0079291, .008412, .0090165, .010688, .011535, .012375, .013166,
    .013895, .015567, .016011, .016392, .016737, .017043, .017731,
    .018031, .018419, .018877, .019474, .019868, .020604, .021538,
    .022653, .023869, .025288, .026879, .028547, .030524, .03274,
    .035132, .03769, .040567, .043793, .047188, .049962, .053542,
    .057205, .060776, .061489, .064419, .067124, .065945, .068487,
    .071209, .074783, .077039, .082444, .08902, .09692, .10617,
    .11687, .12952, .12362, .13498, .14412, .15492, .16519, .1744,
    .17096, .17714, .18208, .17363, .17813, .18564, .18295, .19045,
    .20252, .20815, .21844, .22929, .24229, .25321, .26588, .2797,
    .29465, .31136, .32961, .36529, .38486, .41027, .43694, .4667,
    .49943, .54542, .58348, .62303, .67633, .71755, .76054, .81371,
    .85934, .90841, .96438, 1.0207, 1.0821, 1.1491, 1.2226, 1.3018,
    1.388, 1.4818, 1.5835, 1.6939, 1.8137, 1.9435, 2.0843, 2.237,
    2.4026, 2.5818, 2.7767, 2.9885, 3.2182, 3.4679, 3.7391, 4.0349,
    4.3554, 4.7053, 5.0849, 5.4986, 5.9436, 6.4294, 6.9598, 7.5203,
    8.143, 8.8253, 9.5568, 10.371, 11.267, 12.233, 13.31, 14.357,
    15.598, 16.93, 18.358, 19.849, 21.408, 23.04, 24.706, 26.409,
    28.153, 28.795, 30.549, 32.43, 34.49, 36.027, 38.955, 42.465,
    46.565, 50.875, 55.378, 59.002, 63.882, 67.949, 73.693, 80.095,
    86.403, 94.264, 102.65, 112.37, 123.3, 135.54, 149.14, 163.83,
    179.17, 196.89, 217.91, 240.94, 264.13, 292.39, 324.83, 358.21,
    397.16, 440.5, 488.6, 541.04, 595.3, 650.43, 652.03, 688.74,
    719.47, 743.54, 757.68, 762.35, 756.43, 741.42, 595.43, 580.97,
    580.83, 605.68, 667.88, 764.49, 759.93, 789.12, 798.17, 645.66,
    615.65, 455.05, 421.09, 306.45, 289.14, 235.7, 215.52, 274.57,
    316.53, 357.73, 409.89, 465.06, 521.84, 579.02, 630.64, 794.46,
    813., 813.56, 796.25, 761.57, 727.97, 812.14, 866.75, 932.5,
    1132.8, 1194.8, 1362.2, 1387.2, 1482.3, 1479.7, 1517.9, 1533.1,
    1534.2, 1523.3, 1522.5, 1515.5, 1505.2, 1486.5, 1454., 1412.,
    1358.8, 1107.8, 1060.9, 1033.5, 1048.2, 1122.4, 1248.9, 1227.1,
    1255.4, 1058.9, 1020.7, 970.59, 715.24, 512.56, 468.47, 349.3,
    338.26, 299.22, 301.26, 332.38, 382.08, 445.49, 515.87, 590.85,
    662.3, 726.05, 955.59, 964.11, 945.17, 891.48, 807.11, 720.9,
    803.36, 834.46, 1073.9, 1107.1, 1123.6, 1296., 1393.7, 1303.1,
    1284.3, 1161.8, 1078.8, 976.13, 868.72, 767.4, 674.72, 593.73,
    523.12, 462.24, 409.75, 364.34, 325., 290.73, 260.76, 234.46,
    211.28, 190.78, 172.61, 156.44, 142.01, 129.12, 117.57, 107.2,
    97.877, 89.47, 81.882, 75.021, 68.807, 63.171, 58.052, 53.396,
    49.155, 45.288, 41.759, 38.531, 35.576, 32.868, 30.384, 28.102,
    26.003, 24.071, 22.293, 20.655, 19.147, 17.756, 16.476, 15.292,
    14.198, 13.183, 12.241, 11.367, 10.554, 9.7989, 9.0978, 8.4475,
    7.845, 7.2868, 6.7704, 6.2927, 5.8508, 5.4421, 5.064, 4.714,
    4.3902, 4.0902, 3.8121, 3.5543, 3.315, 3.093, 2.8869, 2.6953,
    2.5172, 2.3517, 2.1977, 2.0544, 1.9211, 1.7969, 1.6812, 1.5735,
    1.4731, 1.3794, 1.2921, 1.2107, 1.1346, 1.0637, .99744, .93554,
    .87771, .82368, .77313, .72587, .6816, .64014, .60134, .565,
    .53086, .49883, .46881, .44074, .4144, .38979, .36679, .34513,
    .32474, .30552, .28751, .27045, .25458, .23976, .22584, .21278,
    .20051, .18899, .17815, .16801, .15846, .14954, .14117, .13328,
    .12584
  };
 
  /* Get CO2 continuum absorption... */
  const double xw = nu / 2 + 1;
  if (xw >= 1 && xw < 2001) {
    const int iw = (int) xw;
    const double dw = xw - iw;
    const double ew = 1 - dw;
    const double cw296 = ew * co2296[iw - 1] + dw * co2296[iw];
    const double cw260 = ew * co2260[iw - 1] + dw * co2260[iw];
    const double cw230 = ew * co2230[iw - 1] + dw * co2230[iw];
    const double dt230 = t - 230;
    const double dt260 = t - 260;
    const double dt296 = t - 296;
    const double ctw =
      dt260 * 5.050505e-4 * dt296 * cw230 -
      dt230 * 9.259259e-4 * dt296 * cw260 +
      dt230 * 4.208754e-4 * dt260 * cw296;
    return u / NA / 1000 * p / P0 * ctw;
  } else
    return 0;
}
 
/*****************************************************************************/
 
double ctmh2o(
  const double nu,
  const double p,
  const double t,
  const double q,
  const double u) {
 
  /* MT_CKD 4.1 coefficients from RFM 5.21 (0 to 20000 cm^-1). */
  static const double h2oslf[2001] =
    { 2.877e-21, 2.855e-21, 2.731e-21, 2.49e-21, 2.178e-21, 1.863e-21,
    1.595e-21,
    1.381e-21, 1.221e-21, 1.095e-21, 9.882e-22, 8.926e-22, 8.041e-22,
    7.217e-22,
    6.45e-22, 5.74e-22, 5.088e-22, 4.492e-22, 3.952e-22, 3.466e-22, 3.031e-22,
    2.644e-22, 2.302e-22, 2.001e-22, 1.738e-22, 1.509e-22, 1.311e-22,
    1.139e-22,
    9.913e-23, 8.639e-23, 7.544e-23, 6.603e-23, 5.794e-23, 5.096e-23,
    4.495e-23,
    3.974e-23, 3.523e-23, 3.13e-23, 2.786e-23, 2.485e-23, 2.221e-23,
    1.987e-23,
    1.78e-23, 1.596e-23, 1.433e-23, 1.287e-23, 1.156e-23, 1.04e-23, 9.349e-24,
    8.41e-24, 7.568e-24, 6.81e-24, 6.13e-24, 5.517e-24, 4.967e-24, 4.471e-24,
    4.025e-24, 3.624e-24, 3.262e-24, 2.937e-24, 2.644e-24, 2.381e-24,
    2.143e-24,
    1.93e-24, 1.737e-24, 1.564e-24, 1.413e-24, 1.284e-24, 1.176e-24,
    1.087e-24,
    1.013e-24, 9.489e-25, 8.961e-25, 8.451e-25, 7.943e-25, 7.43e-25,
    6.912e-25,
    6.447e-25, 6.025e-25, 5.642e-25, 5.292e-25, 4.971e-25, 4.69e-25,
    4.444e-25,
    4.216e-25, 4.012e-25, 3.814e-25, 3.621e-25, 3.442e-25, 3.268e-25, 3.1e-25,
    2.957e-25, 2.78e-25, 2.617e-25, 2.445e-25, 2.305e-25, 2.187e-25, 2.08e-25,
    1.98e-25, 1.885e-25, 1.796e-25, 1.711e-25, 1.633e-25, 1.559e-25, 1.49e-25,
    1.426e-25, 1.367e-25, 1.312e-25, 1.263e-25, 1.218e-25, 1.178e-25,
    1.143e-25,
    1.112e-25, 1.088e-25, 1.07e-25, 1.057e-25, 1.05e-25, 1.051e-25, 1.059e-25,
    1.076e-25, 1.1e-25, 1.133e-25, 1.18e-25, 1.237e-25, 1.308e-25, 1.393e-25,
    1.483e-25, 1.614e-25, 1.758e-25, 1.93e-25, 2.123e-25, 2.346e-25,
    2.647e-25,
    2.93e-25, 3.279e-25, 3.745e-25, 4.152e-25, 4.813e-25, 5.477e-25,
    6.203e-25,
    7.331e-25, 8.056e-25, 9.882e-25, 1.05e-24, 1.21e-24, 1.341e-24, 1.572e-24,
    1.698e-24, 1.968e-24, 2.175e-24, 2.431e-24, 2.735e-24, 2.867e-24,
    3.19e-24,
    3.371e-24, 3.554e-24, 3.726e-24, 3.837e-24, 3.878e-24, 3.864e-24,
    3.858e-24,
    3.841e-24, 3.852e-24, 3.815e-24, 3.762e-24, 3.618e-24, 3.579e-24,
    3.45e-24,
    3.202e-24, 3.018e-24, 2.785e-24, 2.602e-24, 2.416e-24, 2.097e-24,
    1.939e-24,
    1.689e-24, 1.498e-24, 1.308e-24, 1.17e-24, 1.011e-24, 9.237e-25,
    7.909e-25,
    7.006e-25, 6.112e-25, 5.401e-25, 4.914e-25, 4.266e-25, 3.963e-25,
    3.316e-25,
    3.037e-25, 2.598e-25, 2.294e-25, 2.066e-25, 1.813e-25, 1.583e-25,
    1.423e-25,
    1.247e-25, 1.116e-25, 9.76e-26, 8.596e-26, 7.72e-26, 7.091e-26, 6.499e-26,
    5.801e-26, 5.15e-26, 4.5e-26, 4e-26, 3.509e-26, 3.1e-26, 2.714e-26,
    2.406e-26, 2.108e-26, 1.875e-26, 1.669e-26, 1.555e-26, 1.444e-26,
    1.345e-26,
    1.257e-26, 1.175e-26, 1.102e-26, 1.035e-26, 9.745e-27, 9.194e-27,
    8.685e-27,
    8.222e-27, 7.798e-27, 7.412e-27, 7.052e-27, 6.724e-27, 6.42e-27,
    6.143e-27,
    5.886e-27, 5.649e-27, 5.43e-27, 5.228e-27, 5.041e-27, 4.868e-27,
    4.708e-27,
    4.559e-27, 4.421e-27, 4.293e-27, 4.174e-27, 4.064e-27, 3.961e-27,
    3.865e-27,
    3.775e-27, 3.692e-27, 3.614e-27, 3.542e-27, 3.474e-27, 3.411e-27,
    3.353e-27,
    3.298e-27, 3.248e-27, 3.201e-27, 3.158e-27, 3.119e-27, 3.084e-27,
    3.053e-27,
    3.025e-27, 3.003e-27, 2.988e-27, 2.976e-27, 2.977e-27, 2.989e-27,
    3.015e-27,
    3.057e-27, 3.112e-27, 3.161e-27, 3.186e-27, 3.176e-27, 3.142e-27,
    3.099e-27,
    3.065e-27, 3.011e-27, 2.955e-27, 2.914e-27, 2.884e-27, 2.864e-27,
    2.858e-27,
    2.851e-27, 2.857e-27, 2.87e-27, 2.888e-27, 2.914e-27, 2.948e-27, 2.99e-27,
    3.042e-27, 3.105e-27, 3.185e-27, 3.276e-27, 3.385e-27, 3.511e-27,
    3.646e-27,
    3.858e-27, 4.081e-27, 4.335e-27, 4.643e-27, 5.011e-27, 5.494e-27,
    5.953e-27,
    6.354e-27, 7.116e-27, 7.498e-27, 8.613e-27, 9.35e-27, 1.002e-26, 1.09e-26,
    1.174e-26, 1.23e-26, 1.288e-26, 1.334e-26, 1.383e-26, 1.38e-26, 1.39e-26,
    1.373e-26, 1.354e-26, 1.335e-26, 1.343e-26, 1.323e-26, 1.349e-26,
    1.353e-26,
    1.362e-26, 1.344e-26, 1.329e-26, 1.336e-26, 1.327e-26, 1.325e-26,
    1.359e-26,
    1.374e-26, 1.415e-26, 1.462e-26, 1.526e-26, 1.619e-26, 1.735e-26,
    1.863e-26,
    2.034e-26, 2.265e-26, 2.482e-26, 2.756e-26, 3.103e-26, 3.466e-26,
    3.832e-26,
    4.378e-26, 4.913e-26, 5.651e-26, 6.311e-26, 7.169e-26, 8.057e-26,
    9.253e-26,
    1.047e-25, 1.212e-25, 1.36e-25, 1.569e-25, 1.776e-25, 2.02e-25, 2.281e-25,
    2.683e-25, 2.994e-25, 3.488e-25, 3.896e-25, 4.499e-25, 5.175e-25,
    6.035e-25,
    6.34e-25, 7.281e-25, 7.923e-25, 8.348e-25, 9.631e-25, 1.044e-24,
    1.102e-24,
    1.176e-24, 1.244e-24, 1.283e-24, 1.326e-24, 1.4e-24, 1.395e-24, 1.387e-24,
    1.363e-24, 1.314e-24, 1.241e-24, 1.228e-24, 1.148e-24, 1.086e-24,
    1.018e-24,
    8.89e-25, 8.316e-25, 7.292e-25, 6.452e-25, 5.625e-25, 5.045e-25, 4.38e-25,
    3.762e-25, 3.29e-25, 2.836e-25, 2.485e-25, 2.168e-25, 1.895e-25,
    1.659e-25,
    1.453e-25, 1.282e-25, 1.132e-25, 1.001e-25, 8.836e-26, 7.804e-26,
    6.922e-26,
    6.116e-26, 5.429e-26, 4.824e-26, 4.278e-26, 3.788e-26, 3.371e-26,
    2.985e-26,
    2.649e-26, 2.357e-26, 2.09e-26, 1.858e-26, 1.647e-26, 1.462e-26,
    1.299e-26,
    1.155e-26, 1.028e-26, 9.142e-27, 8.132e-27, 7.246e-27, 6.418e-27,
    5.726e-27,
    5.221e-27, 4.89e-27, 4.666e-27, 4.443e-27, 4.203e-27, 3.978e-27, 3.77e-27,
    3.575e-27, 3.395e-27, 3.227e-27, 3.07e-27, 2.924e-27, 2.788e-27,
    2.661e-27,
    2.543e-27, 2.433e-27, 2.329e-27, 2.233e-27, 2.143e-27, 2.058e-27,
    1.98e-27,
    1.906e-27, 1.837e-27, 1.773e-27, 1.713e-27, 1.657e-27, 1.605e-27,
    1.557e-27,
    1.514e-27, 1.472e-27, 1.435e-27, 1.404e-27, 1.377e-27, 1.354e-27,
    1.332e-27,
    1.308e-27, 1.282e-27, 1.256e-27, 1.227e-27, 1.192e-27, 1.159e-27,
    1.134e-27,
    1.114e-27, 1.098e-27, 1.081e-27, 1.066e-27, 1.055e-27, 1.045e-27,
    1.036e-27,
    1.03e-27, 1.026e-27, 1.025e-27, 1.025e-27, 1.028e-27, 1.033e-27,
    1.041e-27,
    1.049e-27, 1.06e-27, 1.075e-27, 1.093e-27, 1.114e-27, 1.139e-27,
    1.166e-27,
    1.199e-27, 1.239e-27, 1.282e-27, 1.316e-27, 1.355e-27, 1.436e-27,
    1.588e-27,
    1.807e-27, 2.06e-27, 2.337e-27, 2.645e-27, 2.996e-27, 3.393e-27,
    3.843e-27,
    4.363e-27, 4.935e-27, 5.607e-27, 6.363e-27, 7.242e-27, 8.23e-27,
    9.411e-27,
    1.071e-26, 1.232e-26, 1.402e-26, 1.6e-26, 1.82e-26, 2.128e-26, 2.386e-26,
    2.781e-26, 3.242e-26, 3.653e-26, 4.323e-26, 4.747e-26, 5.321e-26,
    5.919e-26,
    6.681e-26, 7.101e-26, 7.983e-26, 8.342e-26, 8.741e-26, 9.431e-26,
    9.952e-26,
    1.026e-25, 1.055e-25, 1.095e-25, 1.095e-25, 1.087e-25, 1.056e-25,
    1.026e-25,
    9.715e-26, 9.252e-26, 8.452e-26, 7.958e-26, 7.268e-26, 6.295e-26,
    6.003e-26,
    5e-26, 4.591e-26, 3.983e-26, 3.479e-26, 3.058e-26, 2.667e-26, 2.293e-26,
    1.995e-26, 1.747e-26, 1.517e-26, 1.335e-26, 1.165e-26, 1.028e-26,
    9.007e-27,
    7.956e-27, 7.015e-27, 6.192e-27, 5.491e-27, 4.859e-27, 4.297e-27,
    3.799e-27,
    3.38e-27, 3.002e-27, 2.659e-27, 2.366e-27, 2.103e-27, 1.861e-27,
    1.655e-27,
    1.469e-27, 1.309e-27, 1.162e-27, 1.032e-27, 9.198e-28, 8.181e-28,
    7.294e-28,
    6.516e-28, 5.787e-28, 5.163e-28, 4.612e-28, 4.096e-28, 3.654e-28,
    3.299e-28,
    3.052e-28, 2.856e-28, 2.683e-28, 2.507e-28, 2.346e-28, 2.194e-28,
    2.053e-28,
    1.921e-28, 1.799e-28, 1.686e-28, 1.58e-28, 1.481e-28, 1.389e-28,
    1.304e-28,
    1.226e-28, 1.151e-28, 1.083e-28, 1.02e-28, 9.618e-29, 9.08e-29, 8.575e-29,
    8.08e-29, 7.624e-29, 7.176e-29, 6.761e-29, 6.37e-29, 6.004e-29, 5.672e-29,
    5.371e-29, 5.097e-29, 4.845e-29, 4.608e-29, 4.39e-29, 4.192e-29,
    4.011e-29,
    3.846e-29, 3.698e-29, 3.568e-29, 3.45e-29, 3.351e-29, 3.268e-29,
    3.195e-29,
    3.131e-29, 3.091e-29, 3.06e-29, 3.039e-29, 3.034e-29, 3.045e-29,
    3.072e-29,
    3.116e-29, 3.176e-29, 3.253e-29, 3.347e-29, 3.467e-29, 3.605e-29,
    3.763e-29,
    3.946e-29, 4.162e-29, 4.399e-29, 4.677e-29, 4.983e-29, 5.336e-29,
    5.728e-29,
    6.168e-29, 6.684e-29, 7.214e-29, 7.861e-29, 8.62e-29, 9.481e-29,
    1.032e-28,
    1.135e-28, 1.264e-28, 1.396e-28, 1.567e-28, 1.74e-28, 1.977e-28, 2.2e-28,
    2.563e-28, 2.935e-28, 3.386e-28, 3.993e-28, 4.828e-28, 5.714e-28,
    6.877e-28,
    8.135e-28, 9.779e-28, 1.132e-27, 1.344e-27, 1.544e-27, 1.82e-27,
    2.207e-27,
    2.509e-27, 2.854e-27, 3.026e-27, 3.278e-27, 3.474e-27, 3.693e-27,
    3.93e-27,
    4.104e-27, 4.22e-27, 4.439e-27, 4.545e-27, 4.778e-27, 4.812e-27,
    5.018e-27,
    4.899e-27, 5.075e-27, 5.073e-27, 5.171e-27, 5.131e-27, 5.25e-27,
    5.617e-27,
    5.846e-27, 6.239e-27, 6.696e-27, 7.398e-27, 8.073e-27, 9.15e-27,
    1.009e-26,
    1.116e-26, 1.264e-26, 1.439e-26, 1.644e-26, 1.856e-26, 2.147e-26,
    2.317e-26,
    2.713e-26, 2.882e-26, 2.99e-26, 3.489e-26, 3.581e-26, 4.033e-26, 4.26e-26,
    4.543e-26, 4.84e-26, 4.826e-26, 5.013e-26, 5.252e-26, 5.277e-26,
    5.306e-26,
    5.234e-26, 5.111e-26, 5.134e-26, 4.748e-26, 4.434e-26, 4.109e-26,
    3.605e-26,
    3.252e-26, 2.731e-26, 2.369e-26, 1.922e-26, 1.558e-26, 1.321e-26,
    1.058e-26,
    8.515e-27, 6.811e-27, 5.431e-27, 4.348e-27, 3.51e-27, 2.853e-27,
    2.344e-27,
    1.949e-27, 1.649e-27, 1.409e-27, 1.232e-27, 1.098e-27, 9.866e-28,
    8.899e-28,
    8.135e-28, 7.409e-28, 6.809e-28, 6.237e-28, 5.728e-28, 5.267e-28,
    4.865e-28,
    4.482e-28, 4.169e-28, 3.841e-28, 3.573e-28, 3.304e-28, 3.065e-28,
    2.851e-28,
    2.634e-28, 2.448e-28, 2.275e-28, 2.114e-28, 1.965e-28, 1.83e-28,
    1.707e-28,
    1.591e-28, 1.484e-28, 1.386e-28, 1.294e-28, 1.209e-28, 1.131e-28,
    1.056e-28,
    9.901e-29, 9.263e-29, 8.68e-29, 8.137e-29, 7.627e-29, 7.158e-29,
    6.715e-29,
    6.305e-29, 5.927e-29, 5.568e-29, 5.242e-29, 4.935e-29, 4.648e-29,
    4.383e-29,
    4.137e-29, 3.909e-29, 3.697e-29, 3.5e-29, 3.321e-29, 3.156e-29, 3.006e-29,
    2.868e-29, 2.745e-29, 2.638e-29, 2.545e-29, 2.469e-29, 2.405e-29,
    2.369e-29,
    2.344e-29, 2.35e-29, 2.371e-29, 2.491e-29, 2.535e-29, 2.73e-29, 3.067e-29,
    3.322e-29, 3.63e-29, 4.045e-29, 4.524e-29, 4.981e-29, 5.613e-29,
    6.051e-29,
    6.538e-29, 6.892e-29, 7.601e-29, 8.194e-29, 8.806e-29, 9.45e-29,
    9.745e-29,
    1.009e-28, 1.017e-28, 1.039e-28, 1.061e-28, 1.076e-28, 1.086e-28,
    1.111e-28,
    1.142e-28, 1.16e-28, 1.174e-28, 1.18e-28, 1.187e-28, 1.194e-28, 1.192e-28,
    1.224e-28, 1.245e-28, 1.246e-28, 1.318e-28, 1.377e-28, 1.471e-28,
    1.582e-28,
    1.713e-28, 1.853e-28, 2.063e-28, 2.27e-28, 2.567e-28, 2.891e-28,
    3.264e-28,
    3.744e-28, 4.286e-28, 4.915e-28, 5.623e-28, 6.336e-28, 7.293e-28,
    8.309e-28,
    9.319e-28, 1.091e-27, 1.243e-27, 1.348e-27, 1.449e-27, 1.62e-27,
    1.846e-27,
    1.937e-27, 2.04e-27, 2.179e-27, 2.298e-27, 2.433e-27, 2.439e-27,
    2.464e-27,
    2.611e-27, 2.617e-27, 2.582e-27, 2.453e-27, 2.401e-27, 2.349e-27,
    2.203e-27,
    2.066e-27, 1.939e-27, 1.78e-27, 1.558e-27, 1.391e-27, 1.203e-27,
    1.048e-27,
    9.464e-28, 8.306e-28, 7.239e-28, 6.317e-28, 5.52e-28, 4.847e-28,
    4.282e-28,
    3.796e-28, 3.377e-28, 2.996e-28, 2.678e-28, 2.4e-28, 2.134e-28, 1.904e-28,
    1.705e-28, 1.523e-28, 1.35e-28, 1.204e-28, 1.07e-28, 9.408e-29, 8.476e-29,
    7.47e-29, 6.679e-29, 5.929e-29, 5.267e-29, 4.711e-29, 4.172e-29,
    3.761e-29,
    3.288e-29, 2.929e-29, 2.609e-29, 2.315e-29, 2.042e-29, 1.844e-29,
    1.64e-29,
    1.47e-29, 1.31e-29, 1.176e-29, 1.049e-29, 9.377e-30, 8.462e-30, 7.616e-30,
    6.818e-30, 6.119e-30, 5.558e-30, 5.152e-30, 4.832e-30, 4.546e-30,
    4.267e-30,
    4.009e-30, 3.77e-30, 3.546e-30, 3.34e-30, 3.149e-30, 2.971e-30, 2.805e-30,
    2.652e-30, 2.509e-30, 2.377e-30, 2.255e-30, 2.142e-30, 2.038e-30,
    1.943e-30,
    1.855e-30, 1.776e-30, 1.703e-30, 1.64e-30, 1.586e-30, 1.536e-30,
    1.494e-30,
    1.466e-30, 1.446e-30, 1.44e-30, 1.439e-30, 1.455e-30, 1.461e-30,
    1.479e-30,
    1.514e-30, 1.538e-30, 1.59e-30, 1.652e-30, 1.75e-30, 1.811e-30, 1.88e-30,
    1.933e-30, 2.027e-30, 2.078e-30, 2.17e-30, 2.249e-30, 2.323e-30,
    2.408e-30,
    2.461e-30, 2.536e-30, 2.581e-30, 2.615e-30, 2.721e-30, 2.782e-30,
    2.866e-30,
    2.938e-30, 2.958e-30, 3.011e-30, 3.155e-30, 3.237e-30, 3.589e-30,
    3.838e-30,
    4.083e-30, 4.354e-30, 4.745e-30, 5.148e-30, 5.648e-30, 6.194e-30,
    6.748e-30,
    7.566e-30, 8.421e-30, 9.427e-30, 1.042e-29, 1.165e-29, 1.341e-29,
    1.518e-29,
    1.686e-29, 2.036e-29, 2.362e-29, 2.811e-29, 3.296e-29, 4.07e-29,
    4.695e-29,
    6.152e-29, 7.572e-29, 9.557e-29, 1.135e-28, 1.279e-28, 1.364e-28,
    1.436e-28,
    1.54e-28, 1.672e-28, 1.793e-28, 1.906e-28, 2.036e-28, 2.144e-28,
    2.292e-28,
    2.371e-28, 2.493e-28, 2.606e-28, 2.706e-28, 2.866e-28, 3.036e-28,
    3.136e-28,
    3.405e-28, 3.665e-28, 3.837e-28, 4.229e-28, 4.748e-28, 5.32e-28,
    5.763e-28,
    6.677e-28, 7.216e-28, 7.716e-28, 8.958e-28, 9.419e-28, 1.036e-27,
    1.108e-27,
    1.189e-27, 1.246e-27, 1.348e-27, 1.31e-27, 1.361e-27, 1.364e-27,
    1.363e-27,
    1.343e-27, 1.293e-27, 1.254e-27, 1.235e-27, 1.158e-27, 1.107e-27,
    9.961e-28,
    9.011e-28, 7.91e-28, 6.916e-28, 6.338e-28, 5.564e-28, 4.827e-28,
    4.198e-28,
    3.695e-28, 3.276e-28, 2.929e-28, 2.633e-28, 2.391e-28, 2.192e-28,
    2.021e-28,
    1.89e-28, 1.772e-28, 1.667e-28, 1.603e-28, 1.547e-28, 1.537e-28,
    1.492e-28,
    1.515e-28, 1.479e-28, 1.45e-28, 1.513e-28, 1.495e-28, 1.529e-28,
    1.565e-28,
    1.564e-28, 1.553e-28, 1.569e-28, 1.584e-28, 1.57e-28, 1.538e-28,
    1.531e-28,
    1.346e-28, 1.199e-28, 1.044e-28, 8.892e-29, 7.076e-29, 5.884e-29,
    5.039e-29,
    4.129e-29, 3.663e-29, 2.993e-29, 2.622e-29, 2.232e-29, 1.884e-29,
    1.569e-29,
    1.348e-29, 1.144e-29, 1.009e-29, 8.833e-30, 7.907e-30, 7.079e-30,
    6.514e-30,
    5.823e-30, 5.312e-30, 4.883e-30, 4.458e-30, 4.094e-30, 3.734e-30,
    3.458e-30,
    3.205e-30, 2.962e-30, 2.733e-30, 2.532e-30, 2.351e-30, 2.187e-30,
    2.034e-30,
    1.889e-30, 1.764e-30, 1.648e-30, 1.541e-30, 1.443e-30, 1.355e-30,
    1.274e-30,
    1.198e-30, 1.133e-30, 1.071e-30, 1.015e-30, 9.648e-31, 9.195e-31,
    8.791e-31,
    8.435e-31, 8.125e-31, 7.859e-31, 7.621e-31, 7.481e-31, 7.351e-31,
    7.228e-31,
    7.295e-31, 7.339e-31, 7.588e-31, 7.701e-31, 7.886e-31, 8.511e-31,
    9.061e-31,
    9.926e-31, 1.083e-30, 1.241e-30, 1.469e-30, 1.736e-30, 1.966e-30,
    2.132e-30,
    2.28e-30, 2.473e-30, 2.718e-30, 2.922e-30, 3.128e-30, 3.361e-30,
    3.641e-30,
    3.91e-30, 4.196e-30, 4.501e-30, 4.932e-30, 5.258e-30, 5.755e-30,
    6.253e-30,
    6.664e-30, 7.344e-30, 7.985e-30, 8.877e-30, 1.005e-29, 1.118e-29,
    1.251e-29,
    1.428e-29, 1.61e-29, 1.888e-29, 2.077e-29, 2.331e-29, 2.751e-29,
    3.061e-29,
    3.522e-29, 3.805e-29, 4.181e-29, 4.575e-29, 5.167e-29, 5.634e-29,
    6.007e-29,
    6.501e-29, 6.829e-29, 7.211e-29, 7.262e-29, 7.696e-29, 7.832e-29,
    7.799e-29,
    7.651e-29, 7.304e-29, 7.15e-29, 6.977e-29, 6.603e-29, 6.209e-29, 5.69e-29,
    5.432e-29, 4.764e-29, 4.189e-29, 3.64e-29, 3.203e-29, 2.848e-29, 2.51e-29,
    2.194e-29, 1.946e-29, 1.75e-29, 1.567e-29, 1.426e-29, 1.302e-29,
    1.197e-29,
    1.109e-29, 1.035e-29, 9.719e-30, 9.207e-30, 8.957e-30, 8.578e-30,
    8.262e-30,
    8.117e-30, 7.987e-30, 7.875e-30, 7.741e-30, 7.762e-30, 7.537e-30,
    7.424e-30,
    7.474e-30, 7.294e-30, 7.216e-30, 7.233e-30, 7.14e-30, 7.085e-30,
    6.434e-30,
    5.585e-30, 5.015e-30, 3.956e-30, 3.337e-30, 2.545e-30, 2.141e-30,
    1.761e-30,
    1.685e-30, 1.507e-30, 1.241e-30, 1.081e-30, 9.675e-31, 7.964e-31,
    6.93e-31,
    5.79e-31, 5.069e-31, 4.452e-31, 3.97e-31, 3.551e-31, 3.228e-31, 2.939e-31,
    2.682e-31, 2.471e-31, 2.278e-31, 2.106e-31, 1.95e-31, 1.811e-31,
    1.682e-31,
    1.563e-31, 1.458e-31, 1.363e-31, 1.278e-31, 1.2e-31, 1.129e-31, 1.066e-31,
    1.007e-31, 9.545e-32, 9.075e-32, 8.656e-32, 8.285e-32, 7.958e-32,
    7.674e-32,
    7.431e-32, 7.227e-32, 7.061e-32, 6.934e-32, 6.843e-32, 6.79e-32,
    6.775e-32,
    6.798e-32, 6.859e-32, 6.96e-32, 7.102e-32, 7.287e-32, 7.517e-32,
    7.795e-32,
    8.123e-32, 8.504e-32, 8.945e-32, 9.45e-32, 1.003e-31, 1.07e-31, 1.148e-31,
    1.232e-31, 1.327e-31, 1.441e-31, 1.535e-31, 1.655e-31, 1.814e-31,
    2.02e-31,
    2.307e-31, 2.622e-31, 2.962e-31, 3.369e-31, 3.819e-31, 4.329e-31,
    4.932e-31,
    5.589e-31, 6.364e-31, 7.284e-31, 8.236e-31, 9.447e-31, 1.078e-30,
    1.229e-30,
    1.417e-30, 1.614e-30, 1.843e-30, 2.107e-30, 2.406e-30, 2.728e-30,
    3.195e-30,
    3.595e-30, 4.153e-30, 4.736e-30, 5.41e-30, 6.088e-30, 6.769e-30,
    7.691e-30,
    8.545e-30, 9.621e-30, 1.047e-29, 1.161e-29, 1.296e-29, 1.424e-29,
    1.576e-29,
    1.739e-29, 1.893e-29, 2.08e-29, 2.336e-29, 2.604e-29, 2.76e-29, 3.001e-29,
    3.365e-29, 3.55e-29, 3.895e-29, 4.183e-29, 4.614e-29, 4.846e-29,
    5.068e-29,
    5.427e-29, 5.541e-29, 5.864e-29, 5.997e-29, 5.997e-29, 6.061e-29,
    5.944e-29,
    5.855e-29, 5.661e-29, 5.523e-29, 5.374e-29, 4.94e-29, 4.688e-29, 4.17e-29,
    3.913e-29, 3.423e-29, 2.997e-29, 2.598e-29, 2.253e-29, 1.946e-29,
    1.71e-29,
    1.507e-29, 1.336e-29, 1.19e-29, 1.068e-29, 9.623e-30, 8.772e-30,
    8.007e-30,
    7.42e-30, 6.884e-30, 6.483e-30, 6.162e-30, 5.922e-30, 5.688e-30,
    5.654e-30,
    5.637e-30, 5.701e-30, 5.781e-30, 5.874e-30, 6.268e-30, 6.357e-30,
    6.525e-30,
    7.137e-30, 7.441e-30, 8.024e-30, 8.485e-30, 9.143e-30, 9.536e-30,
    9.717e-30,
    1.018e-29, 1.042e-29, 1.054e-29, 1.092e-29, 1.093e-29, 1.072e-29,
    1.046e-29,
    9.283e-30, 8.053e-30, 6.68e-30, 5.63e-30, 4.933e-30, 3.488e-30, 3.324e-30,
    2.826e-30, 2.429e-30, 2.051e-30, 1.679e-30, 1.411e-30, 1.24e-30,
    1.098e-30,
    9.668e-31, 8.529e-31, 7.848e-31, 7.098e-31, 6.117e-31, 5.246e-31,
    4.521e-31,
    4.059e-31, 3.783e-31, 3.502e-31, 3.271e-31, 2.956e-31, 2.636e-31,
    2.464e-31,
    2.19e-31, 1.986e-31, 1.791e-31, 1.638e-31, 1.491e-31, 1.383e-31,
    1.271e-31,
    1.166e-31, 1.082e-31, 1.002e-31, 9.317e-32, 8.697e-32, 8.157e-32,
    7.678e-32,
    7.252e-32, 6.874e-32, 6.539e-32, 6.243e-32, 5.985e-32, 5.763e-32,
    5.575e-32,
    5.421e-32, 5.3e-32, 5.212e-32, 5.157e-32, 5.138e-32, 5.156e-32, 5.214e-32,
    5.313e-32, 5.457e-32, 5.686e-32, 5.953e-32, 6.284e-32, 6.856e-32,
    7.351e-32,
    8.006e-32, 8.957e-32, 1.031e-31, 1.17e-31, 1.345e-31, 1.623e-31,
    1.999e-31,
    2.507e-31, 3.004e-31, 3.378e-31, 3.688e-31, 4.118e-31, 4.569e-31,
    5.025e-31,
    5.66e-31, 6.231e-31, 6.881e-31, 7.996e-31, 8.526e-31, 9.694e-31,
    1.106e-30,
    1.222e-30, 1.355e-30, 1.525e-30, 1.775e-30, 1.924e-30, 2.181e-30,
    2.379e-30,
    2.662e-30, 2.907e-30, 3.154e-30, 3.366e-30, 3.579e-30, 3.858e-30,
    4.046e-30,
    4.196e-30, 4.166e-30, 4.457e-30, 4.466e-30, 4.404e-30, 4.337e-30,
    4.15e-30,
    4.083e-30, 3.91e-30, 3.723e-30, 3.514e-30, 3.303e-30, 2.847e-30,
    2.546e-30,
    2.23e-30, 1.994e-30, 1.733e-30, 1.488e-30, 1.297e-30, 1.144e-30,
    1.004e-30,
    8.741e-31, 7.928e-31, 7.034e-31, 6.323e-31, 5.754e-31, 5.25e-31, 4.85e-31,
    4.502e-31, 4.286e-31, 4.028e-31, 3.899e-31, 3.824e-31, 3.761e-31,
    3.804e-31,
    3.839e-31, 3.845e-31, 4.244e-31, 4.382e-31, 4.582e-31, 4.847e-31,
    5.209e-31,
    5.384e-31, 5.887e-31, 6.371e-31, 6.737e-31, 7.168e-31, 7.415e-31,
    7.827e-31,
    8.037e-31, 8.12e-31, 8.154e-31, 7.981e-31, 7.783e-31, 6.9e-31, 6.03e-31,
    4.9e-31, 3.878e-31, 3.068e-31, 2.533e-31, 2.255e-31, 2.056e-31, 1.569e-31,
    1.398e-31, 1.149e-31, 9.249e-32, 7.706e-32, 6.436e-32, 5.514e-32,
    4.782e-32,
    4.202e-32, 3.721e-32, 3.336e-32, 3.015e-32, 2.744e-32, 2.512e-32,
    2.312e-32,
    2.138e-32, 1.987e-32, 1.855e-32, 1.741e-32, 1.642e-32, 1.557e-32,
    1.483e-32,
    1.422e-32, 1.37e-32, 1.329e-32, 1.297e-32, 1.274e-32, 1.259e-32,
    1.253e-32,
    1.255e-32, 1.266e-32, 1.284e-32, 1.312e-32, 1.348e-32, 1.393e-32,
    1.448e-32,
    1.512e-32, 1.587e-32, 1.672e-32, 1.77e-32, 1.88e-32, 1.99e-32, 2.11e-32,
    2.274e-32, 2.516e-32, 2.844e-32, 3.231e-32, 3.661e-32, 4.153e-32,
    4.717e-32,
    5.36e-32, 6.094e-32, 6.93e-32, 7.882e-32, 8.966e-32, 1.02e-31, 1.162e-31,
    1.324e-31, 1.51e-31, 1.72e-31, 1.965e-31, 2.237e-31, 2.56e-31, 2.927e-31,
    3.371e-31, 3.842e-31, 4.429e-31, 5.139e-31, 5.798e-31, 6.697e-31,
    7.626e-31,
    8.647e-31, 1.022e-30, 1.136e-30, 1.3e-30, 1.481e-30, 1.672e-30, 1.871e-30,
    2.126e-30, 2.357e-30, 2.583e-30, 2.997e-30, 3.289e-30, 3.702e-30,
    4.012e-30,
    4.319e-30, 4.527e-30, 5.001e-30, 5.448e-30, 5.611e-30, 5.76e-30,
    5.965e-30,
    6.079e-30, 6.207e-30, 6.276e-30, 6.222e-30, 6.137e-30, 6e-30, 5.814e-30,
    5.393e-30, 5.35e-30, 4.947e-30, 4.629e-30, 4.117e-30, 3.712e-30,
    3.372e-30,
    2.923e-30, 2.55e-30, 2.232e-30, 1.929e-30, 1.679e-30, 1.46e-30, 1.289e-30,
    1.13e-30, 9.953e-31, 8.763e-31, 7.76e-31, 6.9e-31, 6.16e-31, 5.525e-31,
    4.958e-31, 4.489e-31, 4.072e-31, 3.728e-31, 3.438e-31, 3.205e-31,
    3.006e-31,
    2.848e-31, 2.766e-31, 2.688e-31, 2.664e-31, 2.67e-31, 2.696e-31,
    2.786e-31,
    2.861e-31, 3.009e-31, 3.178e-31, 3.389e-31, 3.587e-31, 3.819e-31,
    4.054e-31,
    4.417e-31, 4.703e-31, 5.137e-31, 5.46e-31, 6.055e-31, 6.333e-31,
    6.773e-31,
    7.219e-31, 7.717e-31, 8.131e-31, 8.491e-31, 8.574e-31, 9.01e-31,
    9.017e-31,
    8.999e-31, 8.959e-31, 8.838e-31, 8.579e-31, 8.162e-31, 8.098e-31,
    7.472e-31,
    7.108e-31, 6.559e-31, 5.994e-31, 5.172e-31, 4.424e-31, 3.951e-31,
    3.34e-31,
    2.902e-31, 2.541e-31, 2.215e-31, 1.945e-31, 1.716e-31, 1.503e-31,
    1.339e-31,
    1.185e-31, 1.05e-31, 9.336e-32, 8.307e-32, 7.312e-32, 6.55e-32, 5.836e-32,
    5.178e-32, 4.6e-32, 4.086e-32, 3.639e-32, 3.247e-32, 2.904e-32, 2.604e-32,
    2.341e-32, 2.112e-32, 1.914e-32, 1.744e-32, 1.598e-32, 1.476e-32,
    1.374e-32,
    1.293e-32, 1.23e-32, 1.185e-32, 1.158e-32, 1.147e-32, 1.154e-32,
    1.177e-32,
    1.219e-32, 1.28e-32, 1.36e-32, 1.463e-32, 1.591e-32, 1.75e-32, 1.94e-32,
    2.156e-32, 2.43e-32, 2.748e-32, 3.052e-32, 3.533e-32, 3.967e-32,
    4.471e-32,
    5.041e-32, 5.86e-32, 6.664e-32, 7.522e-32, 8.342e-32, 9.412e-32,
    1.072e-31,
    1.213e-31, 1.343e-31, 1.496e-31, 1.664e-31, 1.822e-31, 2.029e-31,
    2.233e-31,
    2.457e-31, 2.709e-31, 2.928e-31, 3.115e-31, 3.356e-31, 3.592e-31,
    3.818e-31,
    3.936e-31, 4.061e-31, 4.149e-31, 4.299e-31, 4.223e-31, 4.251e-31,
    4.287e-31,
    4.177e-31, 4.094e-31, 3.942e-31, 3.772e-31, 3.614e-31, 3.394e-31,
    3.222e-31,
    2.791e-31, 2.665e-31, 2.309e-31, 2.032e-31, 1.74e-31, 1.535e-31,
    1.323e-31,
    1.151e-31, 9.803e-32, 8.65e-32, 7.54e-32, 6.619e-32, 5.832e-32, 5.113e-32,
    4.503e-32, 3.975e-32, 3.52e-32, 3.112e-32, 2.797e-32, 2.5e-32, 2.24e-32,
    2.013e-32, 1.819e-32, 1.653e-32, 1.513e-32, 1.395e-32, 1.299e-32,
    1.225e-32,
    1.168e-32, 1.124e-32, 1.148e-32, 1.107e-32, 1.128e-32, 1.169e-32,
    1.233e-32,
    1.307e-32, 1.359e-32, 1.543e-32, 1.686e-32, 1.794e-32, 2.028e-32,
    2.21e-32,
    2.441e-32, 2.653e-32, 2.828e-32, 3.093e-32, 3.28e-32, 3.551e-32,
    3.677e-32,
    3.803e-32, 3.844e-32, 4.068e-32, 4.093e-32, 4.002e-32, 3.904e-32,
    3.624e-32,
    3.633e-32, 3.622e-32, 3.443e-32, 3.184e-32, 2.934e-32, 2.476e-32,
    2.212e-32,
    1.867e-32, 1.594e-32, 1.37e-32, 1.192e-32, 1.045e-32, 9.211e-33, 8.17e-33,
    7.29e-33, 6.55e-33, 5.929e-33, 5.415e-33, 4.995e-33, 4.661e-33, 4.406e-33,
    4.225e-33, 4.116e-33, 4.075e-33, 4.102e-33, 4.198e-33, 4.365e-33,
    4.606e-33,
    4.925e-33, 5.326e-33, 5.818e-33, 6.407e-33, 7.104e-33, 7.92e-33,
    8.868e-33,
    9.964e-33, 1.123e-32, 1.268e-32, 1.434e-32, 1.626e-32, 1.848e-32,
    2.107e-32,
    2.422e-32, 2.772e-32, 3.145e-32, 3.704e-32, 4.27e-32, 4.721e-32,
    5.361e-32,
    6.083e-32, 7.095e-32, 7.968e-32, 9.228e-32, 1.048e-31, 1.187e-31,
    1.336e-31,
    1.577e-31, 1.772e-31, 2.017e-31, 2.25e-31, 2.63e-31, 2.911e-31, 3.356e-31,
    3.82e-31, 4.173e-31, 4.811e-31, 5.254e-31, 5.839e-31, 6.187e-31,
    6.805e-31,
    7.118e-31, 7.369e-31, 7.664e-31, 7.794e-31, 7.947e-31, 8.036e-31,
    7.954e-31,
    7.849e-31, 7.518e-31, 7.462e-31, 6.926e-31, 6.531e-31, 6.197e-31,
    5.421e-31,
    4.777e-31, 4.111e-31, 3.679e-31, 3.166e-31, 2.786e-31, 2.436e-31,
    2.144e-31,
    1.859e-31, 1.628e-31, 1.414e-31, 1.237e-31, 1.093e-31, 9.558e-32
  };
 
  static const double h2ofrn[2001] =
    { 8.563e-23, 8.828e-23, 9.182e-23, 9.796e-23, 1.14e-22, 1.376e-22,
    1.545e-22,
    1.508e-22, 1.386e-22, 1.215e-22, 1.063e-22, 9.151e-23, 8.008e-23,
    6.97e-23,
    6.055e-23, 5.243e-23, 4.559e-23, 3.763e-23, 3.055e-23, 2.563e-23,
    2.197e-23,
    1.809e-23, 1.483e-23, 1.167e-23, 8.809e-24, 7.131e-24, 5.933e-24,
    5.172e-24,
    4.22e-24, 3.427e-24, 2.648e-24, 2.123e-24, 1.825e-24, 1.476e-24,
    1.101e-24,
    8.588e-25, 6.499e-25, 4.875e-25, 3.861e-25, 3.001e-25, 2.343e-25,
    2.087e-25,
    1.771e-25, 1.588e-25, 1.408e-25, 1.181e-25, 1.024e-25, 9.223e-26,
    7.916e-26,
    6.692e-26, 5.72e-26, 5.125e-26, 4.478e-26, 3.844e-26, 3.267e-26,
    2.851e-26,
    2.473e-26, 2.124e-26, 1.768e-26, 1.481e-26, 1.267e-26, 1.075e-26,
    9.212e-27,
    7.849e-27, 6.601e-27, 5.599e-27, 4.768e-27, 4.098e-27, 3.558e-27,
    3.089e-27,
    2.678e-27, 2.339e-27, 2.038e-27, 1.755e-27, 1.497e-27, 1.294e-27,
    1.129e-27,
    9.878e-28, 8.603e-28, 7.494e-28, 6.568e-28, 5.747e-28, 5.025e-28,
    4.345e-28,
    3.758e-28, 3.272e-28, 2.862e-28, 2.508e-28, 2.198e-28, 1.918e-28,
    1.68e-28,
    1.471e-28, 1.289e-28, 1.135e-28, 9.962e-29, 8.767e-29, 7.699e-29,
    6.798e-29,
    6.007e-29, 5.336e-29, 4.75e-29, 4.232e-29, 3.807e-29, 3.476e-29,
    3.237e-29,
    3.002e-29, 2.821e-29, 2.757e-29, 2.816e-29, 2.92e-29, 3.044e-29, 3.42e-29,
    3.745e-29, 4.197e-29, 4.816e-29, 5.987e-29, 7.098e-29, 8.082e-29,
    9.622e-29,
    1.211e-28, 1.502e-28, 1.766e-28, 2.223e-28, 2.901e-28, 3.951e-28,
    5.072e-28,
    6.232e-28, 7.904e-28, 1.034e-27, 1.438e-27, 1.89e-27, 2.59e-27, 3.592e-27,
    4.973e-27, 7.159e-27, 9.987e-27, 1.382e-26, 1.93e-26, 2.592e-26,
    3.454e-26,
    4.572e-26, 5.932e-26, 7.554e-26, 9.559e-26, 1.183e-25, 1.425e-25,
    1.681e-25,
    1.978e-25, 2.336e-25, 2.669e-25, 3.023e-25, 3.372e-25, 3.716e-25,
    3.968e-25,
    4.061e-25, 4.011e-25, 3.81e-25, 3.491e-25, 3.155e-25, 2.848e-25,
    2.678e-25,
    2.66e-25, 2.811e-25, 3.071e-25, 3.294e-25, 3.459e-25, 3.569e-25, 3.56e-25,
    3.434e-25, 3.186e-25, 2.916e-25, 2.622e-25, 2.275e-25, 1.918e-25,
    1.62e-25,
    1.373e-25, 1.182e-25, 1.006e-25, 8.556e-26, 7.26e-26, 6.11e-26, 5.04e-26,
    4.23e-26, 3.456e-26, 2.903e-26, 2.486e-26, 2.039e-26, 1.672e-26,
    1.285e-26,
    1.054e-26, 8.302e-27, 6.667e-27, 5.503e-27, 4.562e-27, 3.948e-27,
    3.198e-27,
    2.586e-27, 2.225e-27, 1.807e-27, 1.53e-27, 1.294e-27, 1.126e-27,
    9.604e-28,
    7.85e-28, 6.813e-28, 5.583e-28, 4.69e-28, 3.996e-28, 3.373e-28, 2.93e-28,
    2.417e-28, 2.061e-28, 1.743e-28, 1.475e-28, 1.273e-28, 1.084e-28,
    9.368e-29,
    7.985e-29, 6.785e-29, 5.804e-29, 4.975e-29, 4.311e-29, 3.738e-29,
    3.275e-29,
    2.847e-29, 2.469e-29, 2.149e-29, 1.884e-29, 1.631e-29, 1.393e-29,
    1.201e-29,
    1.027e-29, 8.807e-30, 7.521e-30, 6.436e-30, 5.509e-30, 4.729e-30,
    4.055e-30,
    3.49e-30, 3.006e-30, 2.599e-30, 2.246e-30, 1.942e-30, 1.685e-30,
    1.464e-30,
    1.273e-30, 1.115e-30, 9.794e-31, 8.729e-31, 7.893e-31, 7.313e-31,
    7.069e-31,
    7.19e-31, 7.828e-31, 9.295e-31, 1.174e-30, 1.578e-30, 2.184e-30,
    3.053e-30,
    4.212e-30, 5.733e-30, 7.497e-30, 9.487e-30, 1.153e-29, 1.343e-29,
    1.503e-29,
    1.623e-29, 1.696e-29, 1.746e-29, 1.789e-29, 1.852e-29, 1.862e-29,
    1.886e-29,
    1.912e-29, 1.942e-29, 1.938e-29, 1.914e-29, 1.898e-29, 1.864e-29,
    1.77e-29,
    1.635e-29, 1.464e-29, 1.279e-29, 1.099e-29, 9.528e-30, 8.433e-30,
    7.794e-30,
    7.793e-30, 8.241e-30, 9.417e-30, 1.179e-29, 1.616e-29, 2.144e-29,
    2.992e-29,
    4.344e-29, 6.415e-29, 9.242e-29, 1.31e-28, 1.847e-28, 2.567e-28, 3.39e-28,
    4.357e-28, 5.301e-28, 6.364e-28, 7.438e-28, 8.381e-28, 9.294e-28,
    1.013e-27,
    1.103e-27, 1.17e-27, 1.2e-27, 1.19e-27, 1.133e-27, 1.04e-27, 9.475e-28,
    8.601e-28, 8.074e-28, 8.023e-28, 8.473e-28, 9.256e-28, 9.989e-28,
    1.056e-27,
    1.079e-27, 1.079e-27, 1.049e-27, 1e-27, 9.35e-28, 8.662e-28, 7.88e-28,
    7.137e-28, 6.438e-28, 5.706e-28, 5.132e-28, 4.815e-28, 4.736e-28,
    4.709e-28,
    4.918e-28, 5.227e-28, 5.603e-28, 6.023e-28, 6.567e-28, 7.403e-28,
    8.695e-28,
    9.929e-28, 1.163e-27, 1.379e-27, 1.658e-27, 2.01e-27, 2.425e-27, 2.92e-27,
    3.562e-27, 4.274e-27, 5.173e-27, 6.285e-27, 7.787e-27, 9.563e-27,
    1.194e-26,
    1.517e-26, 1.934e-26, 2.511e-26, 3.197e-26, 4.024e-26, 4.981e-26,
    6.09e-26,
    7.229e-26, 8.439e-26, 9.367e-26, 1.016e-25, 1.057e-25, 1.088e-25,
    1.108e-25,
    1.129e-25, 1.159e-25, 1.19e-25, 1.21e-25, 1.21e-25, 1.2e-25, 1.19e-25,
    1.18e-25, 1.19e-25, 1.23e-25, 1.28e-25, 1.3e-25, 1.29e-25, 1.21e-25,
    1.09e-25, 9.44e-26, 7.79e-26, 6.22e-26, 4.64e-26, 3.4e-26, 2.47e-26,
    1.78e-26, 1.29e-26, 9.26e-27, 7e-27, 5.36e-27, 4.26e-27, 3.41e-27,
    2.79e-27, 2.36e-27, 2.01e-27, 1.75e-27, 1.52e-27, 1.33e-27, 1.16e-27,
    1.01e-27, 8.83e-28, 7.71e-28, 6.77e-28, 6.01e-28, 5.34e-28, 4.72e-28,
    4.2e-28, 3.69e-28, 3.27e-28, 2.92e-28, 2.57e-28, 2.27e-28, 2e-28,
    1.77e-28, 1.56e-28, 1.37e-28, 1.2e-28, 1.05e-28, 9.18e-29, 8e-29,
    6.98e-29, 6.08e-29, 5.27e-29, 4.56e-29, 3.94e-29, 3.4e-29, 2.93e-29,
    2.51e-29, 2.15e-29, 1.84e-29, 1.57e-29, 1.34e-29, 1.14e-29, 9.66e-30,
    8.19e-30, 6.93e-30, 5.86e-30, 4.95e-30, 4.19e-30, 3.56e-30, 3.06e-30,
    2.67e-30, 2.41e-30, 2.26e-30, 2.25e-30, 2.36e-30, 2.57e-30, 2.84e-30,
    3.18e-30, 3.49e-30, 3.71e-30, 3.81e-30, 3.84e-30, 3.8e-30, 3.59e-30,
    3.37e-30, 3.08e-30, 2.77e-30, 2.47e-30, 2.2e-30, 2.05e-30, 1.99e-30,
    2.03e-30, 2.13e-30, 2.25e-30, 2.34e-30, 2.41e-30, 2.47e-30, 2.48e-30,
    2.5e-30, 2.52e-30, 2.58e-30, 2.64e-30, 2.69e-30, 2.79e-30, 2.95e-30,
    3.13e-30, 3.34e-30, 3.57e-30, 3.84e-30, 4.2e-30, 4.66e-30, 5.21e-30,
    5.96e-30, 6.89e-30, 8.01e-30, 9.32e-30, 1.08e-29, 1.24e-29, 1.45e-29,
    1.71e-29, 2.01e-29, 2.36e-29, 2.82e-29, 3.38e-29, 4.01e-29, 4.79e-29,
    5.74e-29, 6.92e-29, 8.338e-29, 1.015e-28, 1.246e-28, 1.512e-28, 1.851e-28,
    2.32e-28, 2.988e-28, 3.989e-28, 5.351e-28, 7.256e-28, 1.011e-27,
    1.388e-27,
    1.914e-27, 2.512e-27, 3.257e-27, 4.075e-27, 4.991e-27, 5.914e-27,
    6.638e-27,
    7.16e-27, 7.45e-27, 7.59e-27, 7.54e-27, 7.47e-27, 7.53e-27, 7.94e-27,
    8.46e-27, 8.95e-27, 9.36e-27, 9.84e-27, 1.02e-26, 1.05e-26, 1.06e-26,
    1.07e-26, 1.07e-26, 1.04e-26, 9.79e-27, 8.8e-27, 7.66e-27, 6.38e-27,
    5.142e-27, 3.982e-27, 2.94e-27, 2.177e-27, 1.612e-27, 1.185e-27,
    8.966e-28,
    6.735e-28, 5.219e-28, 4.14e-28, 3.403e-28, 2.811e-28, 2.358e-28,
    1.969e-28,
    1.684e-28, 1.462e-28, 1.285e-28, 1.134e-28, 9.916e-29, 8.65e-29, 7.55e-29,
    6.62e-29, 5.83e-29, 5.14e-29, 4.51e-29, 3.98e-29, 3.53e-29, 3.12e-29,
    2.78e-29, 2.48e-29, 2.18e-29, 1.93e-29, 1.7e-29, 1.5e-29, 1.33e-29,
    1.16e-29, 1.03e-29, 9.01e-30, 7.86e-30, 6.88e-30, 6.02e-30, 5.25e-30,
    4.57e-30, 3.96e-30, 3.44e-30, 2.98e-30, 2.57e-30, 2.21e-30, 1.9e-30,
    1.63e-30, 1.4e-30, 1.21e-30, 1.04e-30, 9.09e-31, 7.96e-31, 7.05e-31,
    6.3e-31, 5.67e-31, 5.09e-31, 4.55e-31, 4.04e-31, 3.55e-31, 3.09e-31,
    2.64e-31, 2.26e-31, 1.9e-31, 1.6e-31, 1.34e-31, 1.14e-31, 1.01e-31,
    9.17e-32, 8.69e-32, 8.47e-32, 8.33e-32, 8.2e-32, 8.04e-32, 7.95e-32,
    7.98e-32, 8.25e-32, 8.47e-32, 8.74e-32, 8.87e-32, 8.92e-32, 8.71e-32,
    8.3e-32, 7.89e-32, 7.59e-32, 7.5e-32, 7.63e-32, 8.06e-32, 8.89e-32,
    1e-31, 1.14e-31, 1.28e-31, 1.45e-31, 1.64e-31, 1.87e-31, 2.12e-31,
    2.44e-31, 2.85e-31, 3.31e-31, 3.83e-31, 4.46e-31, 5.23e-31, 6.15e-31,
    7.35e-31, 8.84e-31, 1.07e-30, 1.29e-30, 1.59e-30, 1.99e-30, 2.49e-30,
    3.12e-30, 3.91e-30, 4.98e-30, 6.28e-30, 7.86e-30, 9.66e-30, 1.16e-29,
    1.41e-29, 1.7e-29, 2.06e-29, 2.54e-29, 3.17e-29, 4.08e-29, 5.24e-29,
    6.8e-29, 8.92e-29, 1.13e-28, 1.4e-28, 1.7e-28, 2.05e-28, 2.37e-28,
    2.61e-28, 2.77e-28, 2.85e-28, 2.86e-28, 2.78e-28, 2.72e-28, 2.74e-28,
    2.83e-28, 3.01e-28, 3.22e-28, 3.52e-28, 3.78e-28, 4.03e-28, 4.21e-28,
    4.33e-28, 4.39e-28, 4.34e-28, 4.25e-28, 4.07e-28, 3.88e-28, 3.67e-28,
    3.56e-28, 3.52e-28, 3.67e-28, 4.02e-28, 4.64e-28, 5.63e-28, 6.89e-28,
    8.82e-28, 1.11e-27, 1.41e-27, 1.73e-27, 2.12e-27, 2.57e-27, 2.99e-27,
    3.45e-27, 3.79e-27, 4.09e-27, 4.23e-27, 4.3e-27, 4.33e-27, 4.35e-27,
    4.44e-27, 4.54e-27, 4.62e-27, 4.67e-27, 4.71e-27, 4.77e-27, 4.93e-27,
    5.19e-27, 5.54e-27, 5.9e-27, 6.12e-27, 6.15e-27, 5.81e-27, 5.21e-27,
    4.51e-27, 3.69e-27, 2.89e-27, 2.14e-27, 1.55e-27, 1.11e-27, 7.78e-28,
    5.46e-28, 3.93e-28, 2.93e-28, 2.26e-28, 1.82e-28, 1.52e-28, 1.31e-28,
    1.15e-28, 1.02e-28, 9.01e-29, 7.95e-29, 7.04e-29, 6.2e-29, 5.49e-29,
    4.86e-29, 4.34e-29, 3.88e-29, 3.46e-29, 3.07e-29, 2.71e-29, 2.38e-29,
    2.09e-29, 1.82e-29, 1.59e-29, 1.38e-29, 1.2e-29, 1.04e-29, 9.08e-30,
    7.88e-30, 6.85e-30, 5.96e-30, 5.2e-30, 4.53e-30, 3.94e-30, 3.43e-30,
    2.97e-30, 2.58e-30, 2.23e-30, 1.92e-30, 1.66e-30, 1.43e-30, 1.24e-30,
    1.06e-30, 9.1e-31, 7.79e-31, 6.65e-31, 5.68e-31, 4.84e-31, 4.11e-31,
    3.51e-31, 2.99e-31, 2.54e-31, 2.17e-31, 1.86e-31, 1.59e-31, 1.37e-31,
    1.18e-31, 1.04e-31, 9.24e-32, 8.39e-32, 7.86e-32, 7.7e-32, 7.85e-32,
    8.41e-32, 9.62e-32, 1.16e-31, 1.47e-31, 1.94e-31, 2.58e-31, 3.51e-31,
    4.73e-31, 6.26e-31, 7.98e-31, 9.95e-31, 1.21e-30, 1.4e-30, 1.58e-30,
    1.77e-30, 1.98e-30, 2.22e-30, 2.47e-30, 2.79e-30, 3.14e-30, 3.55e-30,
    4e-30, 4.51e-30, 5.15e-30, 5.73e-30, 6.25e-30, 6.65e-30, 6.91e-30,
    6.98e-30, 6.83e-30, 6.67e-30, 6.57e-30, 6.6e-30, 6.84e-30, 7.39e-30,
    8.04e-30, 8.73e-30, 9.44e-30, 9.95e-30, 1.03e-29, 1.01e-29, 9.8e-30,
    9.32e-30, 8.67e-30, 7.99e-30, 7.29e-30, 6.67e-30, 6.14e-30, 5.78e-30,
    5.65e-30, 5.65e-30, 5.88e-30, 6.43e-30, 7.5e-30, 9.16e-30, 1.16e-29,
    1.51e-29, 1.99e-29, 2.7e-29, 3.66e-29, 4.95e-29, 6.41e-29, 8.16e-29,
    1.02e-28, 1.24e-28, 1.46e-28, 1.64e-28, 1.79e-28, 1.87e-28, 1.93e-28,
    1.93e-28, 1.93e-28, 1.95e-28, 2.07e-28, 2.23e-28, 2.34e-28, 2.44e-28,
    2.55e-28, 2.67e-28, 2.76e-28, 2.81e-28, 2.9e-28, 2.94e-28, 2.91e-28,
    2.77e-28, 2.52e-28, 2.21e-28, 1.84e-28, 1.49e-28, 1.15e-28, 8.64e-29,
    6.44e-29, 4.79e-29, 3.64e-29, 2.75e-29, 2.14e-29, 1.75e-29, 1.48e-29,
    1.3e-29, 1.16e-29, 1.05e-29, 9.46e-30, 8.55e-30, 7.66e-30, 6.79e-30,
    6.01e-30, 5.3e-30, 4.67e-30, 4.13e-30, 3.67e-30, 3.29e-30, 2.92e-30,
    2.57e-30, 2.27e-30, 1.96e-30, 1.7e-30, 1.47e-30, 1.27e-30, 1.1e-30,
    9.19e-31, 7.79e-31, 6.59e-31, 5.61e-31, 4.81e-31, 4.07e-31, 3.54e-31,
    3.04e-31, 2.62e-31, 2.3e-31, 1.97e-31, 1.71e-31, 1.48e-31, 1.28e-31,
    1.1e-31, 9.44e-32, 8.08e-32, 6.94e-32, 5.93e-32, 5.06e-32, 4.31e-32,
    3.66e-32, 3.12e-32, 2.67e-32, 2.28e-32, 1.95e-32, 1.67e-32, 1.43e-32,
    1.22e-32, 1.05e-32, 9.06e-33, 7.86e-33, 6.87e-33, 6.09e-33, 5.5e-33,
    5.07e-33, 4.78e-33, 4.66e-33, 4.77e-33, 5.21e-33, 5.94e-33, 7.44e-33,
    9.71e-33, 1.35e-32, 1.87e-32, 2.63e-32, 3.67e-32, 4.95e-32, 6.39e-32,
    8e-32, 9.88e-32, 1.15e-31, 1.28e-31, 1.37e-31, 1.43e-31, 1.47e-31,
    1.45e-31, 1.42e-31, 1.4e-31, 1.41e-31, 1.43e-31, 1.51e-31, 1.65e-31,
    1.83e-31, 2.07e-31, 2.25e-31, 2.38e-31, 2.42e-31, 2.38e-31, 2.27e-31,
    2.1e-31, 1.98e-31, 1.89e-31, 1.79e-31, 1.72e-31, 1.62e-31, 1.54e-31,
    1.43e-31, 1.35e-31, 1.35e-31, 1.42e-31, 1.57e-31, 1.77e-31, 2.06e-31,
    2.42e-31, 2.85e-31, 3.43e-31, 4.16e-31, 5.24e-31, 6.82e-31, 8.92e-31,
    1.2e-30, 1.6e-30, 2.15e-30, 2.89e-30, 3.77e-30, 4.8e-30, 5.93e-30,
    7.25e-30, 8.53e-30, 9.6e-30, 1.04e-29, 1.08e-29, 1.1e-29, 1.09e-29,
    1.07e-29, 1.07e-29, 1.12e-29, 1.21e-29, 1.33e-29, 1.48e-29, 1.64e-29,
    1.79e-29, 1.94e-29, 2.05e-29, 2.17e-29, 2.28e-29, 2.4e-29, 2.53e-29,
    2.74e-29, 3.03e-29, 3.42e-29, 3.87e-29, 4.47e-29, 5.19e-29, 5.91e-29,
    6.77e-29, 7.5e-29, 8.28e-29, 8.83e-29, 9.36e-29, 9.91e-29, 1.03e-28,
    1.09e-28, 1.14e-28, 1.17e-28, 1.18e-28, 1.18e-28, 1.18e-28, 1.21e-28,
    1.26e-28, 1.35e-28, 1.43e-28, 1.49e-28, 1.49e-28, 1.4e-28, 1.25e-28,
    1.07e-28, 8.61e-29, 6.57e-29, 4.8e-29, 3.47e-29, 2.47e-29, 1.78e-29,
    1.33e-29, 1.05e-29, 8.72e-30, 7.51e-30, 6.76e-30, 6.27e-30, 6e-30,
    5.99e-30, 6.26e-30, 6.86e-30, 7.58e-30, 8.49e-30, 9.53e-30, 1.05e-29,
    1.14e-29, 1.2e-29, 1.25e-29, 1.28e-29, 1.3e-29, 1.31e-29, 1.32e-29,
    1.33e-29, 1.33e-29, 1.31e-29, 1.27e-29, 1.23e-29, 1.19e-29, 1.2e-29,
    1.25e-29, 1.33e-29, 1.42e-29, 1.48e-29, 1.49e-29, 1.41e-29, 1.26e-29,
    1.08e-29, 8.8e-30, 6.78e-30, 4.95e-30, 3.58e-30, 2.54e-30, 1.78e-30,
    1.26e-30, 9.28e-31, 7.13e-31, 5.56e-31, 4.5e-31, 3.75e-31, 3.21e-31,
    2.76e-31, 2.41e-31, 2.09e-31, 1.82e-31, 1.59e-31, 1.36e-31, 1.18e-31,
    1.03e-31, 9.01e-32, 7.94e-32, 6.9e-32, 6.02e-32, 5.26e-32, 4.62e-32,
    4.06e-32, 3.55e-32, 3.13e-32, 2.76e-32, 2.43e-32, 2.15e-32, 1.9e-32,
    1.68e-32, 1.49e-32, 1.32e-32, 1.17e-32, 1.04e-32, 9.35e-33, 8.47e-33,
    7.79e-33, 7.3e-33, 6.96e-33, 6.88e-33, 7.11e-33, 7.6e-33, 8.67e-33,
    1.04e-32, 1.31e-32, 1.71e-32, 2.2e-32, 2.93e-32, 3.8e-32, 4.97e-32,
    6.22e-32, 7.63e-32, 9.29e-32, 1.1e-31, 1.24e-31, 1.34e-31, 1.41e-31,
    1.44e-31, 1.44e-31, 1.39e-31, 1.38e-31, 1.41e-31, 1.49e-31, 1.64e-31,
    1.86e-31, 2.11e-31, 2.38e-31, 2.65e-31, 2.89e-31, 3.04e-31, 3.14e-31,
    3.29e-31, 3.43e-31, 3.6e-31, 3.91e-31, 4.44e-31, 5.21e-31, 6.43e-31,
    8.18e-31, 1.06e-30, 1.4e-30, 1.78e-30, 2.24e-30, 2.77e-30, 3.35e-30,
    3.95e-30, 4.47e-30, 4.92e-30, 5.2e-30, 5.39e-30, 5.46e-30, 5.53e-30,
    5.66e-30, 6.02e-30, 6.43e-30, 6.68e-30, 6.91e-30, 7.12e-30, 7.42e-30,
    7.55e-30, 7.75e-30, 8.09e-30, 8.3e-30, 8.35e-30, 7.95e-30, 7.22e-30,
    6.3e-30, 5.23e-30, 4.2e-30, 3.19e-30, 2.39e-30, 1.79e-30, 1.36e-30,
    1.05e-30, 8.32e-31, 6.89e-31, 5.89e-31, 5.14e-31, 4.6e-31, 4.19e-31,
    3.94e-31, 3.9e-31, 4.07e-31, 4.39e-31, 4.82e-31, 5.29e-31, 5.75e-31,
    6.09e-31, 6.28e-31, 6.31e-31, 6.19e-31, 6.04e-31, 5.85e-31, 5.71e-31,
    5.68e-31, 5.68e-31, 5.64e-31, 5.58e-31, 5.51e-31, 5.48e-31, 5.45e-31,
    5.57e-31, 5.77e-31, 5.96e-31, 6.05e-31, 5.89e-31, 5.43e-31, 4.77e-31,
    4.02e-31, 3.25e-31, 2.5e-31, 1.82e-31, 1.31e-31, 9.32e-32, 6.58e-32,
    4.64e-32, 3.35e-32, 2.53e-32, 1.96e-32, 1.58e-32, 1.31e-32, 1.11e-32,
    9.58e-33, 8.32e-33, 7.31e-33, 6.43e-33, 5.62e-33, 4.89e-33, 4.27e-33,
    3.73e-33, 3.25e-33, 2.84e-33, 2.5e-33, 2.21e-33, 1.95e-33, 1.72e-33,
    1.52e-33, 1.34e-33, 1.18e-33, 1.05e-33, 9.26e-34, 8.21e-34, 7.29e-34,
    6.48e-34, 5.77e-34, 5.15e-34, 4.62e-34, 4.17e-34, 3.79e-34, 3.49e-34,
    3.26e-34, 3.09e-34, 3e-34, 2.98e-34, 3.04e-34, 3.2e-34, 3.49e-34,
    3.96e-34, 4.68e-34, 5.78e-34, 7.42e-34, 9.8e-34, 1.32e-33, 1.79e-33,
    2.23e-33, 2.65e-33, 3.02e-33, 3.38e-33, 3.74e-33, 4.05e-33, 4.42e-33,
    4.94e-33, 5.48e-33, 6.11e-33, 6.77e-33, 7.56e-33, 8.49e-33, 9.59e-33,
    1.09e-32, 1.27e-32, 1.48e-32, 1.73e-32, 2.08e-32, 2.48e-32, 3.03e-32,
    3.88e-32, 4.86e-32, 6.25e-32, 8.05e-32, 1.04e-31, 1.37e-31, 1.75e-31,
    2.2e-31, 2.75e-31, 3.35e-31, 4.08e-31, 4.79e-31, 5.44e-31, 5.99e-31,
    6.46e-31, 6.82e-31, 7.13e-31, 7.62e-31, 8.36e-31, 9.59e-31, 1.15e-30,
    1.38e-30, 1.67e-30, 1.99e-30, 2.35e-30, 2.74e-30, 3.11e-30, 3.51e-30,
    3.89e-30, 4.21e-30, 4.49e-30, 4.66e-30, 4.86e-30, 4.96e-30, 5.08e-30,
    5.2e-30, 5.29e-30, 5.3e-30, 5.22e-30, 5.16e-30, 5.18e-30, 5.35e-30,
    5.68e-30, 6.07e-30, 6.42e-30, 6.6e-30, 6.39e-30, 5.83e-30, 5.03e-30,
    4.11e-30, 3.2e-30, 2.35e-30, 1.7e-30, 1.2e-30, 8.54e-31, 6.31e-31,
    4.92e-31, 4.01e-31, 3.38e-31, 2.97e-31, 2.71e-31, 2.55e-31, 2.45e-31,
    2.42e-31, 2.43e-31, 2.49e-31, 2.6e-31, 2.73e-31, 2.91e-31, 3.16e-31,
    3.45e-31, 3.81e-31, 4.14e-31, 4.54e-31, 5.02e-31, 5.48e-31, 6.11e-31,
    6.72e-31, 7.37e-31, 7.99e-31, 8.5e-31, 9.01e-31, 9.3e-31, 9.52e-31,
    9.64e-31, 9.59e-31, 9.39e-31, 9.14e-31, 8.95e-31, 8.97e-31, 9.3e-31,
    9.91e-31, 1.06e-30, 1.12e-30, 1.14e-30, 1.1e-30, 1e-30, 8.68e-31,
    7.14e-31, 5.61e-31, 4.17e-31, 3.05e-31, 2.18e-31, 1.55e-31, 1.11e-31,
    8.29e-32, 6.38e-32, 5.07e-32, 4.2e-32, 3.64e-32, 3.28e-32, 3.03e-32,
    2.9e-32, 2.78e-32, 2.67e-32, 2.52e-32, 2.34e-32, 2.15e-32, 1.95e-32,
    1.75e-32, 1.54e-32, 1.32e-32, 1.13e-32, 9.55e-33, 7.9e-33, 6.44e-33,
    5.18e-33, 4.14e-33, 3.32e-33, 2.67e-33, 2.18e-33, 1.83e-33, 1.56e-33,
    1.35e-33, 1.18e-33, 1.05e-33, 9.31e-34, 8.35e-34, 7.55e-34, 6.89e-34,
    6.36e-34, 5.96e-34, 5.69e-34, 5.56e-34, 5.6e-34, 5.86e-34, 6.42e-34,
    7.33e-34, 8.85e-34, 1.14e-33, 1.49e-33, 1.97e-33, 2.69e-33, 3.61e-33,
    4.79e-33, 6.04e-33, 7.51e-33, 9.2e-33, 1.09e-32, 1.26e-32, 1.39e-32,
    1.53e-32, 1.64e-32, 1.71e-32, 1.77e-32, 1.88e-32, 2.08e-32, 2.37e-32,
    2.82e-32, 3.42e-32, 4.18e-32, 5.18e-32, 6.47e-32, 7.98e-32, 9.97e-32,
    1.22e-31, 1.47e-31, 1.75e-31, 2.05e-31, 2.38e-31, 2.66e-31, 2.91e-31,
    3.09e-31, 3.21e-31, 3.29e-31, 3.31e-31, 3.37e-31, 3.49e-31, 3.69e-31,
    3.82e-31, 3.92e-31, 4.05e-31, 4.17e-31, 4.3e-31, 4.42e-31, 4.61e-31,
    4.78e-31, 4.83e-31, 4.69e-31, 4.31e-31, 3.81e-31, 3.21e-31, 2.61e-31,
    2.04e-31, 1.56e-31, 1.2e-31, 9.2e-32, 7.1e-32, 5.65e-32, 4.63e-32,
    3.86e-32, 3.27e-32, 2.83e-32, 2.48e-32, 2.22e-32, 2.03e-32, 1.91e-32,
    1.84e-32, 1.82e-32, 1.82e-32, 1.86e-32, 1.94e-32, 2.11e-32, 2.36e-32,
    2.6e-32, 2.94e-32, 3.31e-32, 3.73e-32, 4.17e-32, 4.57e-32, 4.98e-32,
    5.26e-32, 5.54e-32, 5.79e-32, 6.05e-32, 6.38e-32, 6.71e-32, 6.93e-32,
    7.03e-32, 7.05e-32, 7.05e-32, 7.16e-32, 7.37e-32, 7.79e-32, 8.3e-32,
    8.65e-32, 8.76e-32, 8.32e-32, 7.51e-32, 6.48e-32, 5.31e-32, 4.18e-32,
    3.07e-32, 2.22e-32, 1.57e-32, 1.09e-32, 7.39e-33, 5.11e-33, 3.66e-33,
    2.68e-33, 2e-33, 1.56e-33, 1.27e-33, 1.06e-33, 9.05e-34, 7.85e-34,
    6.9e-34, 6.1e-34, 5.42e-34, 4.84e-34, 4.32e-34, 3.87e-34, 3.47e-34,
    3.12e-34, 2.8e-34, 2.52e-34, 2.27e-34, 2.05e-34, 1.86e-34, 1.69e-34,
    1.55e-34, 1.43e-34, 1.33e-34, 1.25e-34, 1.2e-34, 1.16e-34, 1.15e-34,
    1.16e-34, 1.19e-34, 1.25e-34, 1.34e-34, 1.45e-34, 1.6e-34, 1.78e-34,
    2.01e-34, 2.27e-34, 2.59e-34, 2.96e-34, 3.4e-34, 3.92e-34, 4.53e-34,
    5.24e-34, 6.08e-34, 7.09e-34, 8.31e-34, 9.81e-34, 1.17e-33, 1.42e-33,
    1.78e-33, 2.25e-33, 2.79e-33, 3.5e-33, 4.4e-33, 5.53e-33, 6.92e-33,
    8.92e-33, 1.15e-32, 1.48e-32, 1.92e-32, 2.54e-32, 3.37e-32, 4.37e-32,
    5.71e-32, 7.26e-32, 8.98e-32, 1.1e-31, 1.34e-31, 1.59e-31, 1.86e-31,
    2.14e-31, 2.4e-31, 2.69e-31, 2.98e-31, 3.33e-31, 3.77e-31, 4.25e-31,
    4.75e-31, 5.11e-31, 5.37e-31, 5.56e-31, 5.61e-31, 5.67e-31, 5.68e-31,
    5.78e-31, 5.86e-31, 5.91e-31, 5.93e-31, 5.91e-31, 5.92e-31, 5.93e-31,
    5.94e-31, 5.87e-31, 5.65e-31, 5.21e-31, 4.54e-31, 3.82e-31, 3.07e-31,
    2.37e-31, 1.78e-31, 1.32e-31, 9.82e-32, 7.34e-32, 5.59e-32, 4.33e-32,
    3.42e-32, 2.74e-32, 2.23e-32, 1.86e-32, 1.56e-32, 1.35e-32, 1.17e-32,
    1.05e-32, 9.54e-33, 8.83e-33, 8.34e-33, 8.1e-33, 8.11e-33, 8.2e-33,
    8.46e-33, 8.83e-33, 9.33e-33, 9.92e-33, 1.07e-32, 1.19e-32, 1.35e-32,
    1.58e-32, 1.86e-32, 2.17e-32, 2.52e-32, 2.92e-32, 3.36e-32, 3.83e-32,
    4.3e-32, 4.83e-32, 5.37e-32, 5.81e-32, 6.23e-32, 6.48e-32, 6.77e-32,
    6.99e-32, 7.17e-32, 7.47e-32, 7.66e-32, 7.77e-32, 7.77e-32, 7.72e-32,
    7.77e-32, 7.97e-32, 8.4e-32, 8.9e-32, 9.42e-32, 9.71e-32, 9.55e-32,
    8.85e-32, 7.68e-32, 6.39e-32, 5.02e-32, 3.74e-32, 2.68e-32, 1.87e-32,
    1.33e-32, 9.48e-33, 7e-33, 5.37e-33, 4.17e-33, 3.33e-33, 2.76e-33,
    2.35e-33, 2.04e-33, 1.78e-33, 1.59e-33, 1.42e-33, 1.23e-33, 1.06e-33,
    8.95e-34, 7.45e-34, 6.06e-34, 5.02e-34, 4.22e-34, 3.61e-34, 3.13e-34,
    2.75e-34, 2.45e-34, 2.19e-34, 1.97e-34, 1.79e-34, 1.63e-34, 1.49e-34,
    1.38e-34, 1.29e-34, 1.22e-34, 1.17e-34, 1.14e-34, 1.14e-34, 1.18e-34,
    1.26e-34, 1.41e-34, 1.65e-34, 2.04e-34, 2.65e-34, 3.59e-34, 4.87e-34,
    6.41e-34, 8.47e-34, 1.07e-33, 1.32e-33, 1.66e-33, 2.07e-33, 2.62e-33,
    3.21e-33, 3.94e-33, 4.84e-33, 5.81e-33, 6.84e-33, 7.73e-33, 8.67e-33,
    9.62e-33, 1.06e-32, 1.19e-32, 1.35e-32, 1.56e-32, 1.85e-32, 2.21e-32,
    2.66e-32, 3.14e-32, 3.6e-32, 3.99e-32, 4.22e-32, 4.36e-32, 4.35e-32,
    4.25e-32, 4.1e-32, 3.99e-32, 3.95e-32, 3.87e-32, 3.83e-32, 3.82e-32,
    3.89e-32, 3.98e-32, 4.06e-32, 4.19e-32, 4.22e-32, 4.17e-32, 3.9e-32,
    3.5e-32, 3.03e-32, 2.49e-32, 1.99e-32, 1.51e-32, 1.15e-32, 8.68e-33,
    6.53e-33, 4.89e-33, 3.78e-33, 2.92e-33, 2.25e-33, 1.74e-33, 1.35e-33,
    1.07e-33, 8.54e-34, 7.02e-34, 5.95e-34, 5.13e-34, 4.48e-34, 3.89e-34,
    3.34e-34, 2.94e-34, 2.63e-34, 2.42e-34, 2.3e-34, 2.27e-34, 2.37e-34,
    2.56e-34, 2.78e-34, 3.16e-34, 3.8e-34, 4.86e-34, 6.25e-34, 8.15e-34,
    1.01e-33, 1.24e-33, 1.49e-33, 1.73e-33, 1.99e-33, 2.22e-33, 2.44e-33,
    2.61e-33, 2.72e-33, 2.85e-33, 2.94e-33, 3.1e-33, 3.29e-33, 3.5e-33,
    3.62e-33, 3.66e-33, 3.7e-33, 3.72e-33, 3.83e-33, 4.01e-33, 4.26e-33,
    4.51e-33, 4.64e-33, 4.49e-33, 4.05e-33, 3.45e-33, 2.79e-33, 2.12e-33,
    1.46e-33, 9.67e-34, 6.18e-34, 3.98e-34, 2.63e-34, 1.81e-34, 1.32e-34,
    1.03e-34, 8.42e-35, 7.22e-35, 6.39e-35, 5.78e-35, 5.33e-35, 5e-35,
    4.76e-35, 4.61e-35, 4.54e-35, 4.55e-35, 4.64e-35, 4.81e-35, 5.06e-35,
    5.41e-35, 5.87e-35, 6.44e-35, 7.15e-35, 8.02e-35, 9.1e-35, 1.05e-34,
    1.22e-34, 1.46e-34, 1.8e-34, 2.28e-34, 2.98e-34, 4.02e-34, 5.53e-34,
    7.81e-34, 1.04e-33, 1.31e-33, 1.58e-33, 1.89e-33, 2.2e-33, 2.54e-33,
    3.01e-33, 3.67e-33, 4.43e-33, 5.42e-33, 6.85e-33, 8.44e-33, 1.04e-32,
    1.31e-32, 1.61e-32, 1.95e-32, 2.38e-32, 2.88e-32, 3.42e-32, 4.03e-32,
    4.65e-32, 5.24e-32, 5.7e-32, 6.09e-32, 6.39e-32, 6.48e-32, 6.58e-32,
    6.66e-32, 6.7e-32, 6.66e-32, 6.65e-32, 6.8e-32, 7.09e-32, 7.54e-32,
    8.06e-32, 8.62e-32, 8.89e-32, 8.68e-32, 8.04e-32, 7e-32, 5.83e-32,
    4.58e-32, 3.49e-32, 2.71e-32, 2.1e-32, 1.65e-32, 1.31e-32, 1.06e-32,
    8.35e-33, 6.45e-33, 5.02e-33, 3.94e-33, 3.09e-33, 2.46e-33
  };
 
  static const double tcoslf_table[2001] =
    { 6.413, 6.414, 6.275, 6.049, 5.789, 5.557, 5.33,
    5.107, 4.893, 4.685, 4.481, 4.282, 4.09, 3.905,
    3.72, 3.548, 3.379, 3.215, 3.056, 2.903, 2.756,
    2.614, 2.475, 2.344, 2.219, 2.1, 1.983, 1.873,
    1.768, 1.67, 1.575, 1.486, 1.45, 1.432, 1.429,
    1.431, 1.428, 1.458, 1.517, 1.57, 1.628, 1.689,
    1.753, 1.819, 1.886, 1.976, 2.032, 2.106, 2.19,
    2.259, 2.33, 2.397, 2.466, 2.537, 2.613, 2.675,
    2.746, 2.819, 2.893, 2.97, 3.058, 3.168, 3.319,
    3.456, 3.601, 3.752, 3.9, 4.04, 4.183, 4.327,
    4.47, 4.602, 4.753, 4.897, 5.039, 5.214, 5.409,
    5.608, 5.782, 5.917, 5.983, 5.998, 6.016, 6.016,
    6.037, 6.026, 6.018, 6.021, 6.006, 6.005, 5.988,
    5.978, 5.956, 5.947, 5.898, 5.91, 5.88, 5.842,
    5.819, 5.772, 5.775, 5.74, 5.712, 5.685, 5.659,
    5.631, 5.601, 5.574, 5.541, 5.509, 5.474, 5.437,
    5.399, 5.359, 5.314, 5.261, 5.205, 5.146, 5.075,
    4.997, 4.909, 4.818, 4.709, 4.575, 4.411, 4.245,
    4.075, 3.889, 3.672, 3.387, 3.173, 2.907, 2.708,
    2.536, 2.35, 2.273, 2.196, 2.178, 2.201, 2.238,
    2.309, 2.382, 2.462, 2.579, 2.679, 2.737, 2.81,
    2.887, 2.964, 2.98, 3.011, 3.098, 3.157, 3.211,
    3.274, 3.388, 3.475, 3.527, 3.618, 3.772, 3.864,
    3.884, 3.889, 3.894, 3.884, 3.821, 3.758, 3.703,
    3.657, 3.567, 3.49, 3.435, 3.377, 3.29, 3.204,
    3.178, 3.146, 3.103, 3.088, 3.108, 3.116, 3.07,
    3.046, 3.029, 3.017, 3.001, 3.007, 2.984, 2.98,
    2.936, 2.908, 2.896, 2.875, 2.893, 2.888, 2.948,
    3.028, 3.064, 3.182, 3.228, 3.26, 3.335, 3.412,
    3.468, 3.523, 3.616, 3.659, 3.704, 3.81, 3.833,
    3.966, 4.026, 4.088, 4.141, 4.2, 4.269, 4.377,
    4.459, 4.566, 4.638, 4.709, 4.802, 4.878, 4.974,
    5.047, 5.147, 5.211, 5.315, 5.391, 5.483, 5.566,
    5.603, 5.643, 5.767, 5.807, 5.843, 5.904, 5.924,
    5.983, 5.993, 6.059, 6.095, 6.13, 6.153, 6.174,
    6.18, 6.201, 6.202, 6.21, 6.206, 6.209, 6.187,
    6.172, 6.138, 6.129, 6.085, 6.066, 6.043, 6.001,
    5.951, 5.93, 5.869, 5.822, 5.809, 5.777, 5.739,
    5.7, 5.68, 5.659, 5.598, 5.558, 5.519, 5.465,
    5.399, 5.358, 5.294, 5.225, 5.158, 5.094, 5.023,
    4.94, 4.846, 4.759, 4.662, 4.557, 4.435, 4.304,
    4.188, 4.042, 3.954, 3.803, 3.695, 3.619, 3.51,
    3.414, 3.366, 3.284, 3.217, 3.152, 3.044, 2.983,
    2.898, 2.784, 2.68, 2.627, 2.634, 2.704, 2.637,
    2.756, 2.79, 2.941, 3.091, 3.203, 3.308, 3.431,
    3.49, 3.57, 3.652, 3.683, 3.708, 3.722, 3.687,
    3.631, 3.584, 3.566, 3.536, 3.459, 3.401, 3.326,
    3.216, 3.103, 2.944, 2.828, 2.652, 2.597, 2.559,
    2.522, 2.468, 2.466, 2.43, 2.412, 2.383, 2.357,
    2.338, 2.312, 2.287, 2.25, 2.221, 2.174, 2.174,
    2.135, 2.109, 2.107, 2.106, 2.062, 2.075, 2.08,
    2.136, 2.219, 2.291, 2.415, 2.52, 2.663, 2.797,
    2.936, 3.112, 3.244, 3.347, 3.437, 3.501, 3.513,
    3.511, 3.515, 3.553, 3.553, 3.568, 3.621, 3.713,
    3.836, 3.888, 3.897, 3.874, 3.825, 3.743, 3.626,
    3.503, 3.365, 3.225, 3.077, 2.914, 2.764, 2.623,
    2.508, 2.433, 2.42, 2.41, 2.445, 2.49, 2.623,
    2.753, 2.871, 2.981, 3.069, 3.176, 3.27, 3.339,
    3.394, 3.45, 3.511, 3.572, 3.623, 3.668, 3.742,
    3.807, 3.893, 3.961, 4.019, 4.106, 4.194, 4.286,
    4.364, 4.447, 4.532, 4.629, 4.719, 4.815, 4.9,
    4.989, 5.067, 5.16, 5.245, 5.326, 5.406, 5.479,
    5.558, 5.632, 5.702, 5.772, 5.831, 5.893, 5.953,
    6.009, 6.056, 6.103, 6.143, 6.183, 6.21, 6.239,
    6.258, 6.264, 6.263, 6.247, 6.229, 6.201, 6.176,
    6.141, 6.11, 6.096, 6.085, 6.071, 6.05, 6.053,
    6.042, 6.035, 6.018, 6.005, 5.99, 5.955, 5.931,
    5.884, 5.833, 5.782, 5.724, 5.664, 5.594, 5.542,
    5.484, 5.422, 5.351, 5.284, 5.222, 5.143, 5.063,
    4.978, 4.896, 4.81, 4.723, 4.625, 4.525, 4.431,
    4.334, 4.231, 4.123, 4.022, 3.918, 3.831, 3.726,
    3.624, 3.537, 3.454, 3.367, 3.279, 3.211, 3.137,
    3.056, 2.968, 2.876, 2.764, 2.638, 2.486, 2.392,
    2.28, 2.193, 2.08, 2.056, 2.097, 2.155, 2.239,
    2.327, 2.461, 2.617, 2.759, 2.925, 3.082, 3.253,
    3.366, 3.491, 3.58, 3.67, 3.733, 3.756, 3.735,
    3.663, 3.612, 3.604, 3.655, 3.671, 3.68, 3.721,
    3.769, 3.769, 3.71, 3.605, 3.493, 3.383, 3.231,
    3.109, 2.936, 2.781, 2.645, 2.514, 2.397, 2.304,
    2.236, 2.212, 2.195, 2.204, 2.248, 2.337, 2.464,
    2.575, 2.714, 2.815, 2.941, 3.072, 3.173, 3.263,
    3.331, 3.398, 3.471, 3.531, 3.597, 3.657, 3.737,
    3.8, 3.844, 3.932, 3.997, 4.062, 4.135, 4.214,
    4.303, 4.378, 4.46, 4.563, 4.642, 4.72, 4.808,
    4.885, 4.978, 5.063, 5.142, 5.234, 5.318, 5.395,
    5.482, 5.553, 5.624, 5.684, 5.737, 5.792, 5.84,
    5.886, 5.925, 5.969, 6.01, 6.043, 6.078, 6.109,
    6.142, 6.159, 6.184, 6.201, 6.207, 6.211, 6.207,
    6.204, 6.187, 6.17, 6.151, 6.126, 6.099, 6.067,
    6.033, 5.992, 5.956, 5.919, 5.885, 5.847, 5.813,
    5.787, 5.755, 5.725, 5.687, 5.651, 5.607, 5.557,
    5.51, 5.458, 5.406, 5.35, 5.29, 5.225, 5.163,
    5.094, 5.013, 4.933, 4.852, 4.756, 4.661, 4.554,
    4.44, 4.326, 4.198, 4.078, 3.961, 3.823, 3.714,
    3.606, 3.527, 3.43, 3.345, 3.28, 3.216, 3.151,
    3.057, 2.985, 2.902, 2.786, 2.694, 2.64, 2.634,
    2.655, 2.667, 2.741, 2.824, 2.955, 3.069, 3.196,
    3.298, 3.408, 3.501, 3.577, 3.642, 3.673, 3.712,
    3.712, 3.688, 3.632, 3.598, 3.567, 3.536, 3.461,
    3.398, 3.331, 3.211, 3.099, 2.947, 2.825, 2.651,
    2.467, 2.338, 2.184, 2.098, 2.061, 2.037, 2.101,
    2.154, 2.279, 2.397, 2.514, 2.669, 2.799, 2.946,
    3.099, 3.232, 3.331, 3.404, 3.471, 3.481, 3.516,
    3.537, 3.587, 3.613, 3.637, 3.702, 3.772, 3.874,
    3.898, 3.883, 3.84, 3.771, 3.692, 3.566, 3.436,
    3.29, 3.133, 3.002, 2.833, 2.686, 2.565, 2.498,
    2.489, 2.51, 2.575, 2.69, 2.836, 2.967, 3.067,
    3.15, 3.215, 3.275, 3.333, 3.369, 3.416, 3.478,
    3.526, 3.563, 3.603, 3.649, 3.678, 3.694, 3.716,
    3.74, 3.761, 3.8, 3.831, 3.874, 3.942, 4.005,
    4.099, 4.193, 4.29, 4.387, 4.497, 4.617, 4.715,
    4.805, 4.894, 4.991, 5.084, 5.161, 5.236, 5.3,
    5.368, 5.454, 5.529, 5.589, 5.654, 5.714, 5.786,
    5.838, 5.886, 5.947, 5.987, 6.032, 6.071, 6.099,
    6.122, 6.136, 6.147, 6.151, 6.144, 6.129, 6.104,
    6.063, 6.008, 5.936, 5.835, 5.713, 5.572, 5.404,
    5.225, 5.042, 4.88, 4.718, 4.576, 4.46, 4.355,
    4.234, 4.111, 3.975, 3.888, 3.766, 3.683, 3.633,
    3.637, 3.669, 3.702, 3.739, 3.804, 3.87, 3.916,
    3.948, 3.943, 3.971, 3.98, 3.982, 3.967, 3.95,
    3.947, 3.92, 3.888, 3.819, 3.756, 3.689, 3.618,
    3.523, 3.405, 3.303, 3.206, 3.098, 2.963, 2.816,
    2.667, 2.521, 2.39, 2.261, 2.135, 2.031, 1.988,
    1.995, 2.044, 2.105, 2.189, 2.315, 2.445, 2.592,
    2.745, 2.907, 3.07, 3.231, 3.34, 3.45, 3.547,
    3.617, 3.682, 3.683, 3.653, 3.577, 3.558, 3.572,
    3.597, 3.648, 3.693, 3.772, 3.801, 3.772, 3.703,
    3.597, 3.459, 3.335, 3.189, 3.054, 2.901, 2.756,
    2.629, 2.519, 2.415, 2.379, 2.391, 2.433, 2.485,
    2.612, 2.787, 2.913, 3.033, 3.11, 3.185, 3.21,
    3.254, 3.286, 3.316, 3.334, 3.376, 3.422, 3.443,
    3.471, 3.492, 3.496, 3.491, 3.491, 3.481, 3.46,
    3.475, 3.466, 3.471, 3.485, 3.482, 3.548, 3.566,
    3.643, 3.748, 3.8, 3.956, 4.068, 4.223, 4.357,
    4.506, 4.634, 4.752, 4.839, 4.89, 4.95, 5.034,
    5.113, 5.176, 5.228, 5.383, 5.523, 5.62, 5.705,
    5.775, 5.823, 5.885, 5.931, 5.96, 5.985, 6.006,
    6.019, 6.021, 6.015, 5.997, 5.954, 5.901, 5.817,
    5.716, 5.554, 5.389, 5.18, 4.951, 4.772, 4.646,
    4.551, 4.424, 4.389, 4.41, 4.457, 4.471, 4.473,
    4.545, 4.605, 4.644, 4.652, 4.669, 4.666, 4.639,
    4.603, 4.531, 4.493, 4.449, 4.411, 4.361, 4.304,
    4.269, 4.212, 4.17, 4.152, 4.133, 4.119, 4.1,
    4.105, 4.096, 4.042, 3.964, 3.876, 3.779, 3.652,
    3.513, 3.359, 3.201, 3.075, 2.935, 2.775, 2.682,
    2.601, 2.613, 2.64, 2.663, 2.73, 2.82, 2.936,
    3.052, 3.149, 3.243, 3.322, 3.394, 3.441, 3.479,
    3.449, 3.423, 3.388, 3.331, 3.253, 3.153, 3.109,
    3.05, 2.952, 2.864, 2.808, 2.708, 2.657, 2.594,
    2.554, 2.543, 2.549, 2.623, 2.708, 2.798, 2.909,
    3.039, 3.161, 3.244, 3.293, 3.358, 3.389, 3.424,
    3.489, 3.559, 3.601, 3.641, 3.707, 3.791, 3.879,
    3.902, 3.873, 3.811, 3.726, 3.637, 3.519, 3.357,
    3.205, 3.055, 2.898, 2.737, 2.612, 2.543, 2.531,
    2.589, 2.697, 2.819, 2.914, 2.991, 3.045, 3.067,
    3.06, 3.082, 3.087, 3.11, 3.145, 3.183, 3.249,
    3.296, 3.346, 3.399, 3.409, 3.449, 3.472, 3.497,
    3.55, 3.593, 3.638, 3.674, 3.731, 3.795, 3.863,
    3.874, 3.845, 3.808, 3.739, 3.661, 3.556, 3.411,
    3.273, 3.139, 3.009, 2.865, 2.736, 2.675, 2.674,
    2.73, 2.845, 2.969, 3.148, 3.3, 3.429, 3.55,
    3.642, 3.721, 3.797, 3.866, 3.918, 3.992, 4.054,
    4.117, 4.18, 4.237, 4.318, 4.4, 4.482, 4.567,
    4.648, 4.735, 4.813, 4.886, 4.958, 5.022, 5.083,
    5.137, 5.186, 5.231, 5.266, 5.295, 5.317, 5.324,
    5.311, 5.287, 5.248, 5.178, 5.076, 4.954, 4.793,
    4.605, 4.349, 4.099, 3.939, 3.72, 3.578, 3.462,
    3.431, 3.463, 3.48, 3.528, 3.564, 3.631, 3.705,
    3.747, 3.782, 3.802, 3.825, 3.821, 3.787, 3.737,
    3.698, 3.642, 3.563, 3.445, 3.32, 3.2, 3.072,
    2.931, 2.722, 2.582, 2.409, 2.311, 2.237, 2.194,
    2.209, 2.256, 2.352, 2.45, 2.584, 2.72, 2.87,
    3.018, 3.184, 3.316, 3.408, 3.506, 3.577, 3.623,
    3.604, 3.565, 3.555, 3.562, 3.585, 3.603, 3.681,
    3.774, 3.838, 3.83, 3.779, 3.711, 3.592, 3.455,
    3.326, 3.157, 3.007, 2.847, 2.702, 2.583, 2.503,
    2.479, 2.513, 2.588, 2.656, 2.78, 2.894, 2.967,
    3.026, 3.076, 3.122, 3.164, 3.212, 3.282, 3.335,
    3.405, 3.468, 3.508, 3.546, 3.57, 3.591, 3.575,
    3.576, 3.611, 3.619, 3.649, 3.675, 3.764, 3.854,
    3.88, 3.873, 3.83, 3.767, 3.673, 3.556, 3.44,
    3.309, 3.188, 3.07, 2.969, 2.906, 2.871, 2.904,
    3.003, 3.162, 3.317, 3.469, 3.647, 3.774, 3.884,
    3.98, 4.066, 4.143, 4.225, 4.323, 4.419, 4.515,
    4.603, 4.707, 4.809, 4.893, 4.984, 5.071, 5.156,
    5.251, 5.329, 5.407, 5.478, 5.543, 5.594, 5.641,
    5.684, 5.708, 5.73, 5.741, 5.745, 5.738, 5.727,
    5.701, 5.676, 5.633, 5.591, 5.547, 5.489, 5.431,
    5.368, 5.299, 5.224, 5.154, 5.069, 4.99, 4.903,
    4.812, 4.717, 4.615, 4.513, 4.404, 4.29, 4.162,
    4.023, 3.904, 3.796, 3.683, 3.552, 3.424, 3.295,
    3.189, 3.034, 2.878, 2.751, 2.577, 2.47, 2.358,
    2.215, 2.154, 2.105, 2.104, 2.117, 2.129, 2.184,
    2.237, 2.298, 2.374, 2.462, 2.52, 2.606, 2.6,
    2.596, 2.619, 2.618, 2.572, 2.536, 2.573, 2.618,
    2.634, 2.646, 2.714, 2.787, 2.875, 2.963, 3.065,
    3.179, 3.253, 3.316, 3.352, 3.393, 3.404, 3.445,
    3.496, 3.547, 3.597, 3.632, 3.712, 3.787, 3.846,
    3.85, 3.806, 3.747, 3.662, 3.573, 3.424, 3.274,
    3.142, 3.017, 2.87, 2.765, 2.73, 2.781, 2.864,
    2.937, 3.002, 3.032, 3.044, 3.027, 3.007, 2.979,
    2.934, 2.897, 2.887, 2.875, 2.853, 2.848, 2.859,
    2.903, 2.925, 2.953, 3.006, 3.061, 3.12, 3.184,
    3.277, 3.343, 3.374, 3.422, 3.481, 3.521, 3.588,
    3.641, 3.695, 3.742, 3.776, 3.85, 3.899, 3.919,
    3.891, 3.84, 3.761, 3.662, 3.562, 3.395, 3.261,
    3.131, 3.018, 2.887, 2.802, 2.796, 2.87, 2.986,
    3.102, 3.247, 3.332, 3.4, 3.455, 3.511, 3.567,
    3.624, 3.671, 3.702, 3.734, 3.782, 3.823, 3.835,
    3.851, 3.883, 3.919, 3.949, 3.975, 4.014, 4.061,
    4.13, 4.218, 4.317, 4.422, 4.559, 4.68, 4.776,
    4.862, 4.932, 4.991, 5.033, 5.078, 5.106, 5.117,
    5.119, 5.095, 5.053, 4.988, 4.896, 4.785, 4.648,
    4.498, 4.352, 4.161, 4.005, 3.841, 3.673, 3.543,
    3.398, 3.323, 3.23, 3.17, 3.118, 3.049, 3,
    2.932, 2.83, 2.744, 2.617, 2.49, 2.368, 2.261,
    2.172, 2.135, 2.165, 2.189, 2.229, 2.313, 2.407,
    2.503, 2.601, 2.723, 2.853, 2.968, 3.109, 3.253,
    3.342, 3.43, 3.521, 3.572, 3.613, 3.582, 3.603,
    3.622, 3.633, 3.662, 3.702, 3.806, 3.86, 3.85,
    3.796, 3.722, 3.618, 3.481, 3.347, 3.2, 3.082,
    2.952, 2.846, 2.798, 2.783, 2.848, 2.912, 2.97,
    3.023, 3.085, 3.107, 3.104, 3.067, 3.034, 2.996,
    2.941, 2.914, 2.897, 2.887, 2.903, 2.915, 2.92,
    2.969, 3.023, 3.104, 3.174, 3.268, 3.393, 3.481,
    3.557, 3.633, 3.662, 3.664, 3.665, 3.712, 3.729,
    3.739, 3.774, 3.844, 3.971, 4.023, 4.02, 3.983,
    3.913, 3.853, 3.703, 3.511, 3.351, 3.168, 3.014,
    2.897, 2.844, 2.918, 3.074, 3.295, 3.464, 3.614,
    3.74, 3.858, 3.972, 4.079, 4.188, 4.286, 4.385,
    4.486, 4.581, 4.678, 4.767, 4.855, 4.937, 5.008,
    5.079, 5.137, 5.187, 5.225, 5.255, 5.271, 5.273,
    5.264, 5.247, 5.216, 5.176, 5.131, 5.072, 5.007,
    4.941, 4.865, 4.785, 4.704, 4.617, 4.529, 4.439,
    4.348, 4.251, 4.153, 4.047, 3.942, 3.826, 3.697,
    3.562, 3.403, 3.239, 3.069, 2.915, 2.731, 2.531,
    2.341, 2.183, 2.069, 1.908, 1.781, 1.717, 1.691,
    1.629, 1.601, 1.635, 1.693, 1.756, 1.826, 1.951,
    2.048, 2.126, 2.238, 2.359, 2.474, 2.578, 2.696,
    2.803, 2.875, 2.968, 3.056, 3.12, 3.174, 3.258,
    3.342, 3.398, 3.466, 3.531, 3.623, 3.712, 3.772,
    3.806, 3.811, 3.796, 3.777, 3.757, 3.752, 3.707,
    3.672, 3.627, 3.572, 3.506, 3.398, 3.316, 3.227,
    3.12, 3.033, 3.028, 3.04, 3.092, 3.143, 3.177,
    3.227, 3.242, 3.265, 3.267, 3.243, 3.215, 3.21,
    3.215, 3.226, 3.236, 3.258, 3.289, 3.279, 3.268,
    3.242, 3.147, 3.11, 3.044, 2.985, 2.903, 2.832,
    2.808, 2.782, 2.797, 2.832, 2.903, 2.979, 3.061,
    3.163, 3.247, 3.331, 3.383, 3.419, 3.46, 3.496,
    3.518, 3.557, 3.623, 3.679, 3.725, 3.762, 3.821,
    3.864, 3.899, 3.892, 3.829, 3.752, 3.661, 3.565,
    3.44, 3.331, 3.231, 3.13, 3.018, 2.99, 3.044,
    3.098, 3.194, 3.294, 3.382, 3.44, 3.485, 3.522,
    3.55, 3.568, 3.623, 3.668, 3.715, 3.774, 3.841,
    3.903, 3.952, 3.981, 4.009, 4.044, 4.062, 4.099,
    4.142, 4.207, 4.286, 4.378, 4.483, 4.578, 4.679,
    4.771, 4.857, 4.934, 5.007, 5.086, 5.154, 5.224,
    5.295, 5.358, 5.427, 5.489, 5.55, 5.612, 5.671,
    5.729, 5.782, 5.836, 5.885, 5.933, 5.978, 6.023,
    6.065, 6.102, 6.136, 6.169, 6.197, 6.228, 6.253,
    6.275, 6.292, 6.309, 6.323, 6.334, 6.341, 6.349,
    6.356, 6.359, 6.359, 6.359, 6.359, 6.356, 6.352,
    6.349, 6.342, 6.335, 6.331, 6.324, 6.317, 6.309,
    6.306, 6.299, 6.295, 6.288, 6.284, 6.281, 6.281,
    6.278, 6.277, 6.278, 6.277, 6.282, 6.283, 6.289,
    6.297, 6.3, 6.305, 6.317, 6.325, 6.337, 6.345,
    6.36, 6.37, 6.384, 6.398, 6.416, 6.43, 6.448,
    6.465, 6.483, 6.502, 6.52, 6.541, 6.562, 6.583,
    6.605, 6.628, 6.649, 6.672, 6.697, 6.72, 6.743,
    6.768, 6.791, 6.818, 6.841, 6.867, 6.891, 6.916,
    6.943, 6.97, 6.996, 7.022, 7.052, 7.077, 7.103,
    7.132, 7.158, 7.185, 7.215, 7.241, 7.269, 7.298,
    7.326, 7.354, 7.382, 7.41, 7.438, 7.469, 7.497,
    7.528, 7.555, 7.585, 7.613, 7.643, 7.669, 7.698,
    7.729, 7.759, 7.787, 7.819, 7.849, 7.878, 7.909,
    7.936, 7.968, 7.998, 8.03, 8.055, 8.088, 8.115,
    8.146, 8.18, 8.205, 8.235, 8.269, 8.297, 8.328,
    8.36, 8.393, 8.421, 8.452, 8.484, 8.513, 8.547,
    8.576, 8.607, 8.64, 8.671, 8.699, 8.733, 8.762,
    8.794, 8.827, 8.855, 8.891, 8.922, 8.954, 8.984,
    9.015, 9.049, 9.08, 9.114, 9.143, 9.175, 9.209,
    9.241, 9.271, 9.306, 9.338, 9.369, 9.403, 9.435,
    9.466, 9.5, 9.532, 9.562, 9.594, 9.63, 9.661,
    9.695, 9.726, 9.761, 9.792, 9.825, 9.859, 9.891,
    9.924, 9.954, 9.987, 10.02, 10.06, 10.09, 10.12,
    10.16, 10.19, 10.22, 10.26, 10.29, 10.32
  };
 
  /* Get MT_CKD 4.1 H2O continuum absorption... */
  const double xw = nu / 10 + 1;
  if (xw >= 1 && xw < 2001) {
    const int iw = (int) xw;
    const double dw = xw - iw;
    const double ew = 1 - dw;
    const double cwslf = ew * h2oslf[iw - 1] + dw * h2oslf[iw];
    const double cwfrn = ew * h2ofrn[iw - 1] + dw * h2ofrn[iw];
    const double tcoslf = ew * tcoslf_table[iw - 1]
      + dw * tcoslf_table[iw];
    const double ctwslf = cwslf * pow(296 / t, tcoslf);
    const double a1 = nu * u * tanh(.7193876 / t * nu);
    const double a2 = 296 / t;
    const double a3 = p / 1013 * (q * ctwslf + (1 - q) * cwfrn);
    return a1 * a2 * a3;
  } else
    return 0;
}
 
/*****************************************************************************/
 
double ctmn2(
  const double nu,
  const double p,
  const double t) {
 
  static const double ba[98] =
    { 0., 4.45e-8, 5.22e-8, 6.46e-8, 7.75e-8, 9.03e-8,
    1.06e-7, 1.21e-7, 1.37e-7, 1.57e-7, 1.75e-7, 2.01e-7, 2.3e-7,
    2.59e-7, 2.95e-7, 3.26e-7, 3.66e-7, 4.05e-7, 4.47e-7, 4.92e-7,
    5.34e-7, 5.84e-7, 6.24e-7, 6.67e-7, 7.14e-7, 7.26e-7, 7.54e-7,
    7.84e-7, 8.09e-7, 8.42e-7, 8.62e-7, 8.87e-7, 9.11e-7, 9.36e-7,
    9.76e-7, 1.03e-6, 1.11e-6, 1.23e-6, 1.39e-6, 1.61e-6, 1.76e-6,
    1.94e-6, 1.97e-6, 1.87e-6, 1.75e-6, 1.56e-6, 1.42e-6, 1.35e-6,
    1.32e-6, 1.29e-6, 1.29e-6, 1.29e-6, 1.3e-6, 1.32e-6, 1.33e-6,
    1.34e-6, 1.35e-6, 1.33e-6, 1.31e-6, 1.29e-6, 1.24e-6, 1.2e-6,
    1.16e-6, 1.1e-6, 1.04e-6, 9.96e-7, 9.38e-7, 8.63e-7, 7.98e-7,
    7.26e-7, 6.55e-7, 5.94e-7, 5.35e-7, 4.74e-7, 4.24e-7, 3.77e-7,
    3.33e-7, 2.96e-7, 2.63e-7, 2.34e-7, 2.08e-7, 1.85e-7, 1.67e-7,
    1.47e-7, 1.32e-7, 1.2e-7, 1.09e-7, 9.85e-8, 9.08e-8, 8.18e-8,
    7.56e-8, 6.85e-8, 6.14e-8, 5.83e-8, 5.77e-8, 5e-8, 4.32e-8, 0.
  };
 
  static const double betaa[98] =
    { 802., 802., 761., 722., 679., 646., 609., 562.,
    511., 472., 436., 406., 377., 355., 338., 319., 299., 278., 255.,
    233., 208., 184., 149., 107., 66., 25., -13., -49., -82., -104.,
    -119., -130., -139., -144., -146., -146., -147., -148., -150.,
    -153., -160., -169., -181., -189., -195., -200., -205., -209.,
    -211., -210., -210., -209., -205., -199., -190., -180., -168.,
    -157., -143., -126., -108., -89., -63., -32., 1., 35., 65., 95.,
    121., 141., 152., 161., 164., 164., 161., 155., 148., 143., 137.,
    133., 131., 133., 139., 150., 165., 187., 213., 248., 284., 321.,
    372., 449., 514., 569., 609., 642., 673., 673.
  };
 
  static const double nua[98] =
    { 2120., 2125., 2130., 2135., 2140., 2145., 2150.,
    2155., 2160., 2165., 2170., 2175., 2180., 2185., 2190., 2195.,
    2200., 2205., 2210., 2215., 2220., 2225., 2230., 2235., 2240.,
    2245., 2250., 2255., 2260., 2265., 2270., 2275., 2280., 2285.,
    2290., 2295., 2300., 2305., 2310., 2315., 2320., 2325., 2330.,
    2335., 2340., 2345., 2350., 2355., 2360., 2365., 2370., 2375.,
    2380., 2385., 2390., 2395., 2400., 2405., 2410., 2415., 2420.,
    2425., 2430., 2435., 2440., 2445., 2450., 2455., 2460., 2465.,
    2470., 2475., 2480., 2485., 2490., 2495., 2500., 2505., 2510.,
    2515., 2520., 2525., 2530., 2535., 2540., 2545., 2550., 2555.,
    2560., 2565., 2570., 2575., 2580., 2585., 2590., 2595., 2600., 2605.
  };
 
  const double t0 = 273.0, tr = 296.0;
 
  /* Check wavenumber range... */
  if (nu < nua[0] || nu > nua[97])
    return 0;
 
  /* Interpolate B and beta... */
  const int idx = locate_reg(nua, 98, nu);
  const double b =
    1e6 * LIN(nua[idx], ba[idx], nua[idx + 1], ba[idx + 1], nu);
  const double beta =
    LIN(nua[idx], betaa[idx], nua[idx + 1], betaa[idx + 1], nu);
 
  /* Compute absorption coefficient... */
  return 0.1 * POW2(p / P0 * t0 / t) * exp(beta * (1 / tr - 1 / t))
    * N2 * b * (N2 + (1 - N2) * (1.294 - 0.4545 * t / tr));
}
 
/*****************************************************************************/
 
double ctmo2(
  const double nu,
  const double p,
  const double t) {
 
  static const double ba[90] =
    { 0., .061, .074, .084, .096, .12, .162, .208, .246,
    .285, .314, .38, .444, .5, .571, .673, .768, .853, .966, 1.097,
    1.214, 1.333, 1.466, 1.591, 1.693, 1.796, 1.922, 2.037, 2.154,
    2.264, 2.375, 2.508, 2.671, 2.847, 3.066, 3.417, 3.828, 4.204,
    4.453, 4.599, 4.528, 4.284, 3.955, 3.678, 3.477, 3.346, 3.29,
    3.251, 3.231, 3.226, 3.212, 3.192, 3.108, 3.033, 2.911, 2.798,
    2.646, 2.508, 2.322, 2.13, 1.928, 1.757, 1.588, 1.417, 1.253,
    1.109, .99, .888, .791, .678, .587, .524, .464, .403, .357, .32,
    .29, .267, .242, .215, .182, .16, .146, .128, .103, .087, .081,
    .071, .064, 0.
  };
 
  static const double betaa[90] =
    { 467., 467., 400., 315., 379., 368., 475., 521.,
    531., 512., 442., 444., 430., 381., 335., 324., 296., 248., 215.,
    193., 158., 127., 101., 71., 31., -6., -26., -47., -63., -79.,
    -88., -88., -87., -90., -98., -99., -109., -134., -160., -167.,
    -164., -158., -153., -151., -156., -166., -168., -173., -170.,
    -161., -145., -126., -108., -84., -59., -29., 4., 41., 73., 97.,
    123., 159., 198., 220., 242., 256., 281., 311., 334., 319., 313.,
    321., 323., 310., 315., 320., 335., 361., 378., 373., 338., 319.,
    346., 322., 291., 290., 350., 371., 504., 504.
  };
 
  static const double nua[90] =
    { 1360., 1365., 1370., 1375., 1380., 1385., 1390.,
    1395., 1400., 1405., 1410., 1415., 1420., 1425., 1430., 1435.,
    1440., 1445., 1450., 1455., 1460., 1465., 1470., 1475., 1480.,
    1485., 1490., 1495., 1500., 1505., 1510., 1515., 1520., 1525.,
    1530., 1535., 1540., 1545., 1550., 1555., 1560., 1565., 1570.,
    1575., 1580., 1585., 1590., 1595., 1600., 1605., 1610., 1615.,
    1620., 1625., 1630., 1635., 1640., 1645., 1650., 1655., 1660.,
    1665., 1670., 1675., 1680., 1685., 1690., 1695., 1700., 1705.,
    1710., 1715., 1720., 1725., 1730., 1735., 1740., 1745., 1750.,
    1755., 1760., 1765., 1770., 1775., 1780., 1785., 1790., 1795.,
    1800., 1805.
  };
 
  const double t0 = 273, tr = 296;
 
  /* Check wavenumber range... */
  if (nu < nua[0] || nu > nua[89])
    return 0;
 
  /* Interpolate B and beta... */
  const int idx = locate_reg(nua, 90, nu);
  const double b = LIN(nua[idx], ba[idx], nua[idx + 1], ba[idx + 1], nu);
  const double beta =
    LIN(nua[idx], betaa[idx], nua[idx + 1], betaa[idx + 1], nu);
 
  /* Compute absorption coefficient... */
  return 0.1 * POW2(p / P0 * t0 / t) * exp(beta * (1 / tr - 1 / t)) * O2 * b;
}
 
/*****************************************************************************/
 
void copy_atm(
  const ctl_t *ctl,
  atm_t *atm_dest,
  const atm_t *atm_src,
  const int init) {
 
  /* Data size... */
  const size_t s = (size_t) atm_src->np * sizeof(double);
 
  /* Copy data... */
  atm_dest->np = atm_src->np;
  memcpy(atm_dest->time, atm_src->time, s);
  memcpy(atm_dest->z, atm_src->z, s);
  memcpy(atm_dest->lon, atm_src->lon, s);
  memcpy(atm_dest->lat, atm_src->lat, s);
  memcpy(atm_dest->p, atm_src->p, s);
  memcpy(atm_dest->t, atm_src->t, s);
  for (int ig = 0; ig < ctl->ng; ig++)
    memcpy(atm_dest->q[ig], atm_src->q[ig], s);
  for (int iw = 0; iw < ctl->nw; iw++)
    memcpy(atm_dest->k[iw], atm_src->k[iw], s);
  atm_dest->clz = atm_src->clz;
  atm_dest->cldz = atm_src->cldz;
  for (int icl = 0; icl < ctl->ncl; icl++)
    atm_dest->clk[icl] = atm_src->clk[icl];
  atm_dest->sft = atm_src->sft;
  for (int isf = 0; isf < ctl->nsf; isf++)
    atm_dest->sfeps[isf] = atm_src->sfeps[isf];
 
  /* Initialize... */
  if (init)
    for (int ip = 0; ip < atm_dest->np; ip++) {
      atm_dest->p[ip] = 0;
      atm_dest->t[ip] = 0;
      for (int ig = 0; ig < ctl->ng; ig++)
        atm_dest->q[ig][ip] = 0;
      for (int iw = 0; iw < ctl->nw; iw++)
        atm_dest->k[iw][ip] = 0;
      atm_dest->clz = 0;
      atm_dest->cldz = 0;
      for (int icl = 0; icl < ctl->ncl; icl++)
        atm_dest->clk[icl] = 0;
      atm_dest->sft = 0;
      for (int isf = 0; isf < ctl->nsf; isf++)
        atm_dest->sfeps[isf] = 1;
    }
}
 
/*****************************************************************************/
 
void copy_obs(
  const ctl_t *ctl,
  obs_t *obs_dest,
  const obs_t *obs_src,
  const int init) {
 
  /* Data size... */
  const size_t s = (size_t) obs_src->nr * sizeof(double);
 
  /* Copy data... */
  obs_dest->nr = obs_src->nr;
  memcpy(obs_dest->time, obs_src->time, s);
  memcpy(obs_dest->obsz, obs_src->obsz, s);
  memcpy(obs_dest->obslon, obs_src->obslon, s);
  memcpy(obs_dest->obslat, obs_src->obslat, s);
  memcpy(obs_dest->vpz, obs_src->vpz, s);
  memcpy(obs_dest->vplon, obs_src->vplon, s);
  memcpy(obs_dest->vplat, obs_src->vplat, s);
  memcpy(obs_dest->tpz, obs_src->tpz, s);
  memcpy(obs_dest->tplon, obs_src->tplon, s);
  memcpy(obs_dest->tplat, obs_src->tplat, s);
  for (int id = 0; id < ctl->nd; id++)
    memcpy(obs_dest->rad[id], obs_src->rad[id], s);
  for (int id = 0; id < ctl->nd; id++)
    memcpy(obs_dest->tau[id], obs_src->tau[id], s);
 
  /* Initialize... */
  if (init)
    for (int id = 0; id < ctl->nd; id++)
      for (int ir = 0; ir < obs_dest->nr; ir++)
        if (isfinite(obs_dest->rad[id][ir])) {
          obs_dest->rad[id][ir] = 0;
          obs_dest->tau[id][ir] = 0;
        }
}
 
/*****************************************************************************/
 
void day2doy(
  int year,
  int mon,
  int day,
  int *doy) {
 
  const int d0[12] =
    { 1, 32, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 };
  const int d0l[12] =
    { 1, 32, 61, 92, 122, 153, 183, 214, 245, 275, 306, 336 };
 
  /* Get day of year... */
  if (year % 400 == 0 || (year % 100 != 0 && year % 4 == 0))
    *doy = d0l[mon - 1] + day - 1;
  else
    *doy = d0[mon - 1] + day - 1;
}
 
/*****************************************************************************/
 
void doy2day(
  int year,
  int doy,
  int *mon,
  int *day) {
 
  const int d0[12] =
    { 1, 32, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 };
  const int d0l[12] =
    { 1, 32, 61, 92, 122, 153, 183, 214, 245, 275, 306, 336 };
  int i;
 
  /* Get month and day... */
  if (year % 400 == 0 || (year % 100 != 0 && year % 4 == 0)) {
    for (i = 11; i >= 0; i--)
      if (d0l[i] <= doy)
        break;
    *mon = i + 1;
    *day = doy - d0l[i] + 1;
  } else {
    for (i = 11; i >= 0; i--)
      if (d0[i] <= doy)
        break;
    *mon = i + 1;
    *day = doy - d0[i] + 1;
  }
}
 
/*****************************************************************************/
 
int find_emitter(
  const ctl_t *ctl,
  const char *emitter) {
 
  for (int ig = 0; ig < ctl->ng; ig++)
    if (strcasecmp(ctl->emitter[ig], emitter) == 0)
      return ig;
 
  return -1;
}
 
/*****************************************************************************/
 
int formod(
  const ctl_t *ctl,
  const tbl_t *tbl,
  atm_t *atm,
  obs_t *obs,
  los_t *los_scratch,
  obs_t *obs_scratch) {
 
  /* Save observation mask... */
  for (int id = 0; id < ctl->nd; id++)
    for (int ir = 0; ir < obs->nr; ir++)
      obs->mask[id][ir] = !isfinite(obs->rad[id][ir]);
 
  /* Hydrostatic equilibrium... */
  hydrostatic(ctl, atm);
 
  /* CGA or EGA forward model... */
  if (ctl->formod == 0 || ctl->formod == 1) {
    for (int ir = 0; ir < obs->nr; ir++) {
      const int status = formod_pencil(ctl, tbl, atm, obs, ir, los_scratch);
      if (status != FORMOD_STATUS_OK)
        return status;
    }
  }
 
  /* Call RFM... */
  else if (ctl->formod == 2)
    formod_rfm(ctl, tbl, atm, obs);
 
  /* Apply field-of-view convolution... */
  const int fov_status = formod_fov(ctl, obs, obs_scratch);
  if (fov_status != FORMOD_STATUS_OK)
    return fov_status;
 
  /* Convert radiance to brightness temperature... */
  if (ctl->write_bbt)
    for (int id = 0; id < ctl->nd; id++)
      for (int ir = 0; ir < obs->nr; ir++)
        obs->rad[id][ir] = BRIGHT(obs->rad[id][ir], ctl->nu[id]);
 
  /* Apply observation mask... */
  for (int id = 0; id < ctl->nd; id++)
    for (int ir = 0; ir < obs->nr; ir++)
      if (obs->mask[id][ir])
        obs->rad[id][ir] = NAN;
 
  return FORMOD_STATUS_OK;
}
 
/*****************************************************************************/
 
void formod_batch(
  const ctl_t *ctl,
  const tbl_t *tbl,
  atm_t *atm,
  obs_t *obs,
  const int nbatch,
  int *status,
  los_t *los_scratch,
  obs_t *obs_scratch) {
 
  if (nbatch <= 0)
    return;
 
  if (los_scratch == NULL || obs_scratch == NULL)
    ERRMSG("formod_batch requires scratch arrays for los and obs_scratch!");
 
  /* The RFM interface uses fixed temporary filenames and is therefore
     not thread-safe... */
  if (ctl->formod == 2) {
    for (int ib = 0; ib < nbatch; ib++) {
      const int ib_status = formod(ctl, tbl, &atm[ib], &obs[ib],
                                   &los_scratch[ib], &obs_scratch[ib]);
      if (status)
        status[ib] = ib_status;
      else if (ib_status != FORMOD_STATUS_OK)
        ERRMSG("Forward model failed with status code %d!", ib_status);
    }
    return;
  }
 
  /* Run independent cases in parallel... */
#pragma omp parallel for schedule(static) default(none) shared(ctl,tbl,atm,obs,nbatch,status,los_scratch,obs_scratch)
  for (int ib = 0; ib < nbatch; ib++) {
    const int ib_status = formod(ctl, tbl, &atm[ib], &obs[ib],
                                 &los_scratch[ib], &obs_scratch[ib]);
    if (status)
      status[ib] = ib_status;
    else if (ib_status != FORMOD_STATUS_OK)
      ERRMSG("Forward model failed with status code %d!", ib_status);
  }
}
 
/*****************************************************************************/
 
void formod_continua(
  const ctl_t *ctl,
  const los_t *los,
  const int ip,
  double *beta) {
 
  /* Extinction... */
  for (int id = 0; id < ctl->nd; id++)
    beta[id] = los->k[ip][id];
 
  /* CO2 continuum... */
  if (ctl->ctm_co2 && ctl->ig_co2 >= 0)
    for (int id = 0; id < ctl->nd; id++)
      beta[id] += ctmco2(ctl->nu[id], los->p[ip], los->t[ip],
                         los->u[ip][ctl->ig_co2]) / los->ds[ip];
 
  /* H2O continuum... */
  if (ctl->ctm_h2o && ctl->ig_h2o >= 0)
    for (int id = 0; id < ctl->nd; id++)
      beta[id] += ctmh2o(ctl->nu[id], los->p[ip], los->t[ip],
                         los->q[ip][ctl->ig_h2o], los->u[ip][ctl->ig_h2o])
        / los->ds[ip];
 
  /* N2 continuum... */
  if (ctl->ctm_n2)
    for (int id = 0; id < ctl->nd; id++)
      beta[id] += ctmn2(ctl->nu[id], los->p[ip], los->t[ip]);
 
  /* O2 continuum... */
  if (ctl->ctm_o2)
    for (int id = 0; id < ctl->nd; id++)
      beta[id] += ctmo2(ctl->nu[id], los->p[ip], los->t[ip]);
}
 
/*****************************************************************************/
 
int formod_fov(
  const ctl_t *ctl,
  obs_t *obs,
  obs_t *obs_scratch) {
 
  int rays[2 * NFOV + 1];
  double z[2 * NFOV + 1];
 
  /* Do not take into account FOV... */
  if (ctl->fov[0] == '-')
    return FORMOD_STATUS_OK;
 
  /* Copy observation data... */
  copy_obs(ctl, obs_scratch, obs, 0);
 
  /* Loop over ray paths... */
  for (int ir = 0; ir < obs->nr; ir++) {
 
    /* Collect neighbouring ray paths for the same time step... */
    int nz = 0;
    for (int ir2 = MAX(ir - NFOV, 0);
         ir2 < MIN(ir + 1 + NFOV, obs->nr); ir2++)
      if (obs->time[ir2] == obs->time[ir]) {
        rays[nz] = ir2;
        z[nz] = obs_scratch->vpz[ir2];
        nz++;
      }
    if (nz < 2)
      return FORMOD_STATUS_FOV_DATA_MISSING;
 
    /* Convolute profiles with FOV... */
    double wsum = 0;
    for (int id = 0; id < ctl->nd; id++) {
      obs->rad[id][ir] = 0;
      obs->tau[id][ir] = 0;
    }
    for (int i = 0; i < ctl->fov_n; i++) {
      const double zfov = obs->vpz[ir] + ctl->fov_dz[i];
      const int idx = locate_irr(z, nz, zfov);
      const int ir0 = rays[idx];
      const int ir1 = rays[idx + 1];
      for (int id = 0; id < ctl->nd; id++) {
        obs->rad[id][ir] += ctl->fov_w[i]
          * LIN(z[idx], obs_scratch->rad[id][ir0],
                z[idx + 1], obs_scratch->rad[id][ir1], zfov);
        obs->tau[id][ir] += ctl->fov_w[i]
          * LIN(z[idx], obs_scratch->tau[id][ir0],
                z[idx + 1], obs_scratch->tau[id][ir1], zfov);
      }
      wsum += ctl->fov_w[i];
    }
    for (int id = 0; id < ctl->nd; id++) {
      obs->rad[id][ir] /= wsum;
      obs->tau[id][ir] /= wsum;
    }
  }
 
  return FORMOD_STATUS_OK;
}
 
/*****************************************************************************/
 
int formod_pencil(
  const ctl_t *ctl,
  const tbl_t *tbl,
  const atm_t *atm,
  obs_t *obs,
  const int ir,
  los_t *los) {
 
  double rad[ND], tau[ND], tau_path[ND][NG];
 
  /* Reset scratch LOS data (raytrace relies on zero-initialized fields)... */
  memset(los, 0, sizeof(*los));
 
  /* Initialize... */
  for (int id = 0; id < ctl->nd; id++) {
    rad[id] = 0;
    tau[id] = 1;
    for (int ig = 0; ig < ctl->ng; ig++)
      tau_path[id][ig] = 1;
  }
 
  /* Raytracing... */
  {
    const int status = raytrace(ctl, atm, obs, los, ir);
    if (status != FORMOD_STATUS_OK)
      return status;
  }
 
  /* Loop over LOS points... */
  for (int ip = 0; ip < los->np; ip++) {
 
    /* Get trace gas transmittance... */
    double tau_gas[ND];
    if (ctl->formod == 0)
      intpol_tbl_cga(ctl, tbl, los, ip, tau_path, tau_gas);
    else
      intpol_tbl_ega(ctl, tbl, los, ip, tau_path, tau_gas);
 
    /* Get continuum absorption... */
    double beta_ctm[ND];
    formod_continua(ctl, los, ip, beta_ctm);
 
    /* Compute Planck function... */
    formod_srcfunc(ctl, tbl, los->t[ip], los->src[ip]);
 
    /* Loop over channels... */
    for (int id = 0; id < ctl->nd; id++)
      if (tau_gas[id] >= 0) {
 
        /* Get segment emissivity. An exactly zero transmittance represents
           a fully opaque segment and must contribute with emissivity one. */
        los->eps[ip][id] = 1 - tau_gas[id] * exp(-beta_ctm[id] * los->ds[ip]);
 
        /* Compute radiance... */
        rad[id] += los->src[ip][id] * los->eps[ip][id] * tau[id];
 
        /* Compute path transmittance... */
        tau[id] *= (1 - los->eps[ip][id]);
      }
  }
 
  /* Check whether LOS hit the ground... */
  if (ctl->sftype >= 1 && los->sft > 0) {
 
    /* Add surface emissions... */
    double src_sf[ND];
    formod_srcfunc(ctl, tbl, los->sft, src_sf);
    for (int id = 0; id < ctl->nd; id++)
      rad[id] += los->sfeps[id] * src_sf[id] * tau[id];
 
    /* Check reflectivity... */
    int refl = 0;
    if (ctl->sftype >= 2)
      for (int id = 0; id < ctl->nd; id++)
        if (los->sfeps[id] < 1) {
          refl = 1;
          break;
        }
 
    /* Calculate reflection... */
    if (refl) {
 
      /* Initialize... */
      double tau_refl[ND];
      for (int id = 0; id < ctl->nd; id++)
        tau_refl[id] = 1;
 
      /* Add down-welling radiance... */
      for (int ip = los->np - 1; ip >= 0; ip--)
        for (int id = 0; id < ctl->nd; id++) {
          rad[id] += los->src[ip][id] * los->eps[ip][id] * tau_refl[id]
            * tau[id] * (1 - los->sfeps[id]);
          tau_refl[id] *= (1 - los->eps[ip][id]);
        }
 
      /* Add solar term... */
      if (ctl->sftype >= 3) {
 
        /* Get cosine of solar zenith angle... */
        double cos_sza_val;
        if (ctl->sfsza < 0)
          cos_sza_val = cos_sza(obs->time[ir],
                                los->lon[los->np - 1], los->lat[los->np - 1]);
        else
          cos_sza_val = cos(DEG2RAD(ctl->sfsza));
 
        /* Check validity (avoid division by zero)... */
        if (cos_sza_val > 1e-6) {
 
          /* Compute incidence direction cosine... */
          double x0[3], x1[3];
          geo2cart(los->z[los->np - 1], los->lon[los->np - 1],
                   los->lat[los->np - 1], x0);
          geo2cart(los->z[0], los->lon[0], los->lat[0], x1);
          for (int i = 0; i < 3; i++)
            x1[i] -= x0[i];
          const double cosa = DOTP(x0, x1) / NORM(x0) / NORM(x1);
 
          /* Ratio of incident direction to solar zenith direction... */
          const double rcos = cosa / cos_sza_val;
 
          /* 6.764e-5 sr approximates the solid angle of the solar disk. */
          /* Add solar radiance contribution... */
          for (int id = 0; id < ctl->nd; id++)
            rad[id] += 6.764e-5 / (2. * M_PI) * PLANCK(TSUN, ctl->nu[id])
              * tau_refl[id] * (1 - los->sfeps[id]) * tau[id] * rcos;
        }
      }
    }
  }
 
  /* Copy results... */
  for (int id = 0; id < ctl->nd; id++) {
    obs->rad[id][ir] = rad[id];
    obs->tau[id][ir] = tau[id];
  }
 
  return FORMOD_STATUS_OK;
}
 
/*****************************************************************************/
 
static double convolve_rfm(
  const double *nurfm,
  const double *spec,
  const int npts,
  const double *nu,
  const double *f,
  const int n) {
 
  double fsum = 0, specsum = 0;
 
  /* Convolute... */
  for (int ipts = 0; ipts < npts; ipts++)
    if (nurfm[ipts] >= nu[0] && nurfm[ipts] <= nu[n - 1]) {
      const int idx = locate_irr(nu, n, nurfm[ipts]);
      const double filt =
        LIN(nu[idx], f[idx], nu[idx + 1], f[idx + 1], nurfm[ipts]);
      fsum += filt;
      specsum += filt * spec[ipts];
    }
 
  return specsum / fsum;
}
 
/*****************************************************************************/
 
static void find_rfm_file(
  char *filename,
  const size_t filename_size,
  const char *basename,
  const double z) {
 
  /* Search RFM spectrum... */
  FILE *in;
  int n = snprintf(filename, filename_size, "%s_%05d.asc",
                   basename, (int) (z * 1000));
  if (n < 0 || (size_t) n >= filename_size)
    ERRMSG("RFM spectrum filename too long!");
  if (!(in = fopen(filename, "r"))) {
    n = snprintf(filename, filename_size, "%s_%05d.asc",
                 basename, (int) (z * 1000) + 1);
    if (n < 0 || (size_t) n >= filename_size)
      ERRMSG("RFM spectrum filename too long!");
    if (!(in = fopen(filename, "r")))
      ERRMSG("Cannot find RFM data file! Tried %s", filename);
  }
  fclose(in);
}
 
/*****************************************************************************/
 
void formod_rfm(
  const ctl_t *ctl,
  const tbl_t *tbl,
  const atm_t *atm,
  obs_t *obs) {
 
  los_t *los;
 
  char filename[3 * LEN], tmpdir[2 * LEN], cwd[LEN];
  char rfmflg[LEN] = { "RAD TRA MIX LIN SFC" };
 
  double lower[ND], upper[ND], nu0, nu1, obsz = -999, *nurfm, *spec, tsurf,
    xd[3], xo[3], xv[3], z[NR], zmin, zmax;
 
  int nadir = 0, npts, order[ND], zenith = 0;
 
  /* Allocate... */
  ALLOC(los, los_t, 1);
  ALLOC(nurfm, double,
        RFMNPTS);
  ALLOC(spec, double,
        RFMNPTS);
 
  /* Check observer positions... */
  for (int ir = 1; ir < obs->nr; ir++)
    if (obs->obsz[ir] != obs->obsz[0]
        || obs->obslon[ir] != obs->obslon[0]
        || obs->obslat[ir] != obs->obslat[0])
      ERRMSG("RFM interface requires identical observer positions!");
 
  /* Check extinction data... */
  for (int iw = 0; iw < ctl->nw; iw++)
    for (int ip = 0; ip < atm->np; ip++)
      if (atm->k[iw][ip] != 0)
        ERRMSG("RFM interface cannot handle extinction data!");
 
  /* Get altitude range of atmospheric data... */
  gsl_stats_minmax(&zmin, &zmax, atm->z, 1, (size_t) atm->np);
 
  /* Observer within atmosphere? */
  if (obs->obsz[0] >= zmin && obs->obsz[0] <= zmax) {
    obsz = obs->obsz[0];
    strcat(rfmflg, " OBS");
  }
 
  /* Determine tangent altitude or air mass factor... */
  for (int ir = 0; ir < obs->nr; ir++) {
 
    /* Raytracing... */
    if (raytrace(ctl, atm, obs, los, ir) != FORMOD_STATUS_OK)
      ERRMSG("Ray tracing failed!");
 
    /* Nadir or zenith? (air mass factor / secant of zenith angle) */
    if (obs->tpz[ir] <= zmin) {
 
      /* Nadir: path intersects the surface. */
      geo2cart(obs->obsz[ir], obs->obslon[ir], obs->obslat[ir], xo);
      geo2cart(obs->vpz[ir], obs->vplon[ir], obs->vplat[ir], xv);
      for (int i = 0; i < 3; i++)
        xd[i] = xo[i] - xv[i];
      z[ir] = NORM(xo) * NORM(xd) / DOTP(xo, xd);
      nadir++;
 
    } else if (obs->tpz[ir] >= zmax - 1e-3 && obs->vpz[ir] > obs->obsz[ir]) {
 
      /* Zenith: upward-looking path leaves the atmosphere at the top boundary. */
      geo2cart(obs->obsz[ir], obs->obslon[ir], obs->obslat[ir], xo);
      geo2cart(obs->vpz[ir], obs->vplon[ir], obs->vplat[ir], xv);
      for (int i = 0; i < 3; i++)
        xd[i] = xv[i] - xo[i];
      z[ir] = NORM(xo) * NORM(xd) / DOTP(xo, xd);
      zenith++;
 
    } else
      /* Limb: use tangent altitude. */
      z[ir] = obs->tpz[ir];
  }
  if ((nadir > 0 && nadir < obs->nr)
      || (zenith > 0 && zenith < obs->nr)
      || (nadir > 0 && zenith > 0))
    ERRMSG("Limb, nadir, and zenith not simultaneously possible!");
 
  /* Viewing geometry... */
  if (nadir)
    strcat(rfmflg, " NAD");
  if (zenith)
    strcat(rfmflg, " ZEN");
 
  /* Get surface temperature... */
  tsurf = atm->t[gsl_stats_min_index(atm->z, 1, (size_t) atm->np)];
 
  /* Refraction? */
  if (!nadir && !zenith && !ctl->refrac)
    strcat(rfmflg, " GEO");
 
  /* Continua? */
  if (ctl->ctm_co2 || ctl->ctm_h2o || ctl->ctm_n2 || ctl->ctm_o2)
    strcat(rfmflg, " CTM");
 
  /* Check filter functions and initialize channel order... */
  for (int id = 0; id < ctl->nd; id++) {
    const int n = tbl->filt_n[id];
    if (n < 2 || n > NSHAPE)
      ERRMSG("Missing or invalid filter function in lookup table!");
    for (int i = 1; i < n; i++)
      if (tbl->filt_nu[id][i] <= tbl->filt_nu[id][i - 1])
        ERRMSG("Filter wavenumbers must be strictly increasing!");
    lower[id] = tbl->filt_nu[id][0];
    upper[id] = tbl->filt_nu[id][n - 1];
    order[id] = id;
  }
 
  /* Sort channels by lower filter bound... */
  for (int i = 1; i < ctl->nd; i++) {
    const int id = order[i];
    int j = i;
    while (j > 0 && lower[order[j - 1]] > lower[id]) {
      order[j] = order[j - 1];
      j--;
    }
    order[j] = id;
  }
 
  /* Create a private RFM working directory... */
  const char *base = strcmp(ctl->rfmtmp, "-") == 0 ? "." : ctl->rfmtmp;
  int n;
  if (base[0] == '/')
    n = snprintf(tmpdir, sizeof(tmpdir), "%s/jurassic-rfm-XXXXXX", base);
  else {
    if (!getcwd(cwd, sizeof(cwd)))
      ERRMSG("Cannot determine current working directory!");
    n = snprintf(tmpdir, sizeof(tmpdir), "%s/%s/jurassic-rfm-XXXXXX",
                 cwd, base);
  }
  if (n < 0 || (size_t) n >= sizeof(tmpdir) || !mkdtemp(tmpdir))
    ERRMSG("Cannot create RFM working directory!");
 
  snprintf(filename, sizeof(filename), "%s/rfm.atm", tmpdir);
  write_atm_rfm(filename, ctl, atm);
 
  /* Supply the blank input line used by the previous RFM command... */
  snprintf(filename, sizeof(filename), "%s/rfm.stdin", tmpdir);
  FILE *input = fopen(filename, "w");
  if (!input || fputs("\n", input) == EOF || fclose(input) != 0)
    ERRMSG("Cannot create RFM input in %s!", tmpdir);
 
  /* Loop over overlapping spectral blocks... */
  for (int ib = 0; ib < ctl->nd;) {
    int ie = ib + 1;
    nu0 = lower[order[ib]];
    nu1 = upper[order[ib]];
    while (ie < ctl->nd && lower[order[ie]] <= nu1) {
      nu1 = MAX(nu1, upper[order[ie]]);
      ie++;
    }
 
    /* Create RFM driver file... */
    FILE *out;
    snprintf(filename, sizeof(filename), "%s/rfm.drv", tmpdir);
    if (!(out = fopen(filename, "w")))
      ERRMSG("Cannot create file!");
    fprintf(out, "*HDR\nRFM call by JURASSIC.\n");
    fprintf(out, "*FLG\n%s\n", rfmflg);
    fprintf(out, "*SPC\n%.4f %.4f 0.0005\n", nu0, nu1);
    fprintf(out, "*GAS\n");
    for (int ig = 0; ig < ctl->ng; ig++)
      fprintf(out, "%s\n", ctl->emitter[ig]);
    fprintf(out, "*ATM\nrfm.atm\n");
    fprintf(out, "*TAN\n");
    for (int ir = 0; ir < obs->nr; ir++)
      fprintf(out, "%g\n", z[ir]);
    fprintf(out, "*SFC\n%g 1.0\n", tsurf);
    if (obsz >= 0)
      fprintf(out, "*OBS\n%g\n", obsz);
    fprintf(out, "*HIT\n%s\n", ctl->rfmhit);
    fprintf(out, "*XSC\n");
    for (int ig = 0; ig < ctl->ng; ig++)
      if (ctl->rfmxsc[ig][0] != '-')
        fprintf(out, "%s\n", ctl->rfmxsc[ig]);
    fprintf(out, "*END\n");
    fclose(out);
 
    /* Remove spectra from the previous spectral block... */
    DIR *dir = opendir(tmpdir);
    if (!dir)
      ERRMSG("Cannot open RFM working directory %s!", tmpdir);
    struct dirent *entry;
    while ((entry = readdir(dir)))
      if (strncmp(entry->d_name, "rad_", 4) == 0
          || strncmp(entry->d_name, "tra_", 4) == 0) {
        snprintf(filename, sizeof(filename), "%s/%s", tmpdir, entry->d_name);
        if (unlink(filename))
          ERRMSG("Cannot remove old RFM spectrum in %s!", tmpdir);
      }
    closedir(dir);
 
    /* Run RFM in the child without changing the parent's directory... */
    char program[LEN];
    strcpy(program, ctl->rfmbin);
    pid_t pid = fork();
    if (pid == 0) {
      if (chdir(tmpdir))
        _exit(126);
      int fd = open("rfm.stdin", O_RDONLY);
      if (fd < 0 || dup2(fd, STDIN_FILENO) < 0)
        _exit(126);
      close(fd);
      char *const args[] = { program, NULL };
      execvp(program, args);
      _exit(127);
    }
    if (pid < 0)
      ERRMSG("Cannot launch RFM; files retained in %s!", tmpdir);
    int status;
    while (waitpid(pid, &status, 0) < 0)
      if (errno != EINTR)
        ERRMSG("Cannot wait for RFM; files retained in %s!", tmpdir);
    if (WIFSIGNALED(status))
      ERRMSG("RFM terminated by signal %d; files retained in %s!",
             WTERMSIG(status), tmpdir);
    if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
      ERRMSG("RFM exited with status %d; files retained in %s!",
             WIFEXITED(status) ? WEXITSTATUS(status) : -1, tmpdir);
 
    /* Read and convolute each spectrum once... */
    for (int ir = 0; ir < obs->nr; ir++) {
      char basename[3 * LEN];
      snprintf(basename, sizeof(basename), "%s/rad", tmpdir);
      find_rfm_file(filename, sizeof(filename), basename, z[ir]);
      read_rfm_spec(filename, nurfm, spec, &npts);
      for (int i = ib; i < ie; i++) {
        const int id = order[i];
        obs->rad[id][ir] = convolve_rfm(nurfm, spec, npts,
                                        tbl->filt_nu[id], tbl->filt_f[id],
                                        tbl->filt_n[id]) * 1e-5;
      }
 
      snprintf(basename, sizeof(basename), "%s/tra", tmpdir);
      find_rfm_file(filename, sizeof(filename), basename, z[ir]);
      read_rfm_spec(filename, nurfm, spec, &npts);
      for (int i = ib; i < ie; i++) {
        const int id = order[i];
        obs->tau[id][ir] = convolve_rfm(nurfm, spec, npts,
                                        tbl->filt_nu[id], tbl->filt_f[id],
                                        tbl->filt_n[id]);
      }
    }
    ib = ie;
  }
 
  /* Remove files from this invocation's private directory... */
  DIR *dir = opendir(tmpdir);
  if (!dir)
    ERRMSG("Cannot open RFM working directory %s!", tmpdir);
  struct dirent *entry;
  while ((entry = readdir(dir))) {
    if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
      continue;
    snprintf(filename, sizeof(filename), "%s/%s", tmpdir, entry->d_name);
    if (unlink(filename))
      ERRMSG("Cannot remove RFM file in %s!", tmpdir);
  }
  closedir(dir);
  if (rmdir(tmpdir))
    ERRMSG("Cannot remove RFM working directory %s!", tmpdir);
 
  /* Free... */
  free(los);
  free(nurfm);
  free(spec);
}
 
/*****************************************************************************/
 
void formod_srcfunc(
  const ctl_t *ctl,
  const tbl_t *tbl,
  const double t,
  double *src) {
 
  /* Determine index in temperature array... */
  const int it = locate_reg(tbl->st, TBLNS, t);
 
  /* Interpolate Planck function value... */
  for (int id = 0; id < ctl->nd; id++)
    src[id] = LIN(tbl->st[it], tbl->sr[it][id],
                  tbl->st[it + 1], tbl->sr[it + 1][id], t);
}
 
/*****************************************************************************/
 
void geo2cart(
  const double z,
  const double lon,
  const double lat,
  double *x) {
 
  const double radius = z + RE;
  const double latrad = lat / 180. * M_PI;
  const double lonrad = lon / 180. * M_PI;
  const double coslat = cos(latrad);
 
  x[0] = radius * coslat * cos(lonrad);
  x[1] = radius * coslat * sin(lonrad);
  x[2] = radius * sin(latrad);
}
 
/*****************************************************************************/
 
void hydrostatic(
  const ctl_t *ctl,
  atm_t *atm) {
 
  const double mmair = 28.96456e-3, mmh2o = 18.0153e-3;
 
  const int ipts = 20;
 
  double dzmin = 1e99, e = 0;
 
  int ipref = 0;
 
  /* Check reference height... */
  if (ctl->hydz < 0)
    return;
 
  /* Find air parcel next to reference height... */
  for (int ip = 0; ip < atm->np; ip++)
    if (fabs(atm->z[ip] - ctl->hydz) < dzmin) {
      dzmin = fabs(atm->z[ip] - ctl->hydz);
      ipref = ip;
    }
 
  /* Upper part of profile... */
  for (int ip = ipref + 1; ip < atm->np; ip++) {
    double mean = 0;
    for (int i = 0; i < ipts; i++) {
      if (ctl->ig_h2o >= 0)
        e = LIN(0.0, atm->q[ctl->ig_h2o][ip - 1],
                ipts - 1.0, atm->q[ctl->ig_h2o][ip], (double) i);
      mean += (e * mmh2o + (1 - e) * mmair)
        * G0 / RI
        / LIN(0.0, atm->t[ip - 1], ipts - 1.0, atm->t[ip], (double) i) / ipts;
    }
 
    /* Compute p(z,T)... */
    atm->p[ip] =
      exp(log(atm->p[ip - 1]) - mean * 1000 * (atm->z[ip] - atm->z[ip - 1]));
  }
 
  /* Lower part of profile... */
  for (int ip = ipref - 1; ip >= 0; ip--) {
    double mean = 0;
    for (int i = 0; i < ipts; i++) {
      if (ctl->ig_h2o >= 0)
        e = LIN(0.0, atm->q[ctl->ig_h2o][ip + 1],
                ipts - 1.0, atm->q[ctl->ig_h2o][ip], (double) i);
      mean += (e * mmh2o + (1 - e) * mmair)
        * G0 / RI
        / LIN(0.0, atm->t[ip + 1], ipts - 1.0, atm->t[ip], (double) i) / ipts;
    }
 
    /* Compute p(z,T)... */
    atm->p[ip] =
      exp(log(atm->p[ip + 1]) - mean * 1000 * (atm->z[ip] - atm->z[ip + 1]));
  }
}
 
/*****************************************************************************/
 
void idx2name(
  const ctl_t *ctl,
  const int idx,
  char *quantity) {
 
  if (idx == IDXP)
    sprintf(quantity, "PRESSURE");
 
  if (idx == IDXT)
    sprintf(quantity, "TEMPERATURE");
 
  for (int ig = 0; ig < ctl->ng; ig++)
    if (idx == IDXQ(ig))
      sprintf(quantity, "%s", ctl->emitter[ig]);
 
  for (int iw = 0; iw < ctl->nw; iw++)
    if (idx == IDXK(iw))
      sprintf(quantity, "EXTINCT_WINDOW_%d", iw);
 
  if (idx == IDXCLZ)
    sprintf(quantity, "CLOUD_HEIGHT");
 
  if (idx == IDXCLDZ)
    sprintf(quantity, "CLOUD_DEPTH");
 
  for (int icl = 0; icl < ctl->ncl; icl++)
    if (idx == IDXCLK(icl))
      sprintf(quantity, "CLOUD_EXTINCT_%.4f", ctl->clnu[icl]);
 
  if (idx == IDXSFT)
    sprintf(quantity, "SURFACE_TEMPERATURE");
 
  for (int isf = 0; isf < ctl->nsf; isf++)
    if (idx == IDXSFEPS(isf))
      sprintf(quantity, "SURFACE_EMISSIVITY_%.4f", ctl->sfnu[isf]);
}
 
/*****************************************************************************/
 
void init_srcfunc(
  const ctl_t *ctl,
  tbl_t *tbl) {
 
  /* Write info... */
  LOG(1, "Initialize source function table...");
  LOG(2, "Number of data points: %d", TBLNS);
 
  /* Loop over channels... */
  for (int id = 0; id < ctl->nd; id++) {
 
    /* Get minimum grid spacing... */
    double dnu = 1.0;
    for (int i = 1; i < tbl->filt_n[id]; i++)
      dnu = MIN(dnu, tbl->filt_nu[id][i] - tbl->filt_nu[id][i - 1]);
 
    /* Compute source function table... */
#pragma omp parallel for default(none) shared(ctl,tbl,id,dnu)
    for (int it = 0; it < TBLNS; it++) {
 
      /* Set temperature... */
      tbl->st[it] = LIN(0.0, TMIN, TBLNS - 1.0, TMAX, (double) it);
 
      /* Integrate Planck function... */
      double fsum = tbl->sr[it][id] = 0;
      for (double fnu = tbl->filt_nu[id][0];
           fnu <= tbl->filt_nu[id][tbl->filt_n[id] - 1]; fnu += dnu) {
        const int i = locate_irr(tbl->filt_nu[id], tbl->filt_n[id], fnu);
        const double ff = LIN(tbl->filt_nu[id][i], tbl->filt_f[id][i],
                              tbl->filt_nu[id][i + 1], tbl->filt_f[id][i + 1],
                              fnu);
        fsum += ff;
        tbl->sr[it][id] += ff * PLANCK(tbl->st[it], fnu);
      }
      tbl->sr[it][id] /= fsum;
    }
 
    /* Write info... */
    LOG(2,
        "channel= %.4f cm^-1 | T= %g ... %g K | B= %g ... %g W/(m^2 sr cm^-1)",
        ctl->nu[id], tbl->st[0], tbl->st[TBLNS - 1], tbl->sr[0][id],
        tbl->sr[TBLNS - 1][id]);
  }
}
 
/*****************************************************************************/
 
void intpol_atm(
  const ctl_t *ctl,
  const atm_t *atm,
  const double z,
  double *p,
  double *t,
  double *q,
  double *k) {
 
  /* Get array index... */
  const int ip = locate_irr(atm->z, atm->np, z);
 
  /* Interpolate... */
  *p = LOGY(atm->z[ip], atm->p[ip], atm->z[ip + 1], atm->p[ip + 1], z);
  *t = LIN(atm->z[ip], atm->t[ip], atm->z[ip + 1], atm->t[ip + 1], z);
  for (int ig = 0; ig < ctl->ng; ig++)
    q[ig] =
      LIN(atm->z[ip], atm->q[ig][ip], atm->z[ip + 1], atm->q[ig][ip + 1], z);
  for (int iw = 0; iw < ctl->nw; iw++)
    k[iw] =
      LIN(atm->z[ip], atm->k[iw][ip], atm->z[ip + 1], atm->k[iw][ip + 1], z);
}
 
/*****************************************************************************/
 
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]) {
 
  double eps, lnp[NG];
 
  /* Precompute log-pressure... */
  for (int ig = 0; ig < ctl->ng; ig++)
    lnp[ig] = log(los->cgp[ip][ig]);
 
  /* Loop over channels... */
  for (int id = 0; id < ctl->nd; id++) {
 
    /* Initialize... */
    tau_seg[id] = 1;
 
    /* Loop over emitters.... */
    for (int ig = 0; ig < ctl->ng; ig++) {
 
      /* Check size of table (pressure) and column density... */
      if (tbl->np[id][ig] < 30 || los->cgu[ip][ig] <= 0)
        eps = 0;
 
      /* Check transmittance... */
      else if (tau_path[id][ig] < 1e-9)
        eps = 1;
 
      /* Interpolate... */
      else {
 
        /* Determine pressure and temperature indices... */
        const int ipr =
          locate_irr(tbl->p[id][ig], tbl->np[id][ig], los->cgp[ip][ig]);
        const int it0 = locate_reg(tbl->t[id][ig][ipr], tbl->nt[id][ig][ipr],
                                   los->cgt[ip][ig]);
        const int it1 =
          locate_reg(tbl->t[id][ig][ipr + 1], tbl->nt[id][ig][ipr + 1],
                     los->cgt[ip][ig]);
 
        /* Check size of table (temperature and column density)... */
        if (tbl->nt[id][ig][ipr] < 2 || tbl->nt[id][ig][ipr + 1] < 2
            || tbl->nu[id][ig][ipr][it0] < 2
            || tbl->nu[id][ig][ipr][it0 + 1] < 2
            || tbl->nu[id][ig][ipr + 1][it1] < 2
            || tbl->nu[id][ig][ipr + 1][it1 + 1] < 2)
          eps = 0;
 
        else {
 
          /* Get emissivities of extended path... */
          const double logu = log(los->cgu[ip][ig]);
          double eps00 = intpol_tbl_eps(tbl, ig, id, ipr, it0, logu);
          double eps01 = intpol_tbl_eps(tbl, ig, id, ipr, it0 + 1, logu);
          double eps10 = intpol_tbl_eps(tbl, ig, id, ipr + 1, it1, logu);
          double eps11 = intpol_tbl_eps(tbl, ig, id, ipr + 1, it1 + 1, logu);
 
          /* Interpolate with respect to temperature... */
          eps00 = LIN(tbl->t[id][ig][ipr][it0], eps00,
                      tbl->t[id][ig][ipr][it0 + 1], eps01, los->cgt[ip][ig]);
          eps11 = LIN(tbl->t[id][ig][ipr + 1][it1], eps10,
                      tbl->t[id][ig][ipr + 1][it1 + 1],
                      eps11, los->cgt[ip][ig]);
 
          /* Interpolate with respect to log-pressure... */
          eps00 = LIN(tbl->lnp[id][ig][ipr], eps00,
                      tbl->lnp[id][ig][ipr + 1], eps11, lnp[ig]);
 
          /* Check emissivity range... */
          eps00 = CLAMP(eps00, 0.0, 1.0);
 
          /* Determine segment emissivity... */
          eps = 1 - (1 - eps00) / tau_path[id][ig];
 
          /* Check emissivity range... */
          eps = CLAMP(eps, 0.0, 1.0);
        }
      }
 
      /* Get transmittance of extended path... */
      tau_path[id][ig] *= (1 - eps);
 
      /* Get segment transmittance... */
      tau_seg[id] *= (1 - eps);
    }
  }
}
 
/*****************************************************************************/
 
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]) {
 
  const double lnp = log(los->p[ip]);
 
  double eps, u;
 
  /* Loop over channels... */
  for (int id = 0; id < ctl->nd; id++) {
 
    /* Initialize... */
    tau_seg[id] = 1;
 
    /* Loop over emitters.... */
    for (int ig = 0; ig < ctl->ng; ig++) {
 
      /* Check size of table (pressure) and column density... */
      if (tbl->np[id][ig] < 30 || los->cgu[ip][ig] <= 0)
        eps = 0;
 
      /* Check transmittance... */
      else if (tau_path[id][ig] < 1e-9)
        eps = 1;
 
      /* Interpolate... */
      else {
 
        /* Determine pressure and temperature indices... */
        const int ipr =
          locate_irr(tbl->p[id][ig], tbl->np[id][ig], los->p[ip]);
        const int it0 =
          locate_reg(tbl->t[id][ig][ipr], tbl->nt[id][ig][ipr], los->t[ip]);
        const int it1 =
          locate_reg(tbl->t[id][ig][ipr + 1], tbl->nt[id][ig][ipr + 1],
                     los->t[ip]);
 
        /* Check size of table (temperature and column density)... */
        if (tbl->nt[id][ig][ipr] < 2 || tbl->nt[id][ig][ipr + 1] < 2
            || tbl->nu[id][ig][ipr][it0] < 2
            || tbl->nu[id][ig][ipr][it0 + 1] < 2
            || tbl->nu[id][ig][ipr + 1][it1] < 2
            || tbl->nu[id][ig][ipr + 1][it1 + 1] < 2)
          eps = 0;
 
        else {
 
          /* Get emissivities of extended path... */
          const double logeps = log(1.0 - tau_path[id][ig]);
 
          u = intpol_tbl_u(tbl, ig, id, ipr, it0, logeps);
          double eps00
            = intpol_tbl_eps(tbl, ig, id, ipr, it0, log(u + los->u[ip][ig]));
 
          u = intpol_tbl_u(tbl, ig, id, ipr, it0 + 1, logeps);
          double eps01 = intpol_tbl_eps(tbl, ig, id, ipr, it0 + 1,
                                        log(u + los->u[ip][ig]));
 
          u = intpol_tbl_u(tbl, ig, id, ipr + 1, it1, logeps);
          double eps10 = intpol_tbl_eps(tbl, ig, id, ipr + 1, it1,
                                        log(u + los->u[ip][ig]));
 
          u = intpol_tbl_u(tbl, ig, id, ipr + 1, it1 + 1, logeps);
          double eps11 = intpol_tbl_eps(tbl, ig, id, ipr + 1, it1 + 1,
                                        log(u + los->u[ip][ig]));
 
          /* Interpolate with respect to temperature... */
          eps00 = LIN(tbl->t[id][ig][ipr][it0], eps00,
                      tbl->t[id][ig][ipr][it0 + 1], eps01, los->t[ip]);
          eps11 = LIN(tbl->t[id][ig][ipr + 1][it1], eps10,
                      tbl->t[id][ig][ipr + 1][it1 + 1], eps11, los->t[ip]);
 
          /* Interpolate with respect to log-pressure... */
          eps00 = LIN(tbl->lnp[id][ig][ipr], eps00,
                      tbl->lnp[id][ig][ipr + 1], eps11, lnp);
 
          /* Check emissivity range... */
          eps00 = CLAMP(eps00, 0.0, 1.0);
 
          /* Determine segment emissivity... */
          eps = 1 - (1 - eps00) / tau_path[id][ig];
 
          /* Check emissivity range... */
          eps = CLAMP(eps, 0.0, 1.0);
        }
      }
 
      /* Get transmittance of extended path... */
      tau_path[id][ig] *= (1 - eps);
 
      /* Get segment transmittance... */
      tau_seg[id] *= (1 - eps);
    }
  }
}
 
/*****************************************************************************/
 
inline double intpol_tbl_eps(
  const tbl_t *tbl,
  const int ig,
  const int id,
  const int ip,
  const int it,
  const double logu) {
 
  const int nu = tbl->nu[id][ig][ip][it];
  const float *logu_arr = tbl->logu[id][ig][ip][it];
  const float *logeps_arr = tbl->logeps[id][ig][ip][it];
 
  /* Work in log-space and only convert back when needed... */
  const double logu_min = (double) logu_arr[0];
  const double logu_max = (double) logu_arr[nu - 1];
 
  /* Lower boundary extrapolation (u < u_min)...
     eps ~ eps_min * u/u_min => log(eps) = logeps_min + log(u) - log(u_min) */
  if (logu < logu_min) {
    const double logeps_min = (double) logeps_arr[0];
    return exp(logeps_min + logu - logu_min);
  }
 
  /* Upper boundary extrapolation (u > u_max)...
   * Assume eps(u) approaches 1 exponentially:
   *   eps(u) = 1 - exp(a * u),  a < 0
   * Continuity at (u_max, eps_max) gives
   *   a = log(1 - eps_max) / u_max.
   * Use log1p/expm1 and u/u_max = exp(log(u) - log(u_max)) for stability.
   */
  if (logu > logu_max) {
    const double eps_max = exp((double) logeps_arr[nu - 1]);
    const double l1m_eps_max = log1p(-eps_max);
    const double r = exp(logu - logu_max);
    return -expm1(l1m_eps_max * r);
  }
 
  /* Interpolation (log-log using precomputed logs)... */
  const int idx = locate_tbl(logu_arr, nu, logu);
  return exp(LIN(logu_arr[idx], logeps_arr[idx],
                 logu_arr[idx + 1], logeps_arr[idx + 1], logu));
}
 
/*****************************************************************************/
 
inline double intpol_tbl_u(
  const tbl_t *tbl,
  const int ig,
  const int id,
  const int ip,
  const int it,
  const double logeps) {
 
  const int nu = tbl->nu[id][ig][ip][it];
  const float *logeps_arr = tbl->logeps[id][ig][ip][it];
  const float *logu_arr = tbl->logu[id][ig][ip][it];
 
  /* Work in log-space and only convert back when needed.... */
  const double logeps_min = (double) logeps_arr[0];
  const double logeps_max = (double) logeps_arr[nu - 1];
 
  /* Lower boundary extrapolation (eps < eps_min)...
     u ~ u_min * eps/eps_min => log(u) = log(u_min) + log(eps) - log(eps_min) */
  if (logeps < logeps_min) {
    const double logu_min = (double) logu_arr[0];
    return exp(logu_min + logeps - logeps_min);
  }
 
  /* Upper boundary extrapolation (eps > eps_max):
   * Invert the exponential tail used for eps(u):
   *   u = log(1 - eps) / a,
   * with a = log(1 - eps_max) / u_max.
   * Rewritten as
   *   u = u_max * log(tau) / log(1 - eps_max)
   * for numerical stability (log1p).
   */
  if (logeps > logeps_max) {
    const double u_max = exp((double) logu_arr[nu - 1]);
    const double l1m_eps_max = log1p(-exp(logeps_max));
    const double logtau = log1p(-exp(logeps));
    return u_max * (logtau / l1m_eps_max);
  }
 
  /* Interpolation (log-log using precomputed logs)... */
  const int idx = locate_tbl(logeps_arr, nu, logeps);
  return exp(LIN(logeps_arr[idx], logu_arr[idx],
                 logeps_arr[idx + 1], logu_arr[idx + 1], logeps));
}
 
/*****************************************************************************/
 
void jsec2time(
  const double jsec,
  int *year,
  int *mon,
  int *day,
  int *hour,
  int *min,
  int *sec,
  double *remain) {
 
  struct tm t0, *t1;
 
  t0.tm_year = 100;
  t0.tm_mon = 0;
  t0.tm_mday = 1;
  t0.tm_hour = 0;
  t0.tm_min = 0;
  t0.tm_sec = 0;
 
  const time_t jsec0 = (time_t) jsec + timegm(&t0);
  t1 = gmtime(&jsec0);
 
  *year = t1->tm_year + 1900;
  *mon = t1->tm_mon + 1;
  *day = t1->tm_mday;
  *hour = t1->tm_hour;
  *min = t1->tm_min;
  *sec = t1->tm_sec;
  *remain = jsec - floor(jsec);
}
 
/*****************************************************************************/
 
void kernel(
  const ctl_t *ctl,
  const tbl_t *tbl,
  atm_t *atm,
  obs_t *obs,
  gsl_matrix *k) {
 
  /* Get sizes... */
  const size_t m = k->size1;
  const size_t n = k->size2;
  const size_t nthreads = (size_t) MAX(1, omp_get_max_threads());
  const size_t batch_size = n < nthreads ? n : nthreads;
 
  /* Allocate... */
  gsl_vector *x0 = gsl_vector_alloc(n);
  gsl_vector *yy0 = gsl_vector_alloc(m);
  gsl_vector *x1 = gsl_vector_alloc(n);
  gsl_vector *yy1 = gsl_vector_alloc(m);
  int *iqa;
  ALLOC(iqa, int,
        N);
  double *h_batch;
  int *status;
  ALLOC(h_batch, double,
        batch_size);
  ALLOC(status, int,
        batch_size);
  los_t *los0, *los1;
  atm_t *atm1;
  obs_t *obs_scratch0, *obs1, *obs_scratch1;
  ALLOC(los0, los_t, 1);
  ALLOC(obs_scratch0, obs_t, 1);
  ALLOC(atm1, atm_t, batch_size);
  ALLOC(obs1, obs_t, batch_size);
  ALLOC(los1, los_t, batch_size);
  ALLOC(obs_scratch1, obs_t, batch_size);
 
  /* Compute radiance for undisturbed atmospheric data... */
  if (formod(ctl, tbl, atm, obs, los0, obs_scratch0) != FORMOD_STATUS_OK)
    ERRMSG("Forward model failed!");
  free(los0);
  free(obs_scratch0);
 
  /* Compose vectors... */
  atm2x(ctl, atm, x0, iqa, NULL);
  obs2y(ctl, obs, yy0, NULL, NULL);
 
  /* Initialize kernel matrix... */
  gsl_matrix_set_zero(k);
 
  /* Loop over state vector elements in batches... */
  for (size_t j0 = 0; j0 < n; j0 += batch_size) {
    const size_t nbatch = MIN(batch_size, n - j0);
 
    /* Prepare disturbed states... */
    for (size_t jb = 0; jb < nbatch; jb++) {
      const size_t j = j0 + jb;
 
      /* Set perturbation size... */
      double h;
      if (iqa[j] == IDXP)
        h = MAX(fabs(KERNEL_P_REL * gsl_vector_get(x0, j)),
                KERNEL_P_MIN);
      else if (iqa[j] == IDXT)
        h = KERNEL_T_ABS;
      else if (iqa[j] >= IDXQ(0) && iqa[j] < IDXQ(ctl->ng))
        h = MAX(fabs(KERNEL_Q_REL * gsl_vector_get(x0, j)),
                KERNEL_Q_MIN);
      else if (iqa[j] >= IDXK(0) && iqa[j] < IDXK(ctl->nw))
        h = KERNEL_K_ABS;
      else if (iqa[j] == IDXCLZ)
        h = KERNEL_CLZ_ABS;
      else if (iqa[j] == IDXCLDZ)
        h = KERNEL_CLDZ_ABS;
      else if (iqa[j] >= IDXCLK(0) && iqa[j] < IDXCLK(ctl->ncl))
        h = KERNEL_CLK_ABS;
      else if (iqa[j] == IDXSFT)
        h = KERNEL_SFT_ABS;
      else if (iqa[j] >= IDXSFEPS(0) && iqa[j] < IDXSFEPS(ctl->nsf))
        h = KERNEL_SFEPS_ABS;
      else
        ERRMSG("Cannot set perturbation size!");
 
      /* Disturb state vector element... */
      gsl_vector_memcpy(x1, x0);
      gsl_vector_set(x1, j, gsl_vector_get(x1, j) + h);
      copy_atm(ctl, &atm1[jb], atm, 0);
      copy_obs(ctl, &obs1[jb], obs, 0);
      x2atm(ctl, x1, &atm1[jb]);
      h_batch[jb] = h;
    }
 
    /* Compute radiance for disturbed atmospheric data... */
    formod_batch(ctl, tbl, atm1, obs1, (int) nbatch, status, los1,
                 obs_scratch1);
 
    /* Compose measurement vectors and derivatives... */
    for (size_t jb = 0; jb < nbatch; jb++) {
      const size_t j = j0 + jb;
      if (status[jb] != FORMOD_STATUS_OK)
        ERRMSG("Forward model failed!");
      obs2y(ctl, &obs1[jb], yy1, NULL, NULL);
 
      /* Compute derivatives... */
      for (size_t i = 0; i < m; i++)
        gsl_matrix_set(k, i, j,
                       (gsl_vector_get(yy1, i) - gsl_vector_get(yy0, i))
                       / h_batch[jb]);
    }
  }
 
  /* Free... */
  gsl_vector_free(x0);
  gsl_vector_free(yy0);
  gsl_vector_free(x1);
  gsl_vector_free(yy1);
  free(atm1);
  free(obs1);
  free(obs_scratch1);
  free(los1);
  free(status);
  free(h_batch);
  free(iqa);
}
 
/*****************************************************************************/
 
int locate_irr(
  const double *xx,
  const int n,
  const double x) {
 
  int ilo = 0;
  int ihi = n - 1;
  int i = (ihi + ilo) >> 1;
 
  if (xx[i] < xx[i + 1])
    while (ihi > ilo + 1) {
      i = (ihi + ilo) >> 1;
      if (xx[i] > x)
        ihi = i;
      else
        ilo = i;
  } else
    while (ihi > ilo + 1) {
      i = (ihi + ilo) >> 1;
      if (xx[i] <= x)
        ihi = i;
      else
        ilo = i;
    }
 
  return ilo;
}
 
/*****************************************************************************/
 
int locate_reg(
  const double *xx,
  const int n,
  const double x) {
 
  /* Calculate index... */
  const int i = (int) ((x - xx[0]) / (xx[1] - xx[0]));
 
  /* Check range... */
  if (i < 0)
    return 0;
  else if (i > n - 2)
    return n - 2;
  else
    return i;
}
 
/*****************************************************************************/
 
inline int locate_tbl(
  const float *xx,
  const int n,
  const double x) {
 
  int ilo = 0;
  int ihi = n - 1;
  int i = (ihi + ilo) >> 1;
 
  while (ihi > ilo + 1) {
    i = (ihi + ilo) >> 1;
    if (xx[i] > x)
      ihi = i;
    else
      ilo = i;
  }
 
  return ilo;
}
 
/*****************************************************************************/
 
void matrix_invert(
  gsl_matrix *a) {
 
  size_t diag = 1;
 
  /* Get size... */
  const size_t n = a->size1;
 
  /* Check if matrix is diagonal... */
  for (size_t i = 0; i < n && diag; i++)
    for (size_t j = i + 1; j < n; j++)
      if (gsl_matrix_get(a, i, j) != 0) {
        diag = 0;
        break;
      }
 
  /* Quick inversion of diagonal matrix... */
  if (diag)
    for (size_t i = 0; i < n; i++)
      gsl_matrix_set(a, i, i, 1 / gsl_matrix_get(a, i, i));
 
  /* Matrix inversion by means of Cholesky decomposition... */
  else {
    gsl_linalg_cholesky_decomp(a);
    gsl_linalg_cholesky_invert(a);
  }
}
 
/*****************************************************************************/
 
void matrix_product(
  const gsl_matrix *a,
  const gsl_vector *b,
  const int transpose,
  gsl_matrix *c) {
 
  /* Set sizes... */
  const size_t m = a->size1;
  const size_t n = a->size2;
 
  /* Allocate... */
  gsl_matrix *aux = gsl_matrix_alloc(m, n);
 
  /* Compute A^T B A... */
  if (transpose == 1) {
 
    /* Compute B^1/2 A... */
    for (size_t i = 0; i < m; i++)
      for (size_t j = 0; j < n; j++)
        gsl_matrix_set(aux, i, j,
                       gsl_vector_get(b, i) * gsl_matrix_get(a, i, j));
 
    /* Compute A^T B A = (B^1/2 A)^T (B^1/2 A)... */
    gsl_blas_dgemm(CblasTrans, CblasNoTrans, 1.0, aux, aux, 0.0, c);
  }
 
  /* Compute A B A^T... */
  else if (transpose == 2) {
 
    /* Compute A B^1/2... */
    for (size_t i = 0; i < m; i++)
      for (size_t j = 0; j < n; j++)
        gsl_matrix_set(aux, i, j,
                       gsl_matrix_get(a, i, j) * gsl_vector_get(b, j));
 
    /* Compute A B A^T = (A B^1/2) (A B^1/2)^T... */
    gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1.0, aux, aux, 0.0, c);
  }
 
  /* Free... */
  gsl_matrix_free(aux);
}
 
/*****************************************************************************/
 
size_t obs2y(
  const ctl_t *ctl,
  const obs_t *obs,
  gsl_vector *y,
  int *ida,
  int *ira) {
 
  size_t m = 0;
 
  /* Determine measurement vector... */
  for (int ir = 0; ir < obs->nr; ir++)
    for (int id = 0; id < ctl->nd; id++)
      if (isfinite(obs->rad[id][ir])) {
        if (y != NULL)
          gsl_vector_set(y, m, obs->rad[id][ir]);
        if (ida != NULL)
          ida[m] = id;
        if (ira != NULL)
          ira[m] = ir;
        m++;
      }
 
  return m;
}
 
/*****************************************************************************/
 
void optimal_estimation(
  ret_t *ret,
  ctl_t *ctl,
  tbl_t *tbl,
  obs_t *obs_meas,
  obs_t *obs_i,
  atm_t *atm_apr,
  atm_t *atm_i,
  double *chisq) {
 
  double disq = 0, lmpar = 0.001;
 
  /* ------------------------------------------------------------
     Initialize...
     ------------------------------------------------------------ */
 
  /* Allocate... */
  int *ipa, *iqa;
  ALLOC(ipa, int,
        N);
  ALLOC(iqa, int,
        N);
 
  /* Get sizes... */
  const size_t m = obs2y(ctl, obs_meas, NULL, NULL, NULL);
  const size_t n = atm2x(ctl, atm_apr, NULL, iqa, ipa);
  if (m == 0 || n == 0) {
    WARN("Check problem definition (m = 0 or n = 0)!");
    *chisq = GSL_NAN;
    return;
  }
 
  /* Allocate... */
  gsl_matrix *a = gsl_matrix_alloc(n, n);
  gsl_matrix *cov = gsl_matrix_alloc(n, n);
  gsl_matrix *k_i = gsl_matrix_alloc(m, n);
  gsl_matrix *s_a_inv = gsl_matrix_alloc(n, n);
 
  gsl_vector *b = gsl_vector_alloc(n);
  gsl_vector *dx = gsl_vector_alloc(n);
  gsl_vector *dy = gsl_vector_alloc(m);
  gsl_vector *sig_eps_inv = gsl_vector_alloc(m);
  gsl_vector *sig_formod = gsl_vector_alloc(m);
  gsl_vector *sig_noise = gsl_vector_alloc(m);
  gsl_vector *x_a = gsl_vector_alloc(n);
  gsl_vector *x_i = gsl_vector_alloc(n);
  gsl_vector *x_step = gsl_vector_alloc(n);
  gsl_vector *y_aux = gsl_vector_alloc(m);
  gsl_vector *y_i = gsl_vector_alloc(m);
  gsl_vector *y_m = gsl_vector_alloc(m);
 
  los_t *los_scratch;
  obs_t *obs_scratch;
  ALLOC(los_scratch, los_t, 1);
  ALLOC(obs_scratch, obs_t, 1);
 
  /* Set timer... */
  SELECT_TIMER("RET_SETUP", "RETRIEVAL");
 
  /* Set initial state... */
  copy_atm(ctl, atm_i, atm_apr, 0);
  copy_obs(ctl, obs_i, obs_meas, 0);
  if (formod(ctl, tbl, atm_i, obs_i, los_scratch, obs_scratch)
      != FORMOD_STATUS_OK)
    ERRMSG("Forward model failed!");
 
  /* Set state vectors and observation vectors... */
  atm2x(ctl, atm_apr, x_a, NULL, NULL);
  atm2x(ctl, atm_i, x_i, NULL, NULL);
  obs2y(ctl, obs_meas, y_m, NULL, NULL);
  obs2y(ctl, obs_i, y_i, NULL, NULL);
 
  /* Set inverse a priori covariance S_a^-1... */
  set_cov_apr(ret, ctl, atm_apr, iqa, ipa, s_a_inv);
  int lockfd = shared_io_lock(ret);
  const char *dirname;
  int profile;
  const char *filename =
    shared_io_output_target(ret, ret->shared_io_matrix_cov_apr_file,
                            "matrix_cov_apr.tab", &dirname, &profile);
  write_matrix(dirname, filename, ctl, s_a_inv,
               atm_i, obs_i, "x", "x", "r", profile);
  shared_io_unlock(lockfd);
  matrix_invert(s_a_inv);
 
  /* Get measurement errors... */
  set_cov_meas(ret, ctl, obs_meas, sig_noise, sig_formod, sig_eps_inv);
 
  /* Determine dx = x_i - x_a and dy = y - F(x_i) ... */
  gsl_vector_memcpy(dx, x_i);
  gsl_vector_sub(dx, x_a);
  gsl_vector_memcpy(dy, y_m);
  gsl_vector_sub(dy, y_i);
 
  /* Compute cost function... */
  *chisq = cost_function(dx, dy, s_a_inv, sig_eps_inv);
 
  /* Write info... */
  LOG(2, "it= %d / chi^2/m= %g", 0, *chisq);
 
  /* Compute initial kernel... */
  SELECT_TIMER("RET_KERNEL_INIT", "RETRIEVAL");
  kernel(ctl, tbl, atm_i, obs_i, k_i);
 
  /* ------------------------------------------------------------
     Levenberg-Marquardt minimization...
     ------------------------------------------------------------ */
 
  SELECT_TIMER("RET_ITERATE", "RETRIEVAL");
 
  /* Outer loop... */
  for (int it = 1; it <= ret->conv_itmax; it++) {
 
    /* Store current cost function value... */
    double chisq_old = *chisq;
 
    /* Compute kernel matrix K_i... */
    if (it > 1 && it % ret->kernel_recomp == 0)
      kernel(ctl, tbl, atm_i, obs_i, k_i);
 
    /* Compute K_i^T * S_eps^{-1} * K_i ... */
    if (it == 1 || it % ret->kernel_recomp == 0)
      matrix_product(k_i, sig_eps_inv, 1, cov);
 
    /* Determine b = K_i^T * S_eps^{-1} * dy - S_a^{-1} * dx ... */
    for (size_t i = 0; i < m; i++)
      gsl_vector_set(y_aux, i, gsl_vector_get(dy, i)
                     * POW2(gsl_vector_get(sig_eps_inv, i)));
    gsl_blas_dgemv(CblasTrans, 1.0, k_i, y_aux, 0.0, b);
    gsl_blas_dgemv(CblasNoTrans, -1.0, s_a_inv, dx, 1.0, b);
 
    /* Inner loop... */
    for (int it2 = 0; it2 < 20; it2++) {
 
      /* Compute A = (1 + lmpar) * S_a^{-1} + K_i^T * S_eps^{-1} * K_i ... */
      gsl_matrix_memcpy(a, s_a_inv);
      gsl_matrix_scale(a, 1 + lmpar);
      gsl_matrix_add(a, cov);
 
      /* Solve A * x_step = b by means of Cholesky decomposition... */
      gsl_linalg_cholesky_decomp(a);
      gsl_linalg_cholesky_solve(a, b, x_step);
 
      /* Update atmospheric state... */
      gsl_vector_add(x_i, x_step);
      copy_atm(ctl, atm_i, atm_apr, 0);
      copy_obs(ctl, obs_i, obs_meas, 0);
      x2atm(ctl, x_i, atm_i);
 
      /* Check atmospheric state... */
      for (int ip = 0; ip < atm_i->np; ip++) {
        atm_i->p[ip] = CLAMP(atm_i->p[ip], 5e-7, 5e4);
        atm_i->t[ip] = CLAMP(atm_i->t[ip], 100.0, 400.0);
        for (int ig = 0; ig < ctl->ng; ig++)
          atm_i->q[ig][ip] = CLAMP(atm_i->q[ig][ip], 0.0, 1.0);
        for (int iw = 0; iw < ctl->nw; iw++)
          atm_i->k[iw][ip] = MAX(atm_i->k[iw][ip], 0.0);
      }
      atm_i->clz = MAX(atm_i->clz, 0.0);
      atm_i->cldz = MAX(atm_i->cldz, 0.1);
      for (int icl = 0; icl < ctl->ncl; icl++)
        atm_i->clk[icl] = MAX(atm_i->clk[icl], 0.0);
      atm_i->sft = CLAMP(atm_i->sft, 100.0, 400.0);
      for (int isf = 0; isf < ctl->nsf; isf++)
        atm_i->sfeps[isf] = CLAMP(atm_i->sfeps[isf], 0.0, 1.0);
 
      /* Forward calculation... */
      if (formod(ctl, tbl, atm_i, obs_i, los_scratch, obs_scratch)
          != FORMOD_STATUS_OK)
        ERRMSG("Forward model failed!");
      obs2y(ctl, obs_i, y_i, NULL, NULL);
 
      /* Determine dx = x_i - x_a and dy = y - F(x_i) ... */
      gsl_vector_memcpy(dx, x_i);
      gsl_vector_sub(dx, x_a);
      gsl_vector_memcpy(dy, y_m);
      gsl_vector_sub(dy, y_i);
 
      /* Compute cost function... */
      *chisq = cost_function(dx, dy, s_a_inv, sig_eps_inv);
 
      /* Modify Levenberg-Marquardt parameter... */
      if (*chisq > chisq_old) {
        lmpar *= 10;
        gsl_vector_sub(x_i, x_step);
      } else {
        lmpar /= 10;
        break;
      }
    }
 
    /* Write info... */
    LOG(2, "it= %d / chi^2/m= %g", it, *chisq);
 
    /* Get normalized step size in state space... */
    gsl_blas_ddot(x_step, b, &disq);
    disq /= (double) n;
 
    /* Convergence test... */
    if ((it == 1 || it % ret->kernel_recomp == 0) && disq < ret->conv_dmin)
      break;
  }
 
  /* ------------------------------------------------------------
     Analysis of retrieval results...
     ------------------------------------------------------------ */
 
  /* Check if error analysis is requested... */
  if (ret->err_ana) {
 
    SELECT_TIMER("RET_DIAGNOSTICS", "OUTPUT");
 
    /* Store results... */
    lockfd = shared_io_lock(ret);
    filename = shared_io_output_target(ret, ret->shared_io_atm_final_file,
                                       "atm_final.tab", &dirname, &profile);
    write_atm(dirname, filename, ctl, atm_i, profile);
    filename = shared_io_output_target(ret, ret->shared_io_obs_final_file,
                                       "obs_final.tab", &dirname, &profile);
    write_obs(dirname, filename, ctl, obs_i, profile);
    filename =
      shared_io_output_target(ret, ret->shared_io_matrix_kernel_file,
                              "matrix_kernel.tab", &dirname, &profile);
    write_matrix(dirname, filename, ctl, k_i,
                 atm_i, obs_i, "y", "x", "r", profile);
 
    /* Allocate... */
    gsl_matrix *auxnm = gsl_matrix_alloc(n, m);
    gsl_matrix *corr = gsl_matrix_alloc(n, n);
    gsl_matrix *gain = gsl_matrix_alloc(n, m);
 
    /* Compute inverse retrieval covariance...
       cov^{-1} = S_a^{-1} + K_i^T * S_eps^{-1} * K_i */
    matrix_product(k_i, sig_eps_inv, 1, cov);
    gsl_matrix_add(cov, s_a_inv);
 
    /* Compute retrieval covariance... */
    matrix_invert(cov);
    filename =
      shared_io_output_target(ret, ret->shared_io_matrix_cov_ret_file,
                              "matrix_cov_ret.tab", &dirname, &profile);
    write_matrix(dirname, filename, ctl, cov,
                 atm_i, obs_i, "x", "x", "r", profile);
    write_stddev("total", ret, ctl, atm_i, cov);
 
    /* Compute correlation matrix... */
    for (size_t i = 0; i < n; i++)
      for (size_t j = 0; j < n; j++)
        gsl_matrix_set(corr, i, j, gsl_matrix_get(cov, i, j)
                       / sqrt(gsl_matrix_get(cov, i, i))
                       / sqrt(gsl_matrix_get(cov, j, j)));
    filename = shared_io_output_target(ret, ret->shared_io_matrix_corr_file,
                                       "matrix_corr.tab", &dirname, &profile);
    write_matrix(dirname, filename, ctl, corr,
                 atm_i, obs_i, "x", "x", "r", profile);
 
    /* Compute gain matrix...
       G = cov * K^T * S_eps^{-1} */
    for (size_t i = 0; i < n; i++)
      for (size_t j = 0; j < m; j++)
        gsl_matrix_set(auxnm, i, j, gsl_matrix_get(k_i, j, i)
                       * POW2(gsl_vector_get(sig_eps_inv, j)));
    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, cov, auxnm, 0.0, gain);
    filename = shared_io_output_target(ret, ret->shared_io_matrix_gain_file,
                                       "matrix_gain.tab", &dirname, &profile);
    write_matrix(dirname, filename, ctl, gain,
                 atm_i, obs_i, "x", "y", "c", profile);
 
    /* Compute retrieval error due to noise... */
    matrix_product(gain, sig_noise, 2, a);
    write_stddev("noise", ret, ctl, atm_i, a);
 
    /* Compute retrieval error  due to forward model errors... */
    matrix_product(gain, sig_formod, 2, a);
    write_stddev("formod", ret, ctl, atm_i, a);
 
    /* Compute averaging kernel matrix
       A = G * K ... */
    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, gain, k_i, 0.0, a);
    filename = shared_io_output_target(ret, ret->shared_io_matrix_avk_file,
                                       "matrix_avk.tab", &dirname, &profile);
    write_matrix(dirname, filename, ctl, a,
                 atm_i, obs_i, "x", "x", "r", profile);
 
    /* Analyze averaging kernel matrix... */
    analyze_avk(ret, ctl, atm_i, iqa, ipa, a);
    shared_io_unlock(lockfd);
 
    /* Free... */
    gsl_matrix_free(auxnm);
    gsl_matrix_free(corr);
    gsl_matrix_free(gain);
  }
 
  /* ------------------------------------------------------------
     Finalize...
     ------------------------------------------------------------ */
 
  gsl_matrix_free(a);
  gsl_matrix_free(cov);
  gsl_matrix_free(k_i);
  gsl_matrix_free(s_a_inv);
 
  gsl_vector_free(b);
  gsl_vector_free(dx);
  gsl_vector_free(dy);
  gsl_vector_free(sig_eps_inv);
  gsl_vector_free(sig_formod);
  gsl_vector_free(sig_noise);
  gsl_vector_free(x_a);
  gsl_vector_free(x_i);
  gsl_vector_free(x_step);
  gsl_vector_free(y_aux);
  gsl_vector_free(y_i);
  gsl_vector_free(y_m);
  free(los_scratch);
  free(obs_scratch);
 
  free(ipa);
  free(iqa);
}
 
/*****************************************************************************/
 
int raytrace(
  const ctl_t *ctl,
  const atm_t *atm,
  obs_t *obs,
  los_t *los,
  const int ir) {
 
  /* Cartesian gradient step and refraction cutoff [km]. */
  const double h = 0.02, zrefrac = 60;
 
  double ex0[3], ex1[3], k[NW], lat, lon, n, ng[3], norm, p, q[NG], t,
    x[3], xh[3], xobs[3], xvp[3], z = 1e99, zmax, zmin;
 
  int stop = 0;
 
  /* Initialize... */
  los->np = 0;
  los->sft = -999;
  obs->tpz[ir] = obs->vpz[ir];
  obs->tplon[ir] = obs->vplon[ir];
  obs->tplat[ir] = obs->vplat[ir];
 
  /* Get altitude range of atmospheric data... */
  gsl_stats_minmax(&zmin, &zmax, atm->z, 1, (size_t) atm->np);
 
  /* Check observer altitude... */
  if (obs->obsz[ir] < zmin)
    return FORMOD_STATUS_OBSERVER_BELOW_SURFACE;
 
  /* Determine Cartesian coordinates for observer and view point... */
  geo2cart(obs->obsz[ir], obs->obslon[ir], obs->obslat[ir], xobs);
  geo2cart(obs->vpz[ir], obs->vplon[ir], obs->vplat[ir], xvp);
 
  /* Determine initial tangent vector... */
  for (int i = 0; i < 3; i++)
    ex0[i] = xvp[i] - xobs[i];
  norm = NORM(ex0);
  for (int i = 0; i < 3; i++)
    ex0[i] /= norm;
 
  /* Observer within atmosphere... */
  for (int i = 0; i < 3; i++)
    x[i] = xobs[i];
 
  /* Observer above atmosphere (search entry point)... */
  if (obs->obsz[ir] > zmax) {
    double dmax = norm, dmin = 0;
    while (fabs(dmin - dmax) > 0.001) {
      const double d = (dmax + dmin) / 2;
      for (int i = 0; i < 3; i++)
        x[i] = xobs[i] + d * ex0[i];
      cart2geo(x, &z, &lon, &lat);
      if (z <= zmax && z > zmax - 0.001)
        break;
      if (z < zmax - 0.0005)
        dmax = d;
      else
        dmin = d;
    }
  }
 
  /* Ray-tracing... */
  while (1) {
 
    /* Set step length... */
    double ds = ctl->rayds;
    if (ctl->raydz > 0) {
      norm = NORM(x);
      for (int i = 0; i < 3; i++)
        xh[i] = x[i] / norm;
      const double cosa = fabs(DOTP(ex0, xh));
      if (cosa != 0)
        ds = MIN(ctl->rayds, ctl->raydz / cosa);
    }
 
    /* Determine geolocation... */
    cart2geo(x, &z, &lon, &lat);
 
    /* Check if LOS hits the ground or has left atmosphere... */
    if (z < zmin || z > zmax) {
      if (los->np == 0)
        return FORMOD_STATUS_NO_ATMOSPHERE_INTERSECTION;
      stop = (z < zmin ? 2 : 1);
      const double frac =
        ((z <
          zmin ? zmin : zmax) - los->z[los->np - 1]) / (z - los->z[los->np -
                                                                   1]);
      geo2cart(los->z[los->np - 1], los->lon[los->np - 1],
               los->lat[los->np - 1], xh);
      for (int i = 0; i < 3; i++)
        x[i] = xh[i] + frac * (x[i] - xh[i]);
      cart2geo(x, &z, &lon, &lat);
      los->ds[los->np - 1] = ds * frac;
      ds = 0;
    }
 
    /* Interpolate atmospheric data... */
    intpol_atm(ctl, atm, z, &p, &t, q, k);
 
    /* Abort before writing beyond the fixed LOS scratch buffers... */
    if (los->np >= NLOS)
      return FORMOD_STATUS_TOO_MANY_LOS_POINTS;
 
    /* Save data... */
    los->lon[los->np] = lon;
    los->lat[los->np] = lat;
    los->z[los->np] = z;
    los->p[los->np] = p;
    los->t[los->np] = t;
    for (int ig = 0; ig < ctl->ng; ig++)
      los->q[los->np][ig] = q[ig];
    for (int id = 0; id < ctl->nd; id++)
      los->k[los->np][id] = k[ctl->window[id]];
    los->ds[los->np] = ds;
 
    /* Add cloud extinction... */
    if (ctl->ncl > 0 && atm->cldz > 0) {
      const double aux = exp(-0.5 * POW2((z - atm->clz) / atm->cldz));
      for (int id = 0; id < ctl->nd; id++) {
        const int icl = locate_irr(ctl->clnu, ctl->ncl, ctl->nu[id]);
        los->k[los->np][id]
          += aux * LIN(ctl->clnu[icl], atm->clk[icl],
                       ctl->clnu[icl + 1], atm->clk[icl + 1], ctl->nu[id]);
      }
    }
 
    /* Increment number of LOS points... */
    los->np++;
 
    /* Check stop flag... */
    if (stop) {
 
      /* Set surface temperature... */
      if (ctl->nsf > 0 && atm->sft > 0)
        t = atm->sft;
      los->sft = (stop == 2 ? t : -999);
 
      /* Set surface emissivity... */
      for (int id = 0; id < ctl->nd; id++) {
        los->sfeps[id] = 1.0;
        if (ctl->nsf > 0) {
          const int isf = locate_irr(ctl->sfnu, ctl->nsf, ctl->nu[id]);
          los->sfeps[id] = LIN(ctl->sfnu[isf], atm->sfeps[isf],
                               ctl->sfnu[isf + 1], atm->sfeps[isf + 1],
                               ctl->nu[id]);
        }
      }
 
      /* Leave raytracer... */
      break;
    }
 
    /* Determine refractivity... */
    if (ctl->refrac && z <= zrefrac)
      n = 1 + REFRAC_EDLEN(p, t);
    else
      n = 1;
 
    /* Construct new tangent vector (first term)... */
    for (int i = 0; i < 3; i++)
      ex1[i] = ex0[i] * n;
 
    /* Compute gradient of refractivity... */
    if (ctl->refrac && z <= zrefrac) {
      for (int i = 0; i < 3; i++)
        xh[i] = x[i] + 0.5 * ds * ex0[i];
      cart2geo(xh, &z, &lon, &lat);
      intpol_atm(ctl, atm, z, &p, &t, q, k);
      n = REFRAC_EDLEN(p, t);
      for (int i = 0; i < 3; i++) {
        xh[i] += h;
        cart2geo(xh, &z, &lon, &lat);
        intpol_atm(ctl, atm, z, &p, &t, q, k);
        ng[i] = (REFRAC_EDLEN(p, t) - n) / h;
        xh[i] -= h;
      }
    } else
      for (int i = 0; i < 3; i++)
        ng[i] = 0;
 
    /* Construct new tangent vector (second term)... */
    for (int i = 0; i < 3; i++)
      ex1[i] += ds * ng[i];
 
    /* Normalize new tangent vector... */
    norm = NORM(ex1);
    for (int i = 0; i < 3; i++)
      ex1[i] /= norm;
 
    /* Determine next point of LOS... */
    for (int i = 0; i < 3; i++)
      x[i] += 0.5 * ds * (ex0[i] + ex1[i]);
 
    /* Copy tangent vector... */
    for (int i = 0; i < 3; i++)
      ex0[i] = ex1[i];
  }
 
  /* Get tangent point (to be done before changing segment lengths!)... */
  tangent_point(los, &obs->tpz[ir], &obs->tplon[ir], &obs->tplat[ir]);
 
  /* Change segment lengths according to trapezoid rule... */
  for (int ip = los->np - 1; ip >= 1; ip--)
    los->ds[ip] = 0.5 * (los->ds[ip - 1] + los->ds[ip]);
  los->ds[0] *= 0.5;
 
  /* Compute column density... */
  for (int ip = 0; ip < los->np; ip++)
    for (int ig = 0; ig < ctl->ng; ig++)
      los->u[ip][ig] = 10 * los->q[ip][ig] * los->p[ip]
        / (KB * los->t[ip]) * los->ds[ip];
 
  /* Compute Curtis-Godson means... */
  for (int ig = 0; ig < ctl->ng; ig++) {
    los->cgu[0][ig] = los->u[0][ig];
    los->cgp[0][ig] = los->u[0][ig] * los->p[0];
    los->cgt[0][ig] = los->u[0][ig] * los->t[0];
  }
  for (int ip = 1; ip < los->np; ip++)
    for (int ig = 0; ig < ctl->ng; ig++) {
      los->cgu[ip][ig] = los->cgu[ip - 1][ig] + los->u[ip][ig];
      los->cgp[ip][ig] = los->cgp[ip - 1][ig] + los->u[ip][ig] * los->p[ip];
      los->cgt[ip][ig] = los->cgt[ip - 1][ig] + los->u[ip][ig] * los->t[ip];
    }
  for (int ip = 0; ip < los->np; ip++)
    for (int ig = 0; ig < ctl->ng; ig++)
      if (los->cgu[ip][ig] != 0) {
        los->cgp[ip][ig] /= los->cgu[ip][ig];
        los->cgt[ip][ig] /= los->cgu[ip][ig];
      }
 
  return FORMOD_STATUS_OK;
}
 
/*****************************************************************************/
 
void read_atm(
  const char *dirname,
  const char *filename,
  const ctl_t *ctl,
  atm_t *atm,
  int profile) {
 
  /* Init... */
  atm->np = 0;
 
  /* Set filename... */
  char file[LEN];
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Read atmospheric data: %s", file);
 
  /* Read ASCII data... */
  if (ctl->atmfmt == 1)
    read_atm_asc(file, ctl, atm);
 
  /* Read binary data... */
  else if (ctl->atmfmt == 2)
    read_atm_bin(file, ctl, atm);
 
  /* Read netCDF data... */
  else if (ctl->atmfmt == 3)
    read_atm_nc(file, ctl, atm, profile);
 
  /* Check number of points... */
  if (atm->np < 1)
    ERRMSG("Could not read any data!");
 
  /* Write info... */
  double mini, maxi;
  LOG(2, "Number of data points: %d", atm->np);
  gsl_stats_minmax(&mini, &maxi, atm->time, 1, (size_t) atm->np);
  LOG(2, "Time range: %.2f ... %.2f s", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, atm->z, 1, (size_t) atm->np);
  LOG(2, "Altitude range: %g ... %g km", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, atm->lon, 1, (size_t) atm->np);
  LOG(2, "Longitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, atm->lat, 1, (size_t) atm->np);
  LOG(2, "Latitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, atm->p, 1, (size_t) atm->np);
  LOG(2, "Pressure range: %g ... %g hPa", maxi, mini);
  gsl_stats_minmax(&mini, &maxi, atm->t, 1, (size_t) atm->np);
  LOG(2, "Temperature range: %g ... %g K", mini, maxi);
  for (int ig = 0; ig < ctl->ng; ig++) {
    gsl_stats_minmax(&mini, &maxi, atm->q[ig], 1, (size_t) atm->np);
    LOG(2, "Emitter %s range: %g ... %g ppv", ctl->emitter[ig], mini, maxi);
  }
  for (int iw = 0; iw < ctl->nw; iw++) {
    gsl_stats_minmax(&mini, &maxi, atm->k[iw], 1, (size_t) atm->np);
    LOG(2, "Extinction range (window %d): %g ... %g km^-1", iw, mini, maxi);
  }
  if (ctl->ncl > 0) {
    LOG(2, "Cloud layer: z= %g km | dz= %g km | k= %g ... %g km^-1",
        atm->clz, atm->cldz, atm->clk[0], atm->clk[ctl->ncl - 1]);
  } else
    LOG(2, "Cloud layer: none");
  if (ctl->nsf > 0) {
    LOG(2,
        "Surface: T_s = %g K | eps= %g ... %g",
        atm->sft, atm->sfeps[0], atm->sfeps[ctl->nsf - 1]);
  } else
    LOG(2, "Surface: none");
}
 
/*****************************************************************************/
 
void read_atm_asc(
  const char *filename,
  const ctl_t *ctl,
  atm_t *atm) {
 
  /* Init... */
  atm->np = 0;
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(filename, "r")))
    ERRMSG("Cannot open file!");
 
  /* Read line... */
  char line[LEN], *tok;
  while (fgets(line, LEN, in)) {
 
    /* Check capacity before writing a valid data point... */
    double time;
    TOK(line, tok, "%lg", time);
    if (atm->np >= NP)
      ERRMSG("Too many data points!");
 
    /* Read data... */
    atm->time[atm->np] = time;
    TOK(NULL, tok, "%lg", atm->z[atm->np]);
    TOK(NULL, tok, "%lg", atm->lon[atm->np]);
    TOK(NULL, tok, "%lg", atm->lat[atm->np]);
    TOK(NULL, tok, "%lg", atm->p[atm->np]);
    TOK(NULL, tok, "%lg", atm->t[atm->np]);
    for (int ig = 0; ig < ctl->ng; ig++)
      TOK(NULL, tok, "%lg", atm->q[ig][atm->np]);
    for (int iw = 0; iw < ctl->nw; iw++)
      TOK(NULL, tok, "%lg", atm->k[iw][atm->np]);
    if (ctl->ncl > 0 && atm->np == 0) {
      TOK(NULL, tok, "%lg", atm->clz);
      TOK(NULL, tok, "%lg", atm->cldz);
      for (int icl = 0; icl < ctl->ncl; icl++)
        TOK(NULL, tok, "%lg", atm->clk[icl]);
    }
    if (ctl->nsf > 0 && atm->np == 0) {
      TOK(NULL, tok, "%lg", atm->sft);
      for (int isf = 0; isf < ctl->nsf; isf++)
        TOK(NULL, tok, "%lg", atm->sfeps[isf]);
    }
 
    /* Increment data point counter... */
    ++atm->np;
  }
 
  /* Close file... */
  fclose(in);
}
 
/*****************************************************************************/
 
void read_atm_bin(
  const char *filename,
  const ctl_t *ctl,
  atm_t *atm) {
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(filename, "r")))
    ERRMSG("Cannot open file!");
 
  /* Read header... */
  char magic[4];
  FREAD(magic, char,
        4,
        in);
  if (memcmp(magic, "ATM1", 4) != 0)
    ERRMSG("Invalid magic string!");
 
  int ng, nw, ncl, nsf;
  FREAD(&ng, int,
        1,
        in);
  FREAD(&nw, int,
        1,
        in);
  FREAD(&ncl, int,
        1,
        in);
  FREAD(&nsf, int,
        1,
        in);
  if (ng != ctl->ng || nw != ctl->nw || ncl != ctl->ncl || nsf != ctl->nsf)
    ERRMSG("Error reading file header!");
 
  /* Read data... */
  size_t np;
  FREAD(&np, size_t,
        1,
        in);
  atm->np = (int) np;
  if (atm->np > NP)
    ERRMSG("Too many data points!");
  FREAD(atm->time, double,
        np,
        in);
  FREAD(atm->z, double,
        np,
        in);
  FREAD(atm->lon, double,
        np,
        in);
  FREAD(atm->lat, double,
        np,
        in);
  FREAD(atm->p, double,
        np,
        in);
  FREAD(atm->t, double,
        np,
        in);
  for (int ig = 0; ig < ctl->ng; ig++)
    FREAD(atm->q[ig], double,
          np,
          in);
  for (int iw = 0; iw < ctl->nw; iw++)
    FREAD(atm->k[iw], double,
          np,
          in);
  if (ctl->ncl > 0) {
    FREAD(&atm->clz, double,
          1,
          in);
    FREAD(&atm->cldz, double,
          1,
          in);
    FREAD(atm->clk, double,
            (size_t) ctl->ncl,
          in);
  }
  if (ctl->nsf) {
    FREAD(&atm->sft, double,
          1,
          in);
    FREAD(atm->sfeps, double,
            (size_t) ctl->nsf,
          in);
  }
 
  /* Close file... */
  fclose(in);
}
 
/*****************************************************************************/
 
void read_atm_nc(
  const char *filename,
  const ctl_t *ctl,
  atm_t *atm,
  int profile) {
 
  int ncid, var_time, var_z, var_lon, var_lat, var_p, var_t, var_q[NG],
    var_k[NW], var_cz = -1, var_cdz = -1, var_ck[NCL], var_sft =
    -1, var_sfe[NSF], var_nlev = -1;
 
  char varname[LEN];
 
  /* Open file... */
  NC(nc_open(filename, NC_NOWRITE, &ncid));
 
  /* Initialize hyperslab... */
  size_t start[2] = { (size_t) profile, 0 };
  size_t count[2] = { 1, 0 };
 
  /* Determine atm->np... */
  NC(nc_inq_varid(ncid, "nlev", &var_nlev));
  NC(nc_get_vara_int(ncid, var_nlev, start, count, &atm->np));
  if (atm->np < 1 || atm->np > NP)
    ERRMSG("Number of level out of range!");
 
  /* Update hyperslab... */
  count[1] = (size_t) atm->np;
 
  /* Inquire core variables... */
  NC(nc_inq_varid(ncid, "time", &var_time));
  NC(nc_inq_varid(ncid, "z", &var_z));
  NC(nc_inq_varid(ncid, "lon", &var_lon));
  NC(nc_inq_varid(ncid, "lat", &var_lat));
  NC(nc_inq_varid(ncid, "p", &var_p));
  NC(nc_inq_varid(ncid, "t", &var_t));
 
  /* Inquire emiters... */
  for (int ig = 0; ig < ctl->ng; ig++)
    NC(nc_inq_varid(ncid, ctl->emitter[ig], &var_q[ig]));
 
  /* Inquire extinctions... */
  for (int iw = 0; iw < ctl->nw; iw++) {
    sprintf(varname, "ext_win_%d", iw);
    NC(nc_inq_varid(ncid, varname, &var_k[iw]));
  }
 
  /* Inquire cloud variables... */
  if (ctl->ncl > 0) {
    NC(nc_inq_varid(ncid, "cld_z", &var_cz));
    NC(nc_inq_varid(ncid, "cld_dz", &var_cdz));
    for (int icl = 0; icl < ctl->ncl; icl++) {
      sprintf(varname, "cld_k_%.4f", ctl->clnu[icl]);
      NC(nc_inq_varid(ncid, varname, &var_ck[icl]));
    }
  }
 
  /* Inquire surface variables... */
  if (ctl->nsf > 0) {
    NC(nc_inq_varid(ncid, "srf_t", &var_sft));
    for (int isf = 0; isf < ctl->nsf; isf++) {
      sprintf(varname, "srf_eps_%.4f", ctl->sfnu[isf]);
      NC(nc_inq_varid(ncid, varname, &var_sfe[isf]));
    }
  }
 
  /* Read core variables... */
  NC(nc_get_vara_double(ncid, var_time, start, count, atm->time));
  NC(nc_get_vara_double(ncid, var_z, start, count, atm->z));
  NC(nc_get_vara_double(ncid, var_lon, start, count, atm->lon));
  NC(nc_get_vara_double(ncid, var_lat, start, count, atm->lat));
  NC(nc_get_vara_double(ncid, var_p, start, count, atm->p));
  NC(nc_get_vara_double(ncid, var_t, start, count, atm->t));
 
  /* Read emitters... */
  for (int ig = 0; ig < ctl->ng; ig++)
    NC(nc_get_vara_double(ncid, var_q[ig], start, count, atm->q[ig]));
 
  /* Read extinctions... */
  for (int iw = 0; iw < ctl->nw; iw++)
    NC(nc_get_vara_double(ncid, var_k[iw], start, count, atm->k[iw]));
 
  /* Read cloud variables... */
  if (ctl->ncl > 0) {
    NC(nc_get_vara_double(ncid, var_cz, start, count, &atm->clz));
    NC(nc_get_vara_double(ncid, var_cdz, start, count, &atm->cldz));
    for (int icl = 0; icl < ctl->ncl; icl++)
      NC(nc_get_vara_double(ncid, var_ck[icl], start, count, &atm->clk[icl]));
  }
 
  /* Read surface variables... */
  if (ctl->nsf > 0) {
    NC(nc_get_vara_double(ncid, var_sft, start, count, &atm->sft));
 
    for (int isf = 0; isf < ctl->nsf; isf++)
      NC(nc_get_vara_double
         (ncid, var_sfe[isf], start, count, &atm->sfeps[isf]));
  }
 
  /* Close file... */
  NC(nc_close(ncid));
}
 
/*****************************************************************************/
 
void read_ctl(
  int argc,
  char *argv[],
  ctl_t *ctl) {
 
  /* Write info... */
  LOG(1, "\nJuelich Rapid Spectral Simulation Code (JURASSIC)\n"
      "(executable: %s | version: %s | compiled: %s, %s)\n",
      argv[0], VERSION, __DATE__, __TIME__);
 
  /* Emitters... */
  ctl->ng = (int) scan_ctl(argc, argv, "NG", -1, "0", NULL);
  if (ctl->ng < 0 || ctl->ng > NG)
    ERRMSG("Set 0 <= NG <= MAX!");
  for (int ig = 0; ig < ctl->ng; ig++)
    scan_ctl(argc, argv, "EMITTER", ig, "", ctl->emitter[ig]);
  ctl->ig_co2 = find_emitter(ctl, "CO2");
  ctl->ig_h2o = find_emitter(ctl, "H2O");
  ctl->ig_n2 = find_emitter(ctl, "N2");
  ctl->ig_o2 = find_emitter(ctl, "O2");
 
  /* Radiance channels... */
  ctl->nd = (int) scan_ctl(argc, argv, "ND", -1, "0", NULL);
  if (ctl->nd < 0 || ctl->nd > ND)
    ERRMSG("Set 0 <= ND <= MAX!");
  for (int id = 0; id < ctl->nd; id++)
    ctl->nu[id] = scan_ctl(argc, argv, "NU", id, "", NULL);
 
  /* Spectral windows... */
  ctl->nw = (int) scan_ctl(argc, argv, "NW", -1, "1", NULL);
  if (ctl->nw < 0 || ctl->nw > NW)
    ERRMSG("Set 0 <= NW <= MAX!");
  if (ctl->nd > 0 && ctl->nw == 0)
    ERRMSG("Set NW > 0 when ND > 0!");
  for (int id = 0; id < ctl->nd; id++) {
    const double window = scan_ctl(argc, argv, "WINDOW", id, "0", NULL);
    if (!(window >= 0 && window < ctl->nw) || window != (int) window)
      ERRMSG("Set WINDOW[%d] to an integer in [0, NW)!", id);
    ctl->window[id] = (int) window;
  }
 
  /* Cloud data... */
  ctl->ncl = (int) scan_ctl(argc, argv, "NCL", -1, "0", NULL);
  if (ctl->ncl < 0 || ctl->ncl > NCL)
    ERRMSG("Set 0 <= NCL <= MAX!");
  if (ctl->ncl == 1)
    ERRMSG("Set NCL > 1!");
  for (int icl = 0; icl < ctl->ncl; icl++)
    ctl->clnu[icl] = scan_ctl(argc, argv, "CLNU", icl, "", NULL);
 
  /* Surface data... */
  ctl->nsf = (int) scan_ctl(argc, argv, "NSF", -1, "0", NULL);
  if (ctl->nsf < 0 || ctl->nsf > NSF)
    ERRMSG("Set 0 <= NSF <= MAX!");
  if (ctl->nsf == 1)
    ERRMSG("Set NSF > 1!");
  for (int isf = 0; isf < ctl->nsf; isf++)
    ctl->sfnu[isf] = scan_ctl(argc, argv, "SFNU", isf, "", NULL);
  ctl->sftype = (int) scan_ctl(argc, argv, "SFTYPE", -1, "2", NULL);
  if (ctl->sftype < 0 || ctl->sftype > 3)
    ERRMSG("Set 0 <= SFTYPE <= 3!");
  ctl->sfsza = scan_ctl(argc, argv, "SFSZA", -1, "-999", NULL);
 
  /* Emissivity look-up tables... */
  scan_ctl(argc, argv, "TBLBASE", -1, "-", ctl->tblbase);
  ctl->tblfmt = (int) scan_ctl(argc, argv, "TBLFMT", -1, "1", NULL);
  if (ctl->tblfmt < 1 || ctl->tblfmt > 3)
    ERRMSG("Unknown look-up table file format, set TBLFMT to 1, 2, or 3!");
 
  /* Climatological data file... */
  scan_ctl(argc, argv, "CLIM_FILE", -1, "-", ctl->climfile);
 
  /* File formats... */
  ctl->atmfmt = (int) scan_ctl(argc, argv, "ATMFMT", -1, "1", NULL);
  if (ctl->atmfmt < 1 || ctl->atmfmt > 3)
    ERRMSG("Unknown atmospheric file format, set ATMFMT to 1, 2, or 3!");
  ctl->obsfmt = (int) scan_ctl(argc, argv, "OBSFMT", -1, "1", NULL);
  if (ctl->obsfmt < 1 || ctl->obsfmt > 3)
    ERRMSG("Unknown observation file format, set OBSFMT to 1, 2, or 3!");
  ctl->matrixfmt = (int) scan_ctl(argc, argv, "MATRIXFMT", -1, "1", NULL);
  if (ctl->matrixfmt < 1 || ctl->matrixfmt > 3)
    ERRMSG("Unknown matrix file format, set MATRIXFMT to 1, 2, or 3!");
 
  /* Hydrostatic equilibrium... */
  ctl->hydz = scan_ctl(argc, argv, "HYDZ", -1, "-999", NULL);
 
  /* Continua... */
  ctl->ctm_co2 = (int) scan_ctl(argc, argv, "CTM_CO2", -1, "1", NULL);
  ctl->ctm_h2o = (int) scan_ctl(argc, argv, "CTM_H2O", -1, "1", NULL);
  ctl->ctm_n2 = (int) scan_ctl(argc, argv, "CTM_N2", -1, "1", NULL);
  ctl->ctm_o2 = (int) scan_ctl(argc, argv, "CTM_O2", -1, "1", NULL);
 
  /* Ray-tracing... */
  ctl->refrac = (int) scan_ctl(argc, argv, "REFRAC", -1, "1", NULL);
  ctl->rayds = scan_ctl(argc, argv, "RAYDS", -1, "10", NULL);
  ctl->raydz = scan_ctl(argc, argv, "RAYDZ", -1, "0.1", NULL);
 
  /* Field of view... */
  scan_ctl(argc, argv, "FOV", -1, "-", ctl->fov);
  if (ctl->fov[0] != '-')
    read_shape(ctl->fov, ctl->fov_dz, ctl->fov_w, &ctl->fov_n);
 
  /* Retrieval interface... */
  ctl->retp_zmin = scan_ctl(argc, argv, "RETP_ZMIN", -1, "-999", NULL);
  ctl->retp_zmax = scan_ctl(argc, argv, "RETP_ZMAX", -1, "-999", NULL);
  ctl->rett_zmin = scan_ctl(argc, argv, "RETT_ZMIN", -1, "-999", NULL);
  ctl->rett_zmax = scan_ctl(argc, argv, "RETT_ZMAX", -1, "-999", NULL);
  for (int ig = 0; ig < ctl->ng; ig++) {
    ctl->retq_zmin[ig] = scan_ctl(argc, argv, "RETQ_ZMIN", ig, "-999", NULL);
    ctl->retq_zmax[ig] = scan_ctl(argc, argv, "RETQ_ZMAX", ig, "-999", NULL);
  }
  for (int iw = 0; iw < ctl->nw; iw++) {
    ctl->retk_zmin[iw] = scan_ctl(argc, argv, "RETK_ZMIN", iw, "-999", NULL);
    ctl->retk_zmax[iw] = scan_ctl(argc, argv, "RETK_ZMAX", iw, "-999", NULL);
  }
  ctl->ret_clz = (int) scan_ctl(argc, argv, "RET_CLZ", -1, "0", NULL);
  ctl->ret_cldz = (int) scan_ctl(argc, argv, "RET_CLDZ", -1, "0", NULL);
  ctl->ret_clk = (int) scan_ctl(argc, argv, "RET_CLK", -1, "0", NULL);
  ctl->ret_sft = (int) scan_ctl(argc, argv, "RET_SFT", -1, "0", NULL);
  ctl->ret_sfeps = (int) scan_ctl(argc, argv, "RET_SFEPS", -1, "0", NULL);
 
  /* Output flags... */
  ctl->write_bbt = (int) scan_ctl(argc, argv, "WRITE_BBT", -1, "0", NULL);
  ctl->write_matrix =
    (int) scan_ctl(argc, argv, "WRITE_MATRIX", -1, "0", NULL);
 
  /* External forward models... */
  ctl->formod = (int) scan_ctl(argc, argv, "FORMOD", -1, "1", NULL);
  scan_ctl(argc, argv, "RFMBIN", -1, "-", ctl->rfmbin);
  scan_ctl(argc, argv, "RFMTMP", -1, "-", ctl->rfmtmp);
  scan_ctl(argc, argv, "RFMHIT", -1, "-", ctl->rfmhit);
  for (int ig = 0; ig < ctl->ng; ig++)
    scan_ctl(argc, argv, "RFMXSC", ig, "-", ctl->rfmxsc[ig]);
}
 
/*****************************************************************************/
 
void read_matrix(
  const char *dirname,
  const char *filename,
  const ctl_t *ctl,
  gsl_matrix *matrix,
  int dataset) {
 
  /* Read ASCII data... */
  if (ctl->matrixfmt == 1)
    read_matrix_asc(dirname, filename, matrix);
 
  /* Read binary data... */
  else if (ctl->matrixfmt == 2)
    read_matrix_bin(dirname, filename, matrix);
 
  /* Read netCDF data... */
  else if (ctl->matrixfmt == 3)
    read_matrix_nc(dirname, filename, matrix, dataset);
 
  /* Error... */
  else
    ERRMSG("Unknown matrix file format, check MATRIXFMT!");
}
 
/*****************************************************************************/
 
void read_matrix_asc(
  const char *dirname,
  const char *filename,
  gsl_matrix *matrix) {
 
  char dum[LEN], file[LEN], line[LEN];
 
  double value;
 
  int i, j;
 
  /* Set filename... */
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Read matrix: %s", file);
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(file, "r")))
    ERRMSG("Cannot open file!");
 
  /* Read data... */
  gsl_matrix_set_zero(matrix);
  while (fgets(line, LEN, in))
    if (sscanf(line, "%d %s %s %s %s %s %d %s %s %s %s %s %lg",
               &i, dum, dum, dum, dum, dum,
               &j, dum, dum, dum, dum, dum, &value) == 13)
      gsl_matrix_set(matrix, (size_t) i, (size_t) j, value);
 
  /* Close file... */
  fclose(in);
}
 
/*****************************************************************************/
 
void read_matrix_bin(
  const char *dirname,
  const char *filename,
  gsl_matrix *matrix) {
 
  char file[LEN], magic[4];
  size_t nr, nc;
 
  /* Set filename... */
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Read matrix: %s", file);
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(file, "r")))
    ERRMSG("Cannot open file!");
 
  /* Read header... */
  FREAD(magic, char,
        4,
        in);
  if (memcmp(magic, "MAT1", 4) != 0)
    ERRMSG("Invalid magic string!");
  FREAD(&nr, size_t,
        1,
        in);
  FREAD(&nc, size_t,
        1,
        in);
  if (nr != matrix->size1 || nc != matrix->size2)
    ERRMSG("Error reading file header!");
 
  /* Read data... */
  for (size_t i = 0; i < nr; i++)
    for (size_t j = 0; j < nc; j++) {
      double value;
      FREAD(&value, double,
            1,
            in);
      gsl_matrix_set(matrix, i, j, value);
    }
 
  /* Close file... */
  fclose(in);
}
 
/*****************************************************************************/
 
void read_matrix_nc(
  const char *dirname,
  const char *filename,
  gsl_matrix *matrix,
  int dataset) {
 
  char file[LEN];
 
  int ncid, dimid_row, dimid_col, varid;
 
  size_t nr, nc;
 
  /* Set filename... */
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Read matrix: %s", file);
 
  /* Open file... */
  NC(nc_open(file, NC_NOWRITE, &ncid));
 
  /* Read dimensions... */
  NC(nc_inq_dimid(ncid, "row", &dimid_row));
  NC(nc_inq_dimid(ncid, "col", &dimid_col));
  NC(nc_inq_dimlen(ncid, dimid_row, &nr));
  NC(nc_inq_dimlen(ncid, dimid_col, &nc));
  if (nr != matrix->size1 || nc != matrix->size2)
    ERRMSG("Error reading file header!");
 
  /* Read data... */
  NC(nc_inq_varid(ncid, "matrix", &varid));
  for (size_t i = 0; i < nr; i++)
    for (size_t j = 0; j < nc; j++) {
      double value;
      size_t start[3] = { (size_t) dataset, i, j };
      size_t count[3] = { 1, 1, 1 };
      NC(nc_get_vara_double(ncid, varid, start, count, &value));
      gsl_matrix_set(matrix, i, j, value);
    }
 
  /* Close file... */
  NC(nc_close(ncid));
}
 
/*****************************************************************************/
 
void read_obs(
  const char *dirname,
  const char *filename,
  const ctl_t *ctl,
  obs_t *obs,
  int profile) {
 
  /* Set filename... */
  char file[LEN];
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Read observation data: %s", file);
 
  /* Read ASCII data... */
  if (ctl->obsfmt == 1)
    read_obs_asc(file, ctl, obs);
 
  /* Read binary data... */
  else if (ctl->obsfmt == 2)
    read_obs_bin(file, ctl, obs);
 
  /* Read netCDF data... */
  else if (ctl->obsfmt == 3)
    read_obs_nc(file, ctl, obs, profile);
 
  /* Check number of points... */
  if (obs->nr < 1)
    ERRMSG("Could not read any data!");
 
  /* Write info... */
  double mini, maxi;
  LOG(2, "Number of ray paths: %d", obs->nr);
  gsl_stats_minmax(&mini, &maxi, obs->time, 1, (size_t) obs->nr);
  LOG(2, "Time range: %.2f ... %.2f s", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->obsz, 1, (size_t) obs->nr);
  LOG(2, "Observer altitude range: %g ... %g km", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->obslon, 1, (size_t) obs->nr);
  LOG(2, "Observer longitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->obslat, 1, (size_t) obs->nr);
  LOG(2, "Observer latitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->vpz, 1, (size_t) obs->nr);
  LOG(2, "View point altitude range: %g ... %g km", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->vplon, 1, (size_t) obs->nr);
  LOG(2, "View point longitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->vplat, 1, (size_t) obs->nr);
  LOG(2, "View point latitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->tpz, 1, (size_t) obs->nr);
  LOG(2, "Tangent point altitude range: %g ... %g km", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->tplon, 1, (size_t) obs->nr);
  LOG(2, "Tangent point longitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->tplat, 1, (size_t) obs->nr);
  LOG(2, "Tangent point latitude range: %g ... %g deg", mini, maxi);
  for (int id = 0; id < ctl->nd; id++) {
    gsl_stats_minmax(&mini, &maxi, obs->rad[id], 1, (size_t) obs->nr);
    if (ctl->write_bbt) {
      LOG(2, "Brightness temperature (%.4f cm^-1) range: %g ... %g K",
          ctl->nu[id], mini, maxi);
    } else {
      LOG(2, "Radiance (%.4f cm^-1) range: %g ... %g W/(m^2 sr cm^-1)",
          ctl->nu[id], mini, maxi);
    }
  }
  for (int id = 0; id < ctl->nd; id++) {
    gsl_stats_minmax(&mini, &maxi, obs->tau[id], 1, (size_t) obs->nr);
    LOG(2, "Transmittance (%.4f cm^-1) range: %g ... %g",
        ctl->nu[id], mini, maxi);
  }
}
 
/*****************************************************************************/
 
void read_obs_asc(
  const char *filename,
  const ctl_t *ctl,
  obs_t *obs) {
 
  /* Init... */
  obs->nr = 0;
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(filename, "r")))
    ERRMSG("Cannot open file!");
 
  /* Read line... */
  char line[LEN], *tok;
  while (fgets(line, LEN, in)) {
 
    /* Check capacity before writing a valid ray... */
    double time;
    TOK(line, tok, "%lg", time);
    if (obs->nr >= NR)
      ERRMSG("Too many rays!");
 
    /* Read data... */
    obs->time[obs->nr] = time;
    TOK(NULL, tok, "%lg", obs->obsz[obs->nr]);
    TOK(NULL, tok, "%lg", obs->obslon[obs->nr]);
    TOK(NULL, tok, "%lg", obs->obslat[obs->nr]);
    TOK(NULL, tok, "%lg", obs->vpz[obs->nr]);
    TOK(NULL, tok, "%lg", obs->vplon[obs->nr]);
    TOK(NULL, tok, "%lg", obs->vplat[obs->nr]);
    TOK(NULL, tok, "%lg", obs->tpz[obs->nr]);
    TOK(NULL, tok, "%lg", obs->tplon[obs->nr]);
    TOK(NULL, tok, "%lg", obs->tplat[obs->nr]);
    for (int id = 0; id < ctl->nd; id++)
      TOK(NULL, tok, "%lg", obs->rad[id][obs->nr]);
    for (int id = 0; id < ctl->nd; id++)
      TOK(NULL, tok, "%lg", obs->tau[id][obs->nr]);
 
    /* Increment counter... */
    ++obs->nr;
  }
 
  /* Close file... */
  fclose(in);
}
 
/*****************************************************************************/
 
void read_obs_bin(
  const char *filename,
  const ctl_t *ctl,
  obs_t *obs) {
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(filename, "r")))
    ERRMSG("Cannot open file!");
 
  /* Read header... */
  char magic[4];
  FREAD(magic, char,
        4,
        in);
  if (memcmp(magic, "OBS1", 4) != 0)
    ERRMSG("Invalid magic string!");
 
  int nd;
  FREAD(&nd, int,
        1,
        in);
  if (nd != ctl->nd)
    ERRMSG("Error reading file header!");
 
  /* Read data... */
  size_t nr;
  FREAD(&nr, size_t,
        1,
        in);
  obs->nr = (int) nr;
  if (obs->nr > NR)
    ERRMSG("Too many ray paths!");
  FREAD(obs->time, double,
        nr,
        in);
  FREAD(obs->obsz, double,
        nr,
        in);
  FREAD(obs->obslon, double,
        nr,
        in);
  FREAD(obs->obslat, double,
        nr,
        in);
  FREAD(obs->vpz, double,
        nr,
        in);
  FREAD(obs->vplon, double,
        nr,
        in);
  FREAD(obs->vplat, double,
        nr,
        in);
  FREAD(obs->tpz, double,
        nr,
        in);
  FREAD(obs->tplon, double,
        nr,
        in);
  FREAD(obs->tplat, double,
        nr,
        in);
  for (int id = 0; id < ctl->nd; id++)
    FREAD(obs->rad[id], double,
          nr,
          in);
  for (int id = 0; id < ctl->nd; id++)
    FREAD(obs->tau[id], double,
          nr,
          in);
 
  /* Close file... */
  fclose(in);
}
 
/*****************************************************************************/
 
void read_obs_nc(
  const char *filename,
  const ctl_t *ctl,
  obs_t *obs,
  const int profile) {
 
  int ncid, var_nray = -1, var_time = -1, var_obsz = -1, var_obslon =
    -1, var_obslat = -1, var_vpz = -1, var_vplon = -1, var_vplat =
    -1, var_tpz = -1, var_tplon = -1, var_tplat =
    -1, var_rad[ND], var_tau[ND];
  const char *spec_prefix = ctl->write_bbt ? "bt" : "rad";
 
  /* Open file... */
  NC(nc_open(filename, NC_NOWRITE, &ncid));
 
  /* Initialize hyperslab... */
  size_t start[2] = { (size_t) profile, 0 };
  size_t count[2] = { 1, 0 };
 
  /* Read nray(profile) -> obs->nr */
  NC(nc_inq_varid(ncid, "nray", &var_nray));
  NC(nc_get_vara_int(ncid, var_nray, start, count, &obs->nr));
  if (obs->nr < 1 || obs->nr > NR)
    ERRMSG("Number of ray paths out of range!");
 
  /* Update hyperslab... */
  count[1] = (size_t) obs->nr;
 
  /* Inquire geometry variables... */
  NC(nc_inq_varid(ncid, "time", &var_time));
  NC(nc_inq_varid(ncid, "obs_z", &var_obsz));
  NC(nc_inq_varid(ncid, "obs_lon", &var_obslon));
  NC(nc_inq_varid(ncid, "obs_lat", &var_obslat));
 
  NC(nc_inq_varid(ncid, "vp_z", &var_vpz));
  NC(nc_inq_varid(ncid, "vp_lon", &var_vplon));
  NC(nc_inq_varid(ncid, "vp_lat", &var_vplat));
 
  NC(nc_inq_varid(ncid, "tp_z", &var_tpz));
  NC(nc_inq_varid(ncid, "tp_lon", &var_tplon));
  NC(nc_inq_varid(ncid, "tp_lat", &var_tplat));
 
  /* Inquire spectral variables per channel... */
  for (int id = 0; id < ctl->nd; id++) {
    char varname[LEN];
 
    sprintf(varname, "%s_%.4f", spec_prefix, ctl->nu[id]);
    NC(nc_inq_varid(ncid, varname, &var_rad[id]));
 
    sprintf(varname, "tau_%.4f", ctl->nu[id]);
    NC(nc_inq_varid(ncid, varname, &var_tau[id]));
  }
 
  /* Read geometry... */
  NC(nc_get_vara_double(ncid, var_time, start, count, obs->time));
  NC(nc_get_vara_double(ncid, var_obsz, start, count, obs->obsz));
  NC(nc_get_vara_double(ncid, var_obslon, start, count, obs->obslon));
  NC(nc_get_vara_double(ncid, var_obslat, start, count, obs->obslat));
 
  NC(nc_get_vara_double(ncid, var_vpz, start, count, obs->vpz));
  NC(nc_get_vara_double(ncid, var_vplon, start, count, obs->vplon));
  NC(nc_get_vara_double(ncid, var_vplat, start, count, obs->vplat));
 
  NC(nc_get_vara_double(ncid, var_tpz, start, count, obs->tpz));
  NC(nc_get_vara_double(ncid, var_tplon, start, count, obs->tplon));
  NC(nc_get_vara_double(ncid, var_tplat, start, count, obs->tplat));
 
  /* Read radiance and transmittance... */
  for (int id = 0; id < ctl->nd; id++) {
    NC(nc_get_vara_double(ncid, var_rad[id], start, count, obs->rad[id]));
    NC(nc_get_vara_double(ncid, var_tau[id], start, count, obs->tau[id]));
  }
 
  /* Close file... */
  NC(nc_close(ncid));
}
 
/*****************************************************************************/
 
double read_obs_rfm(
  const char *basename,
  const double z,
  const double *nu,
  const double *f,
  const int n) {
 
  double *nurfm, *spec;
 
  int npts;
 
  /* Allocate... */
  ALLOC(nurfm, double,
        RFMNPTS);
  ALLOC(spec, double,
        RFMNPTS);
 
  /* Search and read RFM spectrum... */
  char filename[LEN];
  find_rfm_file(filename, sizeof(filename), basename, z);
  read_rfm_spec(filename, nurfm, spec, &npts);
 
  /* Convolute... */
  const double result = convolve_rfm(nurfm, spec, npts, nu, f, n);
 
  /* Free... */
  free(nurfm);
  free(spec);
 
  return result;
}
 
/*****************************************************************************/
 
void read_ret(
  int argc,
  char *argv[],
  const ctl_t *ctl,
  ret_t *ret) {
 
  /* Iteration control... */
  ret->kernel_recomp =
    (int) scan_ctl(argc, argv, "KERNEL_RECOMP", -1, "3", NULL);
  ret->conv_itmax = (int) scan_ctl(argc, argv, "CONV_ITMAX", -1, "30", NULL);
  ret->conv_dmin = scan_ctl(argc, argv, "CONV_DMIN", -1, "0.1", NULL);
 
  /* Error analysis... */
  ret->err_ana = (int) scan_ctl(argc, argv, "ERR_ANA", -1, "0", NULL);
 
  for (int id = 0; id < ctl->nd; id++)
    ret->err_formod[id] = scan_ctl(argc, argv, "ERR_FORMOD", id, "0", NULL);
 
  for (int id = 0; id < ctl->nd; id++)
    ret->err_noise[id] = scan_ctl(argc, argv, "ERR_NOISE", id, "0", NULL);
 
  ret->err_press = scan_ctl(argc, argv, "ERR_PRESS", -1, "0", NULL);
  ret->err_press_cz = scan_ctl(argc, argv, "ERR_PRESS_CZ", -1, "-999", NULL);
  ret->err_press_ch = scan_ctl(argc, argv, "ERR_PRESS_CH", -1, "-999", NULL);
 
  ret->err_temp = scan_ctl(argc, argv, "ERR_TEMP", -1, "0", NULL);
  ret->err_temp_cz = scan_ctl(argc, argv, "ERR_TEMP_CZ", -1, "-999", NULL);
  ret->err_temp_ch = scan_ctl(argc, argv, "ERR_TEMP_CH", -1, "-999", NULL);
 
  for (int ig = 0; ig < ctl->ng; ig++) {
    ret->err_q[ig] = scan_ctl(argc, argv, "ERR_Q", ig, "0", NULL);
    ret->err_q_cz[ig] = scan_ctl(argc, argv, "ERR_Q_CZ", ig, "-999", NULL);
    ret->err_q_ch[ig] = scan_ctl(argc, argv, "ERR_Q_CH", ig, "-999", NULL);
  }
 
  for (int iw = 0; iw < ctl->nw; iw++) {
    ret->err_k[iw] = scan_ctl(argc, argv, "ERR_K", iw, "0", NULL);
    ret->err_k_cz[iw] = scan_ctl(argc, argv, "ERR_K_CZ", iw, "-999", NULL);
    ret->err_k_ch[iw] = scan_ctl(argc, argv, "ERR_K_CH", iw, "-999", NULL);
  }
 
  ret->err_clz = scan_ctl(argc, argv, "ERR_CLZ", -1, "0", NULL);
  ret->err_cldz = scan_ctl(argc, argv, "ERR_CLDZ", -1, "0", NULL);
  for (int icl = 0; icl < ctl->ncl; icl++)
    ret->err_clk[icl] = scan_ctl(argc, argv, "ERR_CLK", icl, "0", NULL);
 
  ret->err_sft = scan_ctl(argc, argv, "ERR_SFT", -1, "0", NULL);
  for (int isf = 0; isf < ctl->nsf; isf++)
    ret->err_sfeps[isf] = scan_ctl(argc, argv, "ERR_SFEPS", isf, "0", NULL);
 
  /* Shared retrieval I/O... */
  ret->shared_io_profile = 0;
  scan_ctl(argc, argv, "SHARED_IO_PROFLIST", -1, "-",
           ret->shared_io_proflist);
  scan_ctl(argc, argv, "SHARED_IO_ATM_APR_FILE", -1, "-",
           ret->shared_io_atm_apr_file);
  scan_ctl(argc, argv, "SHARED_IO_OBS_MEAS_FILE", -1, "-",
           ret->shared_io_obs_meas_file);
  scan_ctl(argc, argv, "SHARED_IO_ATM_FINAL_FILE", -1, "-",
           ret->shared_io_atm_final_file);
  scan_ctl(argc, argv, "SHARED_IO_OBS_FINAL_FILE", -1, "-",
           ret->shared_io_obs_final_file);
  scan_ctl(argc, argv, "SHARED_IO_MATRIX_COV_APR_FILE", -1, "-",
           ret->shared_io_matrix_cov_apr_file);
  scan_ctl(argc, argv, "SHARED_IO_MATRIX_KERNEL_FILE", -1, "-",
           ret->shared_io_matrix_kernel_file);
  scan_ctl(argc, argv, "SHARED_IO_MATRIX_COV_RET_FILE", -1, "-",
           ret->shared_io_matrix_cov_ret_file);
  scan_ctl(argc, argv, "SHARED_IO_MATRIX_CORR_FILE", -1, "-",
           ret->shared_io_matrix_corr_file);
  scan_ctl(argc, argv, "SHARED_IO_MATRIX_GAIN_FILE", -1, "-",
           ret->shared_io_matrix_gain_file);
  scan_ctl(argc, argv, "SHARED_IO_MATRIX_AVK_FILE", -1, "-",
           ret->shared_io_matrix_avk_file);
  scan_ctl(argc, argv, "SHARED_IO_ATM_ERR_TOTAL_FILE", -1, "-",
           ret->shared_io_atm_err_total_file);
  scan_ctl(argc, argv, "SHARED_IO_ATM_ERR_NOISE_FILE", -1, "-",
           ret->shared_io_atm_err_noise_file);
  scan_ctl(argc, argv, "SHARED_IO_ATM_ERR_FORMOD_FILE", -1, "-",
           ret->shared_io_atm_err_formod_file);
  scan_ctl(argc, argv, "SHARED_IO_ATM_CONT_FILE", -1, "-",
           ret->shared_io_atm_cont_file);
  scan_ctl(argc, argv, "SHARED_IO_ATM_RES_FILE", -1, "-",
           ret->shared_io_atm_res_file);
}
 
/*****************************************************************************/
 
void read_rfm_spec(
  const char *filename,
  double *nu,
  double *rad,
  int *npts) {
 
  char *line = NULL, *tok;
 
  size_t line_buf_size = 0;
 
  double dnu, nu0, nu1;
 
  int ipts = 0;
 
  /* Write info... */
  LOG(1, "Read RFM data: %s", filename);
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(filename, "r")))
    ERRMSG("Cannot open file!");
 
  /* Read header... */
  for (int i = 0; i < 4; i++)
    if (getline(&line, &line_buf_size, in) == -1)
      ERRMSG("Error while reading file header!");
  if (sscanf(line, "%d %lg %lg %lg", npts, &nu0, &dnu, &nu1) != 4)
    ERRMSG("Invalid spectrum header format!");
 
  /* Check number of spectral grid points... */
  if (*npts < 2)
    ERRMSG("RFM spectrum must contain at least two spectral points!");
  if (*npts > RFMNPTS)
    ERRMSG("Too many spectral grid points!");
 
  /* Read radiance data... */
  while (getline(&line, &line_buf_size, in) != -1 && ipts < *npts) {
    tok = strtok(line, " \t\n");
    while (tok != NULL && ipts < *npts) {
      if (sscanf(tok, "%lg", &rad[ipts]) == 1)
        ipts++;
      tok = strtok(NULL, " \t\n");
    }
  }
 
  /* Check number of spectral grid points... */
  if (ipts != *npts)
    ERRMSG("Error while reading RFM data!");
 
  /* Compute wavenumbers... */
  for (ipts = 0; ipts < *npts; ipts++)
    nu[ipts] = LIN(0.0, nu0, (double) (*npts - 1), nu1, (double) ipts);
 
  /* Close file... */
  fclose(in);
 
  /* Free.. */
  free(line);
}
 
/*****************************************************************************/
 
void read_shape(
  const char *filename,
  double *x,
  double *y,
  int *n) {
 
  char line[LEN];
 
  /* Write info... */
  LOG(1, "Read shape function: %s", filename);
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(filename, "r")))
    ERRMSG("Cannot open file!");
 
  /* Read data... */
  *n = 0;
  while (fgets(line, LEN, in)) {
    double xval, yval;
    if (sscanf(line, "%lg %lg", &xval, &yval) == 2) {
      if (*n >= NSHAPE)
        ERRMSG("Too many data points!");
      x[*n] = xval;
      y[*n] = yval;
      ++(*n);
    }
  }
 
  /* Close file... */
  fclose(in);
 
  /* Check number of data points... */
  if (*n < 2)
    ERRMSG("Could not read any data!");
 
  /* Write info... */
  double mini, maxi;
  LOG(2, "Number of data points: %d", *n);
  gsl_stats_minmax(&mini, &maxi, x, 1, (size_t) *n);
  LOG(2, "Range of x values: %.4f ... %.4f", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, y, 1, (size_t) *n);
  LOG(2, "Range of y values: %g ... %g", mini, maxi);
}
 
/*****************************************************************************/
 
tbl_t *read_tbl(
  const ctl_t *ctl) {
 
  /* Allocate... */
  tbl_t *tbl;
  ALLOC(tbl, tbl_t, 1);
 
  /* Initialize filter function sizes... */
  for (int id = 0; id < ctl->nd; id++)
    tbl->filt_n[id] = 0;
 
  /* Loop over trace gases... */
  for (int ig = 0; ig < ctl->ng; ig++) {
 
    /* Read ASCII look-up tables... */
    if (ctl->tblfmt == 1)
      for (int id = 0; id < ctl->nd; id++) {
        read_tbl_asc(ctl, tbl, id, ig);
        TBL_LOG(tbl, id, ig);
      }
 
    /* Read binary look-up tables... */
    else if (ctl->tblfmt == 2)
      for (int id = 0; id < ctl->nd; id++) {
        read_tbl_bin(ctl, tbl, id, ig);
        TBL_LOG(tbl, id, ig);
      }
 
    /* Read netCDF look-up tables... */
    else if (ctl->tblfmt == 3) {
 
      /* Open file... */
      int ncid;
      char filename[2 * LEN];
      sprintf(filename, "%s_%s.nc", ctl->tblbase, ctl->emitter[ig]);
      if (nc_open(filename, NC_NOWRITE, &ncid) != NC_NOERR) {
        WARN("Missing emissivity table: %s", filename);
        continue;
      } else
        LOG(1, "Read emissivity table: %s", filename);
 
      /* Read channels... */
      for (int id = 0; id < ctl->nd; id++) {
        read_tbl_nc_channel(ctl, tbl, id, ig, ncid);
        TBL_LOG(tbl, id, ig);
      }
 
      /* Close file... */
      NC(nc_close(ncid));
    }
  }
 
  /* Calculate log-pressure... */
  for (int id = 0; id < ctl->nd; id++)
    for (int ig = 0; ig < ctl->ng; ig++)
      for (int ip = 0; ip < tbl->np[id][ig]; ip++)
        tbl->lnp[id][ig][ip] = log(tbl->p[id][ig][ip]);
 
  /* Read filter functions... */
  if (ctl->tblfmt == 1)
    for (int id = 0; id < ctl->nd; id++) {
      char filename[2 * LEN];
      sprintf(filename, "%s_%.4f.filt", ctl->tblbase, ctl->nu[id]);
      read_shape(filename, tbl->filt_nu[id], tbl->filt_f[id],
                 &tbl->filt_n[id]);
    }
 
  /* Initialize source function lookup tables... */
  init_srcfunc(ctl, tbl);
 
  /* Return pointer... */
  return tbl;
}
 
/*****************************************************************************/
 
void read_tbl_asc(
  const ctl_t *ctl,
  tbl_t *tbl,
  const int id,
  const int ig) {
 
  /* Initialize... */
  double eps, eps_old = -999, press, press_old = -999, temp,
    temp_old = -999, u, u_old = -999;
  int nrange = 0;
 
  /* Set filename... */
  char filename[2 * LEN];
  sprintf(filename, "%s_%.4f_%s.tab", ctl->tblbase,
          ctl->nu[id], ctl->emitter[ig]);
 
  /* Open file... */
  FILE *in;
  if (!(in = fopen(filename, "r"))) {
    WARN("Missing emissivity table: %s", filename);
    return;
  } else
    LOG(1, "Read emissivity table: %s", filename);
 
  /* Init pressure level counter... */
  tbl->np[id][ig] = -1;
 
  /* Read data... */
  char line[LEN];
  while (fgets(line, LEN, in)) {
 
    /* Parse line... */
    if (sscanf(line, "%lg %lg %lg %lg", &press, &temp, &u, &eps) != 4)
      continue;
 
    /* Check ranges... */
    if (u < UMIN || u > UMAX || eps < EPSMIN || eps > EPSMAX) {
      nrange++;
      continue;
    }
 
    /* Determine pressure index... */
    if (press != press_old) {
      press_old = press;
      if ((++tbl->np[id][ig]) >= TBLNP)
        ERRMSG("Too many pressure levels!");
      tbl->nt[id][ig][tbl->np[id][ig]] = -1;
    }
 
    /* Determine temperature index... */
    if (temp != temp_old) {
      temp_old = temp;
      if ((++tbl->nt[id][ig][tbl->np[id][ig]]) >= TBLNT)
        ERRMSG("Too many temperatures!");
      tbl->nu[id][ig][tbl->np[id][ig]]
        [tbl->nt[id][ig][tbl->np[id][ig]]] = -1;
 
      /* Reset dynamic arrays for this (ip,it) node... */
      tbl->logu[id][ig][tbl->np[id][ig]]
        [tbl->nt[id][ig][tbl->np[id][ig]]] = NULL;
      tbl->logeps[id][ig][tbl->np[id][ig]]
        [tbl->nt[id][ig][tbl->np[id][ig]]] = NULL;
    }
 
    /* Determine column density index... */
    if ((eps > eps_old && u > u_old) || tbl->nu[id][ig][tbl->np[id][ig]]
        [tbl->nt[id][ig][tbl->np[id][ig]]] < 0) {
      eps_old = eps;
      u_old = u;
      if ((++tbl->nu[id][ig][tbl->np[id][ig]]
           [tbl->nt[id][ig][tbl->np[id][ig]]]) >= TBLNU)
        ERRMSG("Too many column densities!");
 
      /* Grow dynamic arrays (nu is used as an index during reading). */
      const int ip = tbl->np[id][ig];
      const int it = tbl->nt[id][ig][ip];
      const int iu = tbl->nu[id][ig][ip][it];
      const size_t nnew = (size_t) (iu + 1);
 
      float *tmp = (float *) realloc(tbl->logu[id][ig][ip][it],
                                     nnew * sizeof(float));
      if (!tmp)
        ERRMSG("Out of memory!");
      tbl->logu[id][ig][ip][it] = tmp;
 
      tmp =
        (float *) realloc(tbl->logeps[id][ig][ip][it], nnew * sizeof(float));
      if (!tmp)
        ERRMSG("Out of memory!");
      tbl->logeps[id][ig][ip][it] = tmp;
    }
 
    /* Store data... */
    tbl->p[id][ig][tbl->np[id][ig]] = press;
    tbl->t[id][ig][tbl->np[id][ig]][tbl->nt[id][ig][tbl->np[id][ig]]]
      = temp;
    tbl->logu[id][ig][tbl->np[id][ig]][tbl->nt[id][ig][tbl->np[id][ig]]]
      [tbl->nu[id][ig][tbl->np[id][ig]]
       [tbl->nt[id][ig][tbl->np[id][ig]]]] = (float) log(u);
    tbl->logeps[id][ig][tbl->np[id][ig]][tbl->nt[id][ig][tbl->np[id][ig]]]
      [tbl->nu[id][ig][tbl->np[id][ig]]
       [tbl->nt[id][ig][tbl->np[id][ig]]]] = (float) log(eps);
  }
 
  /* Increment counters... */
  tbl->np[id][ig]++;
  for (int ip = 0; ip < tbl->np[id][ig]; ip++) {
    tbl->nt[id][ig][ip]++;
    for (int it = 0; it < tbl->nt[id][ig][ip]; it++)
      tbl->nu[id][ig][ip][it]++;
  }
 
  /* Check ranges... */
  if (nrange > 0)
    WARN("Column density or emissivity out of range (%d data points)!",
         nrange);
 
  /* Close file... */
  fclose(in);
}
 
/*****************************************************************************/
 
void read_tbl_bin(
  const ctl_t *ctl,
  tbl_t *tbl,
  const int id,
  const int ig) {
 
  /* Set filename... */
  char filename[2 * LEN];
  sprintf(filename, "%s_%.4f_%s.bin",
          ctl->tblbase, ctl->nu[id], ctl->emitter[ig]);
 
  /* Open file... */
  FILE *in = fopen(filename, "rb");
  if (!in) {
    WARN("Missing emissivity table: %s", filename);
    return;
  } else
    LOG(1, "Read emissivity table: %s", filename);
 
  /* Read length.. */
  size_t nbytes;
  FREAD(&nbytes, size_t,
        1,
        in);
  if (nbytes <= 0)
    ERRMSG("Invalid packed table size!");
 
  /* Read packed blob... */
  uint8_t *work = NULL;
  ALLOC(work, uint8_t, nbytes);
  FREAD(work, uint8_t, nbytes, in);
 
  /* Unpack... */
  tbl_unpack(tbl, id, ig, work);
 
  /* Close file... */
  fclose(in);
 
  /* Free... */
  free(work);
}
 
/*****************************************************************************/
 
void read_tbl_nc_channel(
  const ctl_t *ctl,
  tbl_t *tbl,
  int id,
  int ig,
  int ncid) {
 
  char varname[LEN];
 
  int varid, dimid;
 
  size_t nbytes;
 
  /* Inquire variable... */
  sprintf(varname, "tbl_%.4f", ctl->nu[id]);
  if (nc_inq_varid(ncid, varname, &varid) != NC_NOERR) {
    WARN("Missing emissivity table: %s", varname);
    return;
  } else
    LOG(1, "Read emissivity table: %s", varname);
  NC(nc_inq_vardimid(ncid, varid, &dimid));
  NC(nc_inq_dimlen(ncid, dimid, &nbytes));
 
  /* Read variable... */
  uint8_t *work = NULL;
  ALLOC(work, uint8_t, nbytes);
  NC(nc_get_var_uchar(ncid, varid, (unsigned char *) work));
 
  /* Unpack... */
  tbl_unpack(tbl, id, ig, work);
 
  /* Free... */
  free(work);
}
 
/*****************************************************************************/
 
double scan_ctl(
  int argc,
  char *argv[],
  const char *varname,
  const int arridx,
  const char *defvalue,
  char *value) {
 
  char dummy[LEN], fullname1[LEN], fullname2[LEN], line[LEN],
    rvarname[LEN], rval[LEN];
 
  int contain = 0;
 
  /* Open file... */
  FILE *in = NULL;
  if (argv[1][0] != '-')
    if (!(in = fopen(argv[1], "r")))
      ERRMSG("Cannot open file!");
 
  /* Set full variable name... */
  if (arridx >= 0) {
    sprintf(fullname1, "%s[%d]", varname, arridx);
    sprintf(fullname2, "%s[*]", varname);
  } else {
    sprintf(fullname1, "%s", varname);
    sprintf(fullname2, "%s", varname);
  }
 
  /* Read data... */
  if (in != NULL)
    while (fgets(line, LEN, in))
      if (sscanf(line, "%s %s %s", rvarname, dummy, rval) == 3)
        if (strcasecmp(rvarname, fullname1) == 0 ||
            strcasecmp(rvarname, fullname2) == 0) {
          contain = 1;
          break;
        }
  for (int i = 1; i < argc - 1; i++)
    if (strcasecmp(argv[i], fullname1) == 0 ||
        strcasecmp(argv[i], fullname2) == 0) {
      sprintf(rval, "%s", argv[i + 1]);
      contain = 1;
      break;
    }
 
  /* Close file... */
  if (in != NULL)
    fclose(in);
 
  /* Check for missing variables... */
  if (!contain) {
    if (strlen(defvalue) > 0)
      sprintf(rval, "%s", defvalue);
    else
      ERRMSG("Missing variable %s!\n", fullname1);
  }
 
  /* Write info... */
  LOG(1, "%s = %s", fullname1, rval);
 
  /* Return values... */
  if (value != NULL)
    sprintf(value, "%s", rval);
  return atof(rval);
}
 
/*****************************************************************************/
 
void set_cov_apr(
  const ret_t *ret,
  const ctl_t *ctl,
  const atm_t *atm,
  const int *iqa,
  const int *ipa,
  gsl_matrix *s_a) {
 
  /* Get sizes... */
  const size_t n = s_a->size1;
 
  /* Allocate... */
  gsl_vector *x_a = gsl_vector_alloc(n);
 
  /* Get sigma vector... */
  atm2x(ctl, atm, x_a, NULL, NULL);
  for (size_t i = 0; i < n; i++) {
    if (iqa[i] == IDXP)
      gsl_vector_set(x_a, i, ret->err_press / 100 * gsl_vector_get(x_a, i));
    if (iqa[i] == IDXT)
      gsl_vector_set(x_a, i, ret->err_temp);
    for (int ig = 0; ig < ctl->ng; ig++)
      if (iqa[i] == IDXQ(ig))
        gsl_vector_set(x_a, i, ret->err_q[ig] / 100 * gsl_vector_get(x_a, i));
    for (int iw = 0; iw < ctl->nw; iw++)
      if (iqa[i] == IDXK(iw))
        gsl_vector_set(x_a, i, ret->err_k[iw]);
    if (iqa[i] == IDXCLZ)
      gsl_vector_set(x_a, i, ret->err_clz);
    if (iqa[i] == IDXCLDZ)
      gsl_vector_set(x_a, i, ret->err_cldz);
    for (int icl = 0; icl < ctl->ncl; icl++)
      if (iqa[i] == IDXCLK(icl))
        gsl_vector_set(x_a, i, ret->err_clk[icl]);
    if (iqa[i] == IDXSFT)
      gsl_vector_set(x_a, i, ret->err_sft);
    for (int isf = 0; isf < ctl->nsf; isf++)
      if (iqa[i] == IDXSFEPS(isf))
        gsl_vector_set(x_a, i, ret->err_sfeps[isf]);
  }
 
  /* Check standard deviations... */
  for (size_t i = 0; i < n; i++)
    if (POW2(gsl_vector_get(x_a, i)) <= 0)
      ERRMSG("Check a priori data (zero standard deviation)!");
 
  /* Initialize diagonal covariance... */
  gsl_matrix_set_zero(s_a);
  for (size_t i = 0; i < n; i++)
    gsl_matrix_set(s_a, i, i, POW2(gsl_vector_get(x_a, i)));
 
  /* Loop over matrix elements... */
  for (size_t i = 0; i < n; i++)
    for (size_t j = 0; j < n; j++)
      if (i != j && iqa[i] == iqa[j]) {
 
        /* Initialize... */
        double cz = 0;
        double ch = 0;
 
        /* Set correlation lengths for pressure... */
        if (iqa[i] == IDXP) {
          cz = ret->err_press_cz;
          ch = ret->err_press_ch;
        }
 
        /* Set correlation lengths for temperature... */
        if (iqa[i] == IDXT) {
          cz = ret->err_temp_cz;
          ch = ret->err_temp_ch;
        }
 
        /* Set correlation lengths for volume mixing ratios... */
        for (int ig = 0; ig < ctl->ng; ig++)
          if (iqa[i] == IDXQ(ig)) {
            cz = ret->err_q_cz[ig];
            ch = ret->err_q_ch[ig];
          }
 
        /* Set correlation lengths for extinction... */
        for (int iw = 0; iw < ctl->nw; iw++)
          if (iqa[i] == IDXK(iw)) {
            cz = ret->err_k_cz[iw];
            ch = ret->err_k_ch[iw];
          }
 
        /* Compute correlations... */
        if (cz > 0 && ch > 0) {
 
          /* Get Cartesian coordinates... */
          double x0[3], x1[3];
          geo2cart(0, atm->lon[ipa[i]], atm->lat[ipa[i]], x0);
          geo2cart(0, atm->lon[ipa[j]], atm->lat[ipa[j]], x1);
 
          /* Compute correlations... */
          const double rho =
            exp(-DIST(x0, x1) / ch -
                fabs(atm->z[ipa[i]] - atm->z[ipa[j]]) / cz);
 
          /* Set covariance... */
          gsl_matrix_set(s_a, i, j, gsl_vector_get(x_a, i)
                         * gsl_vector_get(x_a, j) * rho);
        }
      }
 
  /* Free... */
  gsl_vector_free(x_a);
}
 
/*****************************************************************************/
 
void set_cov_meas(
  const ret_t *ret,
  const ctl_t *ctl,
  const obs_t *obs,
  gsl_vector *sig_noise,
  gsl_vector *sig_formod,
  gsl_vector *sig_eps_inv) {
 
  /* Allocate... */
  obs_t *obs_err;
  ALLOC(obs_err, obs_t, 1);
 
  /* Get size... */
  const size_t m = sig_eps_inv->size;
 
  /* Noise error (always considered in retrieval fit)... */
  copy_obs(ctl, obs_err, obs, 1);
  for (int ir = 0; ir < obs_err->nr; ir++)
    for (int id = 0; id < ctl->nd; id++)
      obs_err->rad[id][ir]
        = (isfinite(obs->rad[id][ir]) ? ret->err_noise[id] : NAN);
  obs2y(ctl, obs_err, sig_noise, NULL, NULL);
 
  /* Forward model error (always considered in retrieval fit)... */
  copy_obs(ctl, obs_err, obs, 1);
  for (int ir = 0; ir < obs_err->nr; ir++)
    for (int id = 0; id < ctl->nd; id++)
      obs_err->rad[id][ir]
        = fabs(ret->err_formod[id] / 100 * obs->rad[id][ir]);
  obs2y(ctl, obs_err, sig_formod, NULL, NULL);
 
  /* Total error... */
  for (size_t i = 0; i < m; i++)
    gsl_vector_set(sig_eps_inv, i, 1 / sqrt(POW2(gsl_vector_get(sig_noise, i))
                                            +
                                            POW2(gsl_vector_get
                                                 (sig_formod, i))));
 
  /* Check standard deviations... */
  for (size_t i = 0; i < m; i++)
    if (gsl_vector_get(sig_eps_inv, i) <= 0)
      ERRMSG("Check measurement errors (zero standard deviation)!");
 
  /* Free... */
  free(obs_err);
}
 
/*****************************************************************************/
 
const char *shared_io_input_target(
  const ret_t *ret,
  const char *shared_file,
  const char *legacy_file,
  const char **dirname,
  int *profile) {
 
  if (shared_file[0] != '-') {
    *dirname = NULL;
    *profile = ret->shared_io_profile;
    return shared_file;
  }
 
  *dirname = ret->dir;
  *profile = 0;
  return legacy_file;
}
 
/*****************************************************************************/
 
const char *shared_io_output_target(
  const ret_t *ret,
  const char *shared_file,
  const char *legacy_file,
  const char **dirname,
  int *profile) {
 
  if (shared_file[0] != '-') {
    *dirname = NULL;
    *profile = ret->shared_io_profile;
    return shared_file;
  }
 
  *dirname = ret->dir;
  *profile = 0;
  return legacy_file;
}
 
/*****************************************************************************/
 
int shared_io_lock(
  const ret_t *ret) {
 
  const char *base = shared_io_output_file(ret);
  if (base == NULL)
    return -1;
 
  char lockfile[LEN];
  if (snprintf(lockfile, LEN, "%s.lock", base) >= LEN)
    ERRMSG("Lock file name too long!");
  int fd = open(lockfile, O_CREAT | O_RDWR, 0666);
  if (fd < 0)
    ERRMSG("Cannot open lock file!");
 
  struct flock fl;
  fl.l_type = F_WRLCK;
  fl.l_whence = SEEK_SET;
  fl.l_start = 0;
  fl.l_len = 0;
  if (fcntl(fd, F_SETLKW, &fl) < 0)
    ERRMSG("Cannot lock shared output file!");
 
  return fd;
}
 
/*****************************************************************************/
 
void shared_io_unlock(
  int fd) {
 
  if (fd < 0)
    return;
 
  struct flock fl;
  fl.l_type = F_UNLCK;
  fl.l_whence = SEEK_SET;
  fl.l_start = 0;
  fl.l_len = 0;
  if (fcntl(fd, F_SETLK, &fl) < 0)
    ERRMSG("Cannot unlock shared output file!");
  close(fd);
}
 
/*****************************************************************************/
 
const char *shared_io_output_file(
  const ret_t *ret) {
 
  if (ret->shared_io_atm_final_file[0] != '-')
    return ret->shared_io_atm_final_file;
  if (ret->shared_io_obs_final_file[0] != '-')
    return ret->shared_io_obs_final_file;
  if (ret->shared_io_matrix_cov_apr_file[0] != '-')
    return ret->shared_io_matrix_cov_apr_file;
  if (ret->shared_io_matrix_kernel_file[0] != '-')
    return ret->shared_io_matrix_kernel_file;
  if (ret->shared_io_matrix_cov_ret_file[0] != '-')
    return ret->shared_io_matrix_cov_ret_file;
  if (ret->shared_io_matrix_corr_file[0] != '-')
    return ret->shared_io_matrix_corr_file;
  if (ret->shared_io_matrix_gain_file[0] != '-')
    return ret->shared_io_matrix_gain_file;
  if (ret->shared_io_matrix_avk_file[0] != '-')
    return ret->shared_io_matrix_avk_file;
  if (ret->shared_io_atm_err_total_file[0] != '-')
    return ret->shared_io_atm_err_total_file;
  if (ret->shared_io_atm_err_noise_file[0] != '-')
    return ret->shared_io_atm_err_noise_file;
  if (ret->shared_io_atm_err_formod_file[0] != '-')
    return ret->shared_io_atm_err_formod_file;
  if (ret->shared_io_atm_cont_file[0] != '-')
    return ret->shared_io_atm_cont_file;
  if (ret->shared_io_atm_res_file[0] != '-')
    return ret->shared_io_atm_res_file;
  return NULL;
}
 
/*****************************************************************************/
 
void tangent_point(
  const los_t *los,
  double *tpz,
  double *tplon,
  double *tplat) {
 
  /* Find minimum altitude... */
  const size_t ip = gsl_stats_min_index(los->z, 1, (size_t) los->np);
 
  /* Nadir or zenith... */
  if (ip <= 0 || ip >= (size_t) los->np - 1) {
    *tpz = los->z[los->np - 1];
    *tplon = los->lon[los->np - 1];
    *tplat = los->lat[los->np - 1];
  }
 
  /* Limb... */
  else {
 
    /* Determine interpolating polynomial y=a*x^2+b*x+c... */
    const double yy0 = los->z[ip - 1];
    const double yy1 = los->z[ip];
    const double yy2 = los->z[ip + 1];
    const double x1 = sqrt(POW2(los->ds[ip]) - POW2(yy1 - yy0));
    const double x2 = x1 + sqrt(POW2(los->ds[ip + 1]) - POW2(yy2 - yy1));
    const double a = 1 / (x1 - x2) * (-(yy0 - yy1) / x1 + (yy0 - yy2) / x2);
    const double b = -(yy0 - yy1) / x1 - a * x1;
    const double c = yy0;
 
    /* Get tangent point location... */
    double dummy, v[3], v0[3], v2[3];
    const double x = -b / (2 * a);
    *tpz = a * x * x + b * x + c;
    geo2cart(los->z[ip - 1], los->lon[ip - 1], los->lat[ip - 1], v0);
    geo2cart(los->z[ip + 1], los->lon[ip + 1], los->lat[ip + 1], v2);
    for (int i = 0; i < 3; i++)
      v[i] = LIN(0.0, v0[i], x2, v2[i], x);
    cart2geo(v, &dummy, tplon, tplat);
  }
}
 
/*****************************************************************************/
 
void tbl_free(
  const ctl_t *ctl,
  tbl_t *tbl) {
 
  /* Check pointer... */
  if (!tbl)
    return;
 
  /* Loop over channels and emitters... */
  for (int id = 0; id < ctl->nd; id++)
    for (int ig = 0; ig < ctl->ng; ig++) {
 
      /* Check number of pressure levels... */
      const int np = tbl->np[id][ig];
      if (np < 0)
        continue;
 
      /* Loop over pressure levels... */
      for (int ip = 0; ip < np; ip++) {
 
        /* Loop over temperature levels... */
        const int nt = tbl->nt[id][ig][ip];
        for (int it = 0; it < nt; it++) {
 
          /* Free... */
          free(tbl->logu[id][ig][ip][it]);
          free(tbl->logeps[id][ig][ip][it]);
          tbl->logu[id][ig][ip][it] = NULL;
          tbl->logeps[id][ig][ip][it] = NULL;
        }
      }
    }
 
  /* Free... */
  free(tbl);
}
 
/*****************************************************************************/
 
void tbl_pack(
  const tbl_t *tbl,
  int id,
  int ig,
  uint8_t *buf,
  size_t *bytes_used) {
 
  uint8_t *cur = buf;
 
  /* Pack lookup table... */
  int np = tbl->np[id][ig];
  memcpy(cur, &np, sizeof(np));
  cur += sizeof(np);
 
  memcpy(cur, tbl->p[id][ig], (size_t) np * sizeof(double));
  cur += ((size_t) np * sizeof(double));
 
  for (int ip = 0; ip < np; ip++) {
    int nt = tbl->nt[id][ig][ip];
    memcpy(cur, &nt, sizeof(nt));
    cur += sizeof(nt);
 
    memcpy(cur, tbl->t[id][ig][ip], (size_t) nt * sizeof(double));
    cur += ((size_t) nt * sizeof(double));
 
    for (int it = 0; it < nt; it++) {
      int nu = tbl->nu[id][ig][ip][it];
      memcpy(cur, &nu, sizeof(nu));
      cur += sizeof(nu);
 
      memcpy(cur, tbl->logu[id][ig][ip][it], (size_t) nu * sizeof(float));
      cur += ((size_t) nu * sizeof(float));
 
      memcpy(cur, tbl->logeps[id][ig][ip][it], (size_t) nu * sizeof(float));
      cur += ((size_t) nu * sizeof(float));
    }
  }
 
  /* Pack filter function... */
  const int n = tbl->filt_n[id];
  memcpy(cur, &n, sizeof(n));
  cur += sizeof(n);
 
  memcpy(cur, tbl->filt_nu[id], (size_t) n * sizeof(double));
  cur += ((size_t) n * sizeof(double));
 
  memcpy(cur, tbl->filt_f[id], (size_t) n * sizeof(double));
  cur += ((size_t) n * sizeof(double));
 
  *bytes_used = (size_t) (cur - buf);
}
 
/*****************************************************************************/
 
size_t tbl_packed_size(
  const tbl_t *tbl,
  int id,
  int ig) {
 
  size_t bytes = 0;
 
  /* Size of lookup table... */
  const int np = tbl->np[id][ig];
  bytes += sizeof(int);
  bytes += ((size_t) np * sizeof(double));
 
  for (int ip = 0; ip < np; ip++) {
    const int nt = tbl->nt[id][ig][ip];
    bytes += sizeof(int);
    bytes += ((size_t) nt * sizeof(double));
 
    for (int it = 0; it < nt; it++) {
      const int nu = tbl->nu[id][ig][ip][it];
      bytes += sizeof(int);
      bytes += (2 * (size_t) nu * sizeof(float));
    }
  }
 
  /* Size of filter function... */
  const int n = tbl->filt_n[id];
  bytes += sizeof(int);
  bytes += (2 * (size_t) n * sizeof(double));
 
  return bytes;
}
 
/*****************************************************************************/
 
size_t tbl_unpack(
  tbl_t *tbl,
  int id,
  int ig,
  const uint8_t *buf) {
 
  const uint8_t *cur = buf;
 
  /* Unpack lookup table... */
  int np;
  memcpy(&np, cur, sizeof(np));
  cur += sizeof(np);
 
  if (np < 0 || np > TBLNP)
    ERRMSG("np out of range!");
  tbl->np[id][ig] = np;
 
  memcpy(tbl->p[id][ig], cur, (size_t) np * sizeof(double));
  cur += ((size_t) np * sizeof(double));
 
  for (int ip = 0; ip < np; ip++) {
 
    int nt;
    memcpy(&nt, cur, sizeof(nt));
    cur += sizeof(nt);
 
    if (nt < 0 || nt > TBLNT)
      ERRMSG("nt out of range!");
    tbl->nt[id][ig][ip] = nt;
 
    memcpy(tbl->t[id][ig][ip], cur, (size_t) nt * sizeof(double));
    cur += ((size_t) nt * sizeof(double));
 
    for (int it = 0; it < nt; it++) {
 
      int nu;
      memcpy(&nu, cur, sizeof(nu));
      cur += sizeof(nu);
 
      if (nu < 0 || nu > TBLNU)
        ERRMSG("nu out of range!");
      tbl->nu[id][ig][ip][it] = nu;
 
      ALLOC(tbl->logu[id][ig][ip][it], float,
            nu);
      ALLOC(tbl->logeps[id][ig][ip][it], float,
            nu);
 
      memcpy(tbl->logu[id][ig][ip][it], cur, (size_t) nu * sizeof(float));
      cur += ((size_t) nu * sizeof(float));
 
      memcpy(tbl->logeps[id][ig][ip][it], cur, (size_t) nu * sizeof(float));
      cur += ((size_t) nu * sizeof(float));
    }
  }
 
  /* Unpack filter function... */
  int n;
  memcpy(&n, cur, sizeof(n));
  cur += sizeof(n);
 
  if (n < 2 || n > NSHAPE)
    ERRMSG("Missing or invalid filter function (filt_n) in packed table!");
  tbl->filt_n[id] = n;
 
  memcpy(tbl->filt_nu[id], cur, (size_t) n * sizeof(double));
  cur += ((size_t) n * sizeof(double));
 
  memcpy(tbl->filt_f[id], cur, (size_t) n * sizeof(double));
  cur += ((size_t) n * sizeof(double));
 
  return (size_t) (cur - buf);
}
 
/*****************************************************************************/
 
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) {
 
  struct tm t0, t1;
 
  t0.tm_year = 100;
  t0.tm_mon = 0;
  t0.tm_mday = 1;
  t0.tm_hour = 0;
  t0.tm_min = 0;
  t0.tm_sec = 0;
 
  t1.tm_year = year - 1900;
  t1.tm_mon = mon - 1;
  t1.tm_mday = day;
  t1.tm_hour = hour;
  t1.tm_min = min;
  t1.tm_sec = sec;
 
  *jsec = (double) timegm(&t1) - (double) timegm(&t0) + remain;
}
 
/*****************************************************************************/
 
void timer_group(
  const char *name,
  const char *group,
  int output) {
 
  static char names[NTIMER][100], groups[NTIMER][100];
  static double rt_name[NTIMER], rt_group[NTIMER], rt_min[NTIMER],
    rt_max[NTIMER], rt_sq[NTIMER], t0, t1;
  static int ct_name[NTIMER], iname = -1, igroup = -1, nname, ngroup;
 
  /* Get time... */
  t1 = omp_get_wtime();
  const double dt = t1 - t0;
 
  /* Accumulate runtime for current timer... */
  if (iname >= 0) {
    rt_name[iname] += dt;
    rt_sq[iname] += POW2(dt);
    rt_min[iname] = (ct_name[iname] <= 0 ? dt : MIN(rt_min[iname], dt));
    rt_max[iname] = (ct_name[iname] <= 0 ? dt : MAX(rt_max[iname], dt));
    ct_name[iname]++;
  }
  if (igroup >= 0)
    rt_group[igroup] += dt;
 
  /* Write summary... */
  if (output) {
    for (int i = 0; i < nname; i++) {
      const double mean = rt_name[i] / ct_name[i];
      const double variance = MAX(0.0, rt_sq[i] / ct_name[i] - POW2(mean));
      LOG(1,
          "TIMER_%s = %.3f s    (min= %g s, mean= %g s, stddev= %g s, max= %g s, n= %d)",
          names[i], rt_name[i], rt_min[i], mean, sqrt(variance), rt_max[i],
          ct_name[i]);
    }
    for (int i = 0; i < ngroup; i++)
      LOG(1, "TIMER_GROUP_%s = %.3f s", groups[i], rt_group[i]);
    double total = 0.0;
    for (int i = 0; i < nname; i++)
      total += rt_name[i];
    LOG(1, "TIMER_TOTAL = %.3f s", total);
  }
 
  /* Identify next timer name... */
  for (iname = 0; iname < nname; iname++)
    if (strcasecmp(name, names[iname]) == 0)
      break;
  for (igroup = 0; igroup < ngroup; igroup++)
    if (strcasecmp(group, groups[igroup]) == 0)
      break;
 
  /* Add new timer name if needed... */
  if (iname >= nname) {
    sprintf(names[iname], "%s", name);
    if ((++nname) >= NTIMER)
      ERRMSG("Too many timers!");
  }
 
  /* Add new timer group if needed... */
  if (igroup >= ngroup) {
    sprintf(groups[igroup], "%s", group);
    if ((++ngroup) >= NTIMER)
      ERRMSG("Too many groups!");
  }
 
  /* Save time stamp for next phase... */
  t0 = t1;
}
 
/*****************************************************************************/
 
void write_atm(
  const char *dirname,
  const char *filename,
  const ctl_t *ctl,
  const atm_t *atm,
  int profile) {
 
  /* Set filename... */
  char file[LEN];
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Write atmospheric data: %s", file);
 
  /* Write ASCII data... */
  if (ctl->atmfmt == 1)
    write_atm_asc(file, ctl, atm);
 
  /* Write binary data... */
  else if (ctl->atmfmt == 2)
    write_atm_bin(file, ctl, atm);
 
  /* Write netCDF data... */
  else if (ctl->atmfmt == 3)
    write_atm_nc(file, ctl, atm, profile);
 
  /* Error... */
  else
    ERRMSG("Unknown file format, check ATMFMT!");
 
  /* Write info... */
  double mini, maxi;
  LOG(2, "Number of data points: %d", atm->np);
  gsl_stats_minmax(&mini, &maxi, atm->time, 1, (size_t) atm->np);
  LOG(2, "Time range: %.2f ... %.2f s", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, atm->z, 1, (size_t) atm->np);
  LOG(2, "Altitude range: %g ... %g km", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, atm->lon, 1, (size_t) atm->np);
  LOG(2, "Longitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, atm->lat, 1, (size_t) atm->np);
  LOG(2, "Latitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, atm->p, 1, (size_t) atm->np);
  LOG(2, "Pressure range: %g ... %g hPa", maxi, mini);
  gsl_stats_minmax(&mini, &maxi, atm->t, 1, (size_t) atm->np);
  LOG(2, "Temperature range: %g ... %g K", mini, maxi);
  for (int ig = 0; ig < ctl->ng; ig++) {
    gsl_stats_minmax(&mini, &maxi, atm->q[ig], 1, (size_t) atm->np);
    LOG(2, "Emitter %s range: %g ... %g ppv", ctl->emitter[ig], mini, maxi);
  }
  for (int iw = 0; iw < ctl->nw; iw++) {
    gsl_stats_minmax(&mini, &maxi, atm->k[iw], 1, (size_t) atm->np);
    LOG(2, "Extinction range (window %d): %g ... %g km^-1", iw, mini, maxi);
  }
  if (ctl->ncl > 0) {
    LOG(2, "Cloud layer: z= %g km | dz= %g km | k= %g ... %g km^-1",
        atm->clz, atm->cldz, atm->clk[0], atm->clk[ctl->ncl - 1]);
  } else
    LOG(2, "Cloud layer: none");
  if (ctl->nsf > 0) {
    LOG(2,
        "Surface: T_s = %g K | eps= %g ... %g",
        atm->sft, atm->sfeps[0], atm->sfeps[ctl->nsf - 1]);
  } else
    LOG(2, "Surface: none");
}
 
/*****************************************************************************/
 
void write_atm_asc(
  const char *filename,
  const ctl_t *ctl,
  const atm_t *atm) {
 
  int n = 6;
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(filename, "w")))
    ERRMSG("Cannot create file!");
 
  /* Write header... */
  fprintf(out,
          "# $1 = time (seconds since 2000-01-01T00:00Z)\n"
          "# $2 = altitude [km]\n"
          "# $3 = longitude [deg]\n"
          "# $4 = latitude [deg]\n"
          "# $5 = pressure [hPa]\n" "# $6 = temperature [K]\n");
  for (int ig = 0; ig < ctl->ng; ig++)
    fprintf(out, "# $%d = %s volume mixing ratio [ppv]\n",
            ++n, ctl->emitter[ig]);
  for (int iw = 0; iw < ctl->nw; iw++)
    fprintf(out, "# $%d = extinction (window %d) [km^-1]\n", ++n, iw);
  if (ctl->ncl > 0) {
    fprintf(out, "# $%d = cloud layer height [km]\n", ++n);
    fprintf(out, "# $%d = cloud layer depth [km]\n", ++n);
    for (int icl = 0; icl < ctl->ncl; icl++)
      fprintf(out, "# $%d = cloud layer extinction (%.4f cm^-1) [km^-1]\n",
              ++n, ctl->clnu[icl]);
  }
  if (ctl->nsf > 0) {
    fprintf(out, "# $%d = surface temperature [K]\n", ++n);
    for (int isf = 0; isf < ctl->nsf; isf++)
      fprintf(out, "# $%d = surface emissivity (%.4f cm^-1)\n",
              ++n, ctl->sfnu[isf]);
  }
 
  /* Write data... */
  for (int ip = 0; ip < atm->np; ip++) {
    if (ip == 0 || atm->time[ip] != atm->time[ip - 1])
      fprintf(out, "\n");
    fprintf(out, "%.2f %g %g %g %g %g", atm->time[ip], atm->z[ip],
            atm->lon[ip], atm->lat[ip], atm->p[ip], atm->t[ip]);
    for (int ig = 0; ig < ctl->ng; ig++)
      fprintf(out, " %g", atm->q[ig][ip]);
    for (int iw = 0; iw < ctl->nw; iw++)
      fprintf(out, " %g", atm->k[iw][ip]);
    if (ctl->ncl > 0) {
      fprintf(out, " %g %g", atm->clz, atm->cldz);
      for (int icl = 0; icl < ctl->ncl; icl++)
        fprintf(out, " %g", atm->clk[icl]);
    }
    if (ctl->nsf > 0) {
      fprintf(out, " %g", atm->sft);
      for (int isf = 0; isf < ctl->nsf; isf++)
        fprintf(out, " %g", atm->sfeps[isf]);
    }
    fprintf(out, "\n");
  }
 
  /* Close file... */
  fclose(out);
}
 
/*****************************************************************************/
 
void write_atm_bin(
  const char *filename,
  const ctl_t *ctl,
  const atm_t *atm) {
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(filename, "w")))
    ERRMSG("Cannot create file!");
 
  /* Write header... */
  FWRITE("ATM1", char,
         4,
         out);
  FWRITE(&ctl->ng, int,
         1,
         out);
  FWRITE(&ctl->nw, int,
         1,
         out);
  FWRITE(&ctl->ncl, int,
         1,
         out);
  FWRITE(&ctl->nsf, int,
         1,
         out);
 
  /* Write data... */
  size_t np = (size_t) atm->np;
  FWRITE(&np, size_t,
         1,
         out);
  FWRITE(atm->time, double,
         np,
         out);
  FWRITE(atm->z, double,
         np,
         out);
  FWRITE(atm->lon, double,
         np,
         out);
  FWRITE(atm->lat, double,
         np,
         out);
  FWRITE(atm->p, double,
         np,
         out);
  FWRITE(atm->t, double,
         np,
         out);
  for (int ig = 0; ig < ctl->ng; ig++)
    FWRITE(atm->q[ig], double,
           np,
           out);
  for (int iw = 0; iw < ctl->nw; iw++)
    FWRITE(atm->k[iw], double,
           np,
           out);
  if (ctl->ncl > 0) {
    FWRITE(&atm->clz, double,
           1,
           out);
    FWRITE(&atm->cldz, double,
           1,
           out);
    FWRITE(atm->clk, double,
             (size_t) ctl->ncl,
           out);
  }
  if (ctl->nsf > 0) {
    FWRITE(&atm->sft, double,
           1,
           out);
    FWRITE(atm->sfeps, double,
             (size_t) ctl->nsf,
           out);
  }
 
  /* Close file... */
  fclose(out);
}
 
/*****************************************************************************/
 
void write_atm_nc(
  const char *filename,
  const ctl_t *ctl,
  const atm_t *atm,
  int profile) {
 
  char longname[LEN], varname[LEN];
 
  int ncid, varid, dim_profile, dim_level;
 
  size_t level_max;
 
  /* Check number of levels... */
  if (atm->np < 1 || atm->np > NP)
    ERRMSG("Number of levels out of range!");
 
  /* Open or create file... */
  if (nc_open(filename, NC_WRITE, &ncid) != NC_NOERR)
    NC(nc_create(filename, NC_NETCDF4, &ncid));
 
  /* Enter define mode... */
  int r = nc_redef(ncid);
  if (r != NC_NOERR && r != NC_EINDEFINE)
    NC(r);
 
  /* Define profile dimension (unlimited)... */
  if (nc_inq_dimid(ncid, "profile", &dim_profile) != NC_NOERR)
    NC(nc_def_dim(ncid, "profile", NC_UNLIMITED, &dim_profile));
 
  /* Define level dimension (fixed)... */
  if (nc_inq_dimid(ncid, "level", &dim_level) == NC_NOERR) {
    NC(nc_inq_dimlen(ncid, dim_level, &level_max));
    if (level_max < 1 || level_max > (size_t) NP)
      ERRMSG("netCDF dimension level is out of range!");
    if ((size_t) atm->np > level_max)
      ERRMSG("profile has too many levels!");
  } else {
    level_max = (size_t) atm->np;
    NC(nc_def_dim(ncid, "level", level_max, &dim_level));
  }
 
  /* Set dimension IDs... */
  int dimids[2] = { dim_profile, dim_level };
 
  /* Tunables for compression/quantization... */
  const int deflate_level = 0;
  const int quant_digits = 0;
 
  /* Define nlev (1D)... */
  if (nc_inq_varid(ncid, "nlev", &varid) != NC_NOERR)
    NC_DEF_VAR("nlev", NC_INT, 1, dimids,
               "number of vertical levels", "1", 0, 0);
 
  /* Define core variables (2D)... */
  if (nc_inq_varid(ncid, "time", &varid) != NC_NOERR)
    NC_DEF_VAR("time", NC_DOUBLE, 2, dimids,
               "time in seconds since 2000-01-01, 00:00 UTC", "s",
               deflate_level, 0);
 
  if (nc_inq_varid(ncid, "z", &varid) != NC_NOERR)
    NC_DEF_VAR("z", NC_DOUBLE, 2, dimids, "altitude", "km", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "lon", &varid) != NC_NOERR)
    NC_DEF_VAR("lon", NC_DOUBLE, 2, dimids,
               "longitude", "degrees_east", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "lat", &varid) != NC_NOERR)
    NC_DEF_VAR("lat", NC_DOUBLE, 2, dimids,
               "latitude", "degrees_north", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "p", &varid) != NC_NOERR)
    NC_DEF_VAR("p", NC_DOUBLE, 2, dimids,
               "pressure", "hPa", deflate_level, quant_digits);
 
  if (nc_inq_varid(ncid, "t", &varid) != NC_NOERR)
    NC_DEF_VAR("t", NC_DOUBLE, 2, dimids,
               "temperature", "K", deflate_level, quant_digits);
 
  /* Write emitters (2D)... */
  for (int ig = 0; ig < ctl->ng; ig++)
    if (nc_inq_varid(ncid, ctl->emitter[ig], &varid) != NC_NOERR) {
      sprintf(longname, "%s volume mixing ratio", ctl->emitter[ig]);
      NC_DEF_VAR(ctl->emitter[ig], NC_DOUBLE, 2, dimids,
                 longname, "ppv", deflate_level, quant_digits);
    }
 
  /* Write extinction (2D)... */
  for (int iw = 0; iw < ctl->nw; iw++) {
    sprintf(varname, "ext_win_%d", iw);
    if (nc_inq_varid(ncid, varname, &varid) != NC_NOERR) {
      sprintf(longname, "extinction (window %d)", iw);
      NC_DEF_VAR(varname, NC_DOUBLE, 2, dimids,
                 longname, "km**-1", deflate_level, quant_digits);
    }
  }
 
  /* Write cloud variables (1D)... */
  if (ctl->ncl > 0) {
    if (nc_inq_varid(ncid, "cld_z", &varid) != NC_NOERR)
      NC_DEF_VAR("cld_z", NC_DOUBLE, 1, dimids,
                 "cloud layer height", "km", deflate_level, quant_digits);
 
    if (nc_inq_varid(ncid, "cld_dz", &varid) != NC_NOERR)
      NC_DEF_VAR("cld_dz", NC_DOUBLE, 1, dimids,
                 "cloud layer depth", "km", deflate_level, quant_digits);
 
    for (int icl = 0; icl < ctl->ncl; icl++) {
      sprintf(varname, "cld_k_%.4f", ctl->clnu[icl]);
      if (nc_inq_varid(ncid, varname, &varid) != NC_NOERR) {
        sprintf(longname, "cloud layer extinction (%.4f cm^-1)",
                ctl->clnu[icl]);
        NC_DEF_VAR(varname, NC_DOUBLE, 1, dimids, longname, "km**-1",
                   deflate_level, quant_digits);
      }
    }
  }
 
  /* Write surface variables (1D)... */
  if (ctl->nsf > 0) {
    if (nc_inq_varid(ncid, "srf_t", &varid) != NC_NOERR)
      NC_DEF_VAR("srf_t", NC_DOUBLE, 1, dimids,
                 "surface temperature", "K", deflate_level, quant_digits);
 
    for (int isf = 0; isf < ctl->nsf; isf++) {
      sprintf(varname, "srf_eps_%.4f", ctl->sfnu[isf]);
      if (nc_inq_varid(ncid, varname, &varid) != NC_NOERR) {
        sprintf(longname, "surface emissivity (%.4f cm^-1)", ctl->sfnu[isf]);
        NC_DEF_VAR(varname, NC_DOUBLE, 1, dimids, longname, "1",
                   deflate_level, quant_digits);
      }
    }
  }
 
  /* Leave define mode... */
  NC(nc_enddef(ncid));
 
  /* Define hyperslabs... */
  size_t start[2] = { (size_t) profile, 0 };
  size_t count[2] = { 1, (size_t) atm->np };
 
  /* Write nlev... */
  NC_PUT_INT("nlev", &atm->np, 1);
 
  /* Write core variables... */
  NC_PUT_DOUBLE("time", atm->time, 1);
  NC_PUT_DOUBLE("z", atm->z, 1);
  NC_PUT_DOUBLE("lon", atm->lon, 1);
  NC_PUT_DOUBLE("lat", atm->lat, 1);
  NC_PUT_DOUBLE("p", atm->p, 1);
  NC_PUT_DOUBLE("t", atm->t, 1);
 
  /* Write emitters... */
  for (int ig = 0; ig < ctl->ng; ig++)
    NC_PUT_DOUBLE(ctl->emitter[ig], atm->q[ig], 1);
 
  /* Write extinction... */
  for (int iw = 0; iw < ctl->nw; iw++) {
    sprintf(varname, "ext_win_%d", iw);
    NC_PUT_DOUBLE(varname, atm->k[iw], 1);
  }
 
  /* Write cloud variables... */
  if (ctl->ncl > 0) {
    NC_PUT_DOUBLE("cld_z", &atm->clz, 1);
    NC_PUT_DOUBLE("cld_dz", &atm->cldz, 1);
    for (int icl = 0; icl < ctl->ncl; icl++) {
      sprintf(varname, "cld_k_%.4f", ctl->clnu[icl]);
      NC_PUT_DOUBLE(varname, &atm->clk[icl], 1);
    }
  }
 
  /* Write surface variables... */
  if (ctl->nsf > 0) {
    NC_PUT_DOUBLE("srf_t", &atm->sft, 1);
    for (int isf = 0; isf < ctl->nsf; isf++) {
      sprintf(varname, "srf_eps_%.4f", ctl->sfnu[isf]);
      NC_PUT_DOUBLE(varname, &atm->sfeps[isf], 1);
    }
  }
 
  /* Close file... */
  NC(nc_sync(ncid));
  NC(nc_close(ncid));
}
 
/*****************************************************************************/
 
void write_atm_rfm(
  const char *filename,
  const ctl_t *ctl,
  const atm_t *atm) {
 
  /* Write info... */
  LOG(1, "Write RFM data: %s", filename);
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(filename, "w")))
    ERRMSG("Cannot create file!");
 
  /* Write data... */
  fprintf(out, "%d\n", atm->np);
  fprintf(out, "*HGT [km]\n");
  for (int ip = 0; ip < atm->np; ip++)
    fprintf(out, "%g\n", atm->z[ip]);
  fprintf(out, "*PRE [mb]\n");
  for (int ip = 0; ip < atm->np; ip++)
    fprintf(out, "%g\n", atm->p[ip]);
  fprintf(out, "*TEM [K]\n");
  for (int ip = 0; ip < atm->np; ip++)
    fprintf(out, "%g\n", atm->t[ip]);
  for (int ig = 0; ig < ctl->ng; ig++) {
    fprintf(out, "*%s [ppmv]\n", ctl->emitter[ig]);
    for (int ip = 0; ip < atm->np; ip++)
      fprintf(out, "%g\n", atm->q[ig][ip] * 1e6);
  }
  fprintf(out, "*END\n");
 
  /* Close file... */
  fclose(out);
}
 
/*****************************************************************************/
 
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,
  int dataset) {
 
  /* Check output flag... */
  if (!ctl->write_matrix)
    return;
 
  /* Write ASCII data... */
  if (ctl->matrixfmt == 1)
    write_matrix_asc(dirname, filename, ctl, matrix, atm, obs,
                     rowspace, colspace, sort);
 
  /* Write binary data... */
  else if (ctl->matrixfmt == 2)
    write_matrix_bin(dirname, filename, matrix);
 
  /* Write netCDF data... */
  else if (ctl->matrixfmt == 3)
    write_matrix_nc(dirname, filename, ctl, matrix, atm, obs,
                    rowspace, colspace, sort, dataset);
 
  /* Error... */
  else
    ERRMSG("Unknown matrix file format, check MATRIXFMT!");
}
 
/*****************************************************************************/
 
void write_matrix_asc(
  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) {
 
  char file[LEN], quantity[LEN];
 
  int *cida, *ciqa, *cipa, *cira, *rida, *riqa, *ripa, *rira;
 
  size_t i, j, nc, nr;
 
  /* Allocate... */
  ALLOC(cida, int,
        M);
  ALLOC(ciqa, int,
        N);
  ALLOC(cipa, int,
        N);
  ALLOC(cira, int,
        M);
  ALLOC(rida, int,
        M);
  ALLOC(riqa, int,
        N);
  ALLOC(ripa, int,
        N);
  ALLOC(rira, int,
        M);
 
  /* Set filename... */
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Write matrix: %s", file);
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(file, "w")))
    ERRMSG("Cannot create file!");
 
  /* Write header (row space)... */
  if (rowspace[0] == 'y') {
 
    fprintf(out,
            "# $1 = Row: index (measurement space)\n"
            "# $2 = Row: channel wavenumber [cm^-1]\n"
            "# $3 = Row: time (seconds since 2000-01-01T00:00Z)\n"
            "# $4 = Row: view point altitude [km]\n"
            "# $5 = Row: view point longitude [deg]\n"
            "# $6 = Row: view point latitude [deg]\n");
 
    /* Get number of rows... */
    nr = obs2y(ctl, obs, NULL, rida, rira);
 
  } else {
 
    fprintf(out,
            "# $1 = Row: index (state space)\n"
            "# $2 = Row: name of quantity\n"
            "# $3 = Row: time (seconds since 2000-01-01T00:00Z)\n"
            "# $4 = Row: altitude [km]\n"
            "# $5 = Row: longitude [deg]\n" "# $6 = Row: latitude [deg]\n");
 
    /* Get number of rows... */
    nr = atm2x(ctl, atm, NULL, riqa, ripa);
  }
 
  /* Write header (column space)... */
  if (colspace[0] == 'y') {
 
    fprintf(out,
            "# $7 = Col: index (measurement space)\n"
            "# $8 = Col: channel wavenumber [cm^-1]\n"
            "# $9 = Col: time (seconds since 2000-01-01T00:00Z)\n"
            "# $10 = Col: view point altitude [km]\n"
            "# $11 = Col: view point longitude [deg]\n"
            "# $12 = Col: view point latitude [deg]\n");
 
    /* Get number of columns... */
    nc = obs2y(ctl, obs, NULL, cida, cira);
 
  } else {
 
    fprintf(out,
            "# $7 = Col: index (state space)\n"
            "# $8 = Col: name of quantity\n"
            "# $9 = Col: time (seconds since 2000-01-01T00:00Z)\n"
            "# $10 = Col: altitude [km]\n"
            "# $11 = Col: longitude [deg]\n" "# $12 = Col: latitude [deg]\n");
 
    /* Get number of columns... */
    nc = atm2x(ctl, atm, NULL, ciqa, cipa);
  }
 
  /* Write header entry... */
  fprintf(out, "# $13 = Matrix element\n\n");
 
  /* Write matrix data... */
  i = j = 0;
  while (i < nr && j < nc) {
 
    /* Write info about the row... */
    if (rowspace[0] == 'y')
      fprintf(out, "%d %.4f %.2f %g %g %g",
              (int) i, ctl->nu[rida[i]],
              obs->time[rira[i]], obs->vpz[rira[i]],
              obs->vplon[rira[i]], obs->vplat[rira[i]]);
    else {
      idx2name(ctl, riqa[i], quantity);
      fprintf(out, "%d %s %.2f %g %g %g", (int) i, quantity,
              atm->time[ripa[i]], atm->z[ripa[i]],
              atm->lon[ripa[i]], atm->lat[ripa[i]]);
    }
 
    /* Write info about the column... */
    if (colspace[0] == 'y')
      fprintf(out, " %d %.4f %.2f %g %g %g",
              (int) j, ctl->nu[cida[j]],
              obs->time[cira[j]], obs->vpz[cira[j]],
              obs->vplon[cira[j]], obs->vplat[cira[j]]);
    else {
      idx2name(ctl, ciqa[j], quantity);
      fprintf(out, " %d %s %.2f %g %g %g", (int) j, quantity,
              atm->time[cipa[j]], atm->z[cipa[j]],
              atm->lon[cipa[j]], atm->lat[cipa[j]]);
    }
 
    /* Write matrix entry... */
    fprintf(out, " %g\n", gsl_matrix_get(matrix, i, j));
 
    /* Set matrix indices... */
    if (sort[0] == 'r') {
      j++;
      if (j >= nc) {
        j = 0;
        i++;
        fprintf(out, "\n");
      }
    } else {
      i++;
      if (i >= nr) {
        i = 0;
        j++;
        fprintf(out, "\n");
      }
    }
  }
 
  /* Close file... */
  fclose(out);
 
  /* Free... */
  free(cida);
  free(ciqa);
  free(cipa);
  free(cira);
  free(rida);
  free(riqa);
  free(ripa);
  free(rira);
}
 
/*****************************************************************************/
 
void write_matrix_bin(
  const char *dirname,
  const char *filename,
  const gsl_matrix *matrix) {
 
  char file[LEN];
  const size_t nr = matrix->size1;
  const size_t nc = matrix->size2;
 
  /* Set filename... */
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Write matrix: %s", file);
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(file, "w")))
    ERRMSG("Cannot create file!");
 
  /* Write header... */
  FWRITE("MAT1", char,
         4,
         out);
  FWRITE(&nr, size_t,
         1,
         out);
  FWRITE(&nc, size_t,
         1,
         out);
 
  /* Write data... */
  for (size_t i = 0; i < nr; i++)
    for (size_t j = 0; j < nc; j++) {
      double value = gsl_matrix_get(matrix, i, j);
      FWRITE(&value, double,
             1,
             out);
    }
 
  /* Close file... */
  fclose(out);
}
 
/*****************************************************************************/
 
void write_matrix_nc(
  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,
  int dataset) {
 
  char file[LEN];
  char quantity[LEN];
  const size_t name_strlen = 100;
 
  int ncid, dimid_dataset, dimid_row, dimid_col, dimid_name, varid;
  int *cida, *ciqa, *cipa, *cira, *rida, *riqa, *ripa, *rira;
 
  size_t nr = matrix->size1, nc = matrix->size2, naux;
 
  /* Allocate metadata index arrays... */
  ALLOC(cida, int,
        M);
  ALLOC(ciqa, int,
        N);
  ALLOC(cipa, int,
        N);
  ALLOC(cira, int,
        M);
  ALLOC(rida, int,
        M);
  ALLOC(riqa, int,
        N);
  ALLOC(ripa, int,
        N);
  ALLOC(rira, int,
        M);
 
  /* Set filename... */
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Write matrix: %s", file);
 
  /* Open or create file... */
  if (nc_open(file, NC_WRITE, &ncid) != NC_NOERR)
    NC(nc_create(file, NC_NETCDF4, &ncid));
 
  /* Enter define mode... */
  int r = nc_redef(ncid);
  if (r != NC_NOERR && r != NC_EINDEFINE)
    NC(r);
 
  /* Define dataset dimension (unlimited)... */
  if (nc_inq_dimid(ncid, "dataset", &dimid_dataset) != NC_NOERR)
    NC(nc_def_dim(ncid, "dataset", NC_UNLIMITED, &dimid_dataset));
 
  /* Define row dimension (fixed)... */
  if (nc_inq_dimid(ncid, "row", &dimid_row) == NC_NOERR) {
    NC(nc_inq_dimlen(ncid, dimid_row, &naux));
    if (naux != nr)
      ERRMSG("matrix row dimension is incompatible!");
  } else
    NC(nc_def_dim(ncid, "row", nr, &dimid_row));
 
  /* Define col dimension (fixed)... */
  if (nc_inq_dimid(ncid, "col", &dimid_col) == NC_NOERR) {
    NC(nc_inq_dimlen(ncid, dimid_col, &naux));
    if (naux != nc)
      ERRMSG("matrix col dimension is incompatible!");
  } else
    NC(nc_def_dim(ncid, "col", nc, &dimid_col));
 
  /* Define fixed-length name dimension... */
  if (nc_inq_dimid(ncid, "name_strlen", &dimid_name) == NC_NOERR) {
    NC(nc_inq_dimlen(ncid, dimid_name, &naux));
    if (naux != name_strlen)
      ERRMSG("matrix name_strlen dimension is incompatible!");
  } else
    NC(nc_def_dim(ncid, "name_strlen", name_strlen, &dimid_name));
 
  /* Define variables... */
  int dimids3[3] = { dimid_dataset, dimid_row, dimid_col };
  int dimids1[1] = { dimid_dataset };
  int dimids2_row[2] = { dimid_dataset, dimid_row };
  int dimids2_col[2] = { dimid_dataset, dimid_col };
  int dimids3_rowname[3] = { dimid_dataset, dimid_row, dimid_name };
  int dimids3_colname[3] = { dimid_dataset, dimid_col, dimid_name };
  if (nc_inq_varid(ncid, "matrix", &varid) != NC_NOERR) {
    NC(nc_def_var(ncid, "matrix", NC_DOUBLE, 3, dimids3, &varid));
    NC(nc_put_att_text(ncid, varid, "long_name", 14, "matrix element"));
    NC(nc_put_att_text(ncid, varid, "units", 1, "1"));
  }
  if (nc_inq_varid(ncid, "rowspace", &varid) != NC_NOERR)
    NC_DEF_VAR("rowspace", NC_CHAR, 1, dimids1,
               "row space selector", "1", 0, 0);
  if (nc_inq_varid(ncid, "colspace", &varid) != NC_NOERR)
    NC_DEF_VAR("colspace", NC_CHAR, 1, dimids1,
               "column space selector", "1", 0, 0);
  if (nc_inq_varid(ncid, "sort", &varid) != NC_NOERR)
    NC_DEF_VAR("sort", NC_CHAR, 1, dimids1,
               "matrix sort selector", "1", 0, 0);
  if (nc_inq_varid(ncid, "row_nu", &varid) != NC_NOERR)
    NC_DEF_VAR("row_nu", NC_DOUBLE, 2, dimids2_row,
               "row channel wavenumber", "cm^-1", 0, 0);
  if (nc_inq_varid(ncid, "row_time", &varid) != NC_NOERR)
    NC_DEF_VAR("row_time", NC_DOUBLE, 2, dimids2_row,
               "row time since 2000-01-01T00:00Z", "s", 0, 0);
  if (nc_inq_varid(ncid, "row_z", &varid) != NC_NOERR)
    NC_DEF_VAR("row_z", NC_DOUBLE, 2, dimids2_row,
               "row altitude", "km", 0, 0);
  if (nc_inq_varid(ncid, "row_lon", &varid) != NC_NOERR)
    NC_DEF_VAR("row_lon", NC_DOUBLE, 2, dimids2_row,
               "row longitude", "degrees_east", 0, 0);
  if (nc_inq_varid(ncid, "row_lat", &varid) != NC_NOERR)
    NC_DEF_VAR("row_lat", NC_DOUBLE, 2, dimids2_row,
               "row latitude", "degrees_north", 0, 0);
  if (nc_inq_varid(ncid, "row_quantity", &varid) != NC_NOERR)
    NC_DEF_VAR("row_quantity", NC_CHAR, 3, dimids3_rowname,
               "row state quantity name", "1", 0, 0);
  if (nc_inq_varid(ncid, "col_nu", &varid) != NC_NOERR)
    NC_DEF_VAR("col_nu", NC_DOUBLE, 2, dimids2_col,
               "column channel wavenumber", "cm^-1", 0, 0);
  if (nc_inq_varid(ncid, "col_time", &varid) != NC_NOERR)
    NC_DEF_VAR("col_time", NC_DOUBLE, 2, dimids2_col,
               "column time since 2000-01-01T00:00Z", "s", 0, 0);
  if (nc_inq_varid(ncid, "col_z", &varid) != NC_NOERR)
    NC_DEF_VAR("col_z", NC_DOUBLE, 2, dimids2_col,
               "column altitude", "km", 0, 0);
  if (nc_inq_varid(ncid, "col_lon", &varid) != NC_NOERR)
    NC_DEF_VAR("col_lon", NC_DOUBLE, 2, dimids2_col,
               "column longitude", "degrees_east", 0, 0);
  if (nc_inq_varid(ncid, "col_lat", &varid) != NC_NOERR)
    NC_DEF_VAR("col_lat", NC_DOUBLE, 2, dimids2_col,
               "column latitude", "degrees_north", 0, 0);
  if (nc_inq_varid(ncid, "col_quantity", &varid) != NC_NOERR)
    NC_DEF_VAR("col_quantity", NC_CHAR, 3, dimids3_colname,
               "column state quantity name", "1", 0, 0);
 
  /* Leave define mode... */
  NC(nc_enddef(ncid));
 
  /* Write metadata... */
  size_t start1[1] = { (size_t) dataset };
  size_t count1[1] = { 1 };
  NC(nc_inq_varid(ncid, "rowspace", &varid));
  NC(nc_put_vara_text(ncid, varid, start1, count1, rowspace));
  NC(nc_inq_varid(ncid, "colspace", &varid));
  NC(nc_put_vara_text(ncid, varid, start1, count1, colspace));
  NC(nc_inq_varid(ncid, "sort", &varid));
  NC(nc_put_vara_text(ncid, varid, start1, count1, sort));
 
  /* Set row and column metadata indices... */
  if (rowspace[0] == 'y')
    nr = obs2y(ctl, obs, NULL, rida, rira);
  else
    nr = atm2x(ctl, atm, NULL, riqa, ripa);
  if (colspace[0] == 'y')
    nc = obs2y(ctl, obs, NULL, cida, cira);
  else
    nc = atm2x(ctl, atm, NULL, ciqa, cipa);
 
  /* Write row metadata... */
  for (size_t i = 0; i < nr; i++) {
    const double nu = rowspace[0] == 'y' ? ctl->nu[rida[i]] : GSL_NAN;
    const double time =
      rowspace[0] == 'y' ? obs->time[rira[i]] : atm->time[ripa[i]];
    const double z = rowspace[0] == 'y' ? obs->vpz[rira[i]] : atm->z[ripa[i]];
    const double lon =
      rowspace[0] == 'y' ? obs->vplon[rira[i]] : atm->lon[ripa[i]];
    const double lat =
      rowspace[0] == 'y' ? obs->vplat[rira[i]] : atm->lat[ripa[i]];
    char qbuf[LEN] = { 0 };
    size_t start2[2] = { (size_t) dataset, i };
    size_t count2[2] = { 1, 1 };
    size_t start3n[3] = { (size_t) dataset, i, 0 };
    size_t count3n[3] = { 1, 1, name_strlen };
 
    if (rowspace[0] != 'y') {
      idx2name(ctl, riqa[i], quantity);
      snprintf(qbuf, LEN, "%s", quantity);
    }
 
    NC(nc_inq_varid(ncid, "row_nu", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &nu));
    NC(nc_inq_varid(ncid, "row_time", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &time));
    NC(nc_inq_varid(ncid, "row_z", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &z));
    NC(nc_inq_varid(ncid, "row_lon", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &lon));
    NC(nc_inq_varid(ncid, "row_lat", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &lat));
    NC(nc_inq_varid(ncid, "row_quantity", &varid));
    NC(nc_put_vara_text(ncid, varid, start3n, count3n, qbuf));
  }
 
  /* Write column metadata... */
  for (size_t j = 0; j < nc; j++) {
    const double nu = colspace[0] == 'y' ? ctl->nu[cida[j]] : GSL_NAN;
    const double time =
      colspace[0] == 'y' ? obs->time[cira[j]] : atm->time[cipa[j]];
    const double z = colspace[0] == 'y' ? obs->vpz[cira[j]] : atm->z[cipa[j]];
    const double lon =
      colspace[0] == 'y' ? obs->vplon[cira[j]] : atm->lon[cipa[j]];
    const double lat =
      colspace[0] == 'y' ? obs->vplat[cira[j]] : atm->lat[cipa[j]];
    char qbuf[LEN] = { 0 };
    size_t start2[2] = { (size_t) dataset, j };
    size_t count2[2] = { 1, 1 };
    size_t start3n[3] = { (size_t) dataset, j, 0 };
    size_t count3n[3] = { 1, 1, name_strlen };
 
    if (colspace[0] != 'y') {
      idx2name(ctl, ciqa[j], quantity);
      snprintf(qbuf, LEN, "%s", quantity);
    }
 
    NC(nc_inq_varid(ncid, "col_nu", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &nu));
    NC(nc_inq_varid(ncid, "col_time", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &time));
    NC(nc_inq_varid(ncid, "col_z", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &z));
    NC(nc_inq_varid(ncid, "col_lon", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &lon));
    NC(nc_inq_varid(ncid, "col_lat", &varid));
    NC(nc_put_vara_double(ncid, varid, start2, count2, &lat));
    NC(nc_inq_varid(ncid, "col_quantity", &varid));
    NC(nc_put_vara_text(ncid, varid, start3n, count3n, qbuf));
  }
 
  /* Write matrix data... */
  NC(nc_inq_varid(ncid, "matrix", &varid));
  for (size_t i = 0; i < nr; i++)
    for (size_t j = 0; j < nc; j++) {
      const double value = gsl_matrix_get(matrix, i, j);
      size_t start3[3] = { (size_t) dataset, i, j };
      size_t count3[3] = { 1, 1, 1 };
      NC(nc_put_vara_double(ncid, varid, start3, count3, &value));
    }
 
  /* Close file... */
  NC(nc_sync(ncid));
  NC(nc_close(ncid));
 
  /* Free... */
  free(cida);
  free(ciqa);
  free(cipa);
  free(cira);
  free(rida);
  free(riqa);
  free(ripa);
  free(rira);
}
 
/*****************************************************************************/
 
void write_obs(
  const char *dirname,
  const char *filename,
  const ctl_t *ctl,
  const obs_t *obs,
  int profile) {
 
  /* Set filename... */
  char file[LEN];
  if (dirname != NULL)
    sprintf(file, "%s/%s", dirname, filename);
  else
    sprintf(file, "%s", filename);
 
  /* Write info... */
  LOG(1, "Write observation data: %s", file);
 
  /* Write ASCII data... */
  if (ctl->obsfmt == 1)
    write_obs_asc(file, ctl, obs);
 
  /* Write binary data... */
  else if (ctl->obsfmt == 2)
    write_obs_bin(file, ctl, obs);
 
  /* Write netCDF data... */
  else if (ctl->obsfmt == 3)
    write_obs_nc(file, ctl, obs, profile);
 
  /* Write info... */
  double mini, maxi;
  LOG(2, "Number of ray paths: %d", obs->nr);
  gsl_stats_minmax(&mini, &maxi, obs->time, 1, (size_t) obs->nr);
  LOG(2, "Time range: %.2f ... %.2f s", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->obsz, 1, (size_t) obs->nr);
  LOG(2, "Observer altitude range: %g ... %g km", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->obslon, 1, (size_t) obs->nr);
  LOG(2, "Observer longitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->obslat, 1, (size_t) obs->nr);
  LOG(2, "Observer latitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->vpz, 1, (size_t) obs->nr);
  LOG(2, "View point altitude range: %g ... %g km", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->vplon, 1, (size_t) obs->nr);
  LOG(2, "View point longitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->vplat, 1, (size_t) obs->nr);
  LOG(2, "View point latitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->tpz, 1, (size_t) obs->nr);
  LOG(2, "Tangent point altitude range: %g ... %g km", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->tplon, 1, (size_t) obs->nr);
  LOG(2, "Tangent point longitude range: %g ... %g deg", mini, maxi);
  gsl_stats_minmax(&mini, &maxi, obs->tplat, 1, (size_t) obs->nr);
  LOG(2, "Tangent point latitude range: %g ... %g deg", mini, maxi);
  for (int id = 0; id < ctl->nd; id++) {
    gsl_stats_minmax(&mini, &maxi, obs->rad[id], 1, (size_t) obs->nr);
    if (ctl->write_bbt) {
      LOG(2, "Brightness temperature (%.4f cm^-1) range: %g ... %g K",
          ctl->nu[id], mini, maxi);
    } else {
      LOG(2, "Radiance (%.4f cm^-1) range: %g ... %g W/(m^2 sr cm^-1)",
          ctl->nu[id], mini, maxi);
    }
  }
  for (int id = 0; id < ctl->nd; id++) {
    gsl_stats_minmax(&mini, &maxi, obs->tau[id], 1, (size_t) obs->nr);
    LOG(2, "Transmittance (%.4f cm^-1) range: %g ... %g",
        ctl->nu[id], mini, maxi);
  }
}
 
/*****************************************************************************/
 
void write_obs_asc(
  const char *filename,
  const ctl_t *ctl,
  const obs_t *obs) {
 
  int n = 10;
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(filename, "w")))
    ERRMSG("Cannot create file!");
 
  /* Write header... */
  fprintf(out,
          "# $1 = time (seconds since 2000-01-01T00:00Z)\n"
          "# $2 = observer altitude [km]\n"
          "# $3 = observer longitude [deg]\n"
          "# $4 = observer latitude [deg]\n"
          "# $5 = view point altitude [km]\n"
          "# $6 = view point longitude [deg]\n"
          "# $7 = view point latitude [deg]\n"
          "# $8 = tangent point altitude [km]\n"
          "# $9 = tangent point longitude [deg]\n"
          "# $10 = tangent point latitude [deg]\n");
  for (int id = 0; id < ctl->nd; id++)
    if (ctl->write_bbt)
      fprintf(out, "# $%d = brightness temperature (%.4f cm^-1) [K]\n",
              ++n, ctl->nu[id]);
    else
      fprintf(out, "# $%d = radiance (%.4f cm^-1) [W/(m^2 sr cm^-1)]\n",
              ++n, ctl->nu[id]);
  for (int id = 0; id < ctl->nd; id++)
    fprintf(out, "# $%d = transmittance (%.4f cm^-1) [-]\n", ++n,
            ctl->nu[id]);
 
  /* Write data... */
  for (int ir = 0; ir < obs->nr; ir++) {
    if (ir == 0 || obs->time[ir] != obs->time[ir - 1])
      fprintf(out, "\n");
    fprintf(out, "%.2f %g %g %g %g %g %g %g %g %g", obs->time[ir],
            obs->obsz[ir], obs->obslon[ir], obs->obslat[ir],
            obs->vpz[ir], obs->vplon[ir], obs->vplat[ir],
            obs->tpz[ir], obs->tplon[ir], obs->tplat[ir]);
    for (int id = 0; id < ctl->nd; id++)
      fprintf(out, " %g", obs->rad[id][ir]);
    for (int id = 0; id < ctl->nd; id++)
      fprintf(out, " %g", obs->tau[id][ir]);
    fprintf(out, "\n");
  }
 
  /* Close file... */
  fclose(out);
}
 
/*****************************************************************************/
 
void write_obs_bin(
  const char *filename,
  const ctl_t *ctl,
  const obs_t *obs) {
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(filename, "w")))
    ERRMSG("Cannot create file!");
 
  /* Write header... */
  FWRITE("OBS1", char,
         4,
         out);
  FWRITE(&ctl->nd, int,
         1,
         out);
 
  /* Write data... */
  size_t nr = (size_t) obs->nr;
  FWRITE(&nr, size_t,
         1,
         out);
  FWRITE(obs->time, double,
         nr,
         out);
  FWRITE(obs->obsz, double,
         nr,
         out);
  FWRITE(obs->obslon, double,
         nr,
         out);
  FWRITE(obs->obslat, double,
         nr,
         out);
  FWRITE(obs->vpz, double,
         nr,
         out);
  FWRITE(obs->vplon, double,
         nr,
         out);
  FWRITE(obs->vplat, double,
         nr,
         out);
  FWRITE(obs->tpz, double,
         nr,
         out);
  FWRITE(obs->tplon, double,
         nr,
         out);
  FWRITE(obs->tplat, double,
         nr,
         out);
  for (int id = 0; id < ctl->nd; id++)
    FWRITE(obs->rad[id], double,
           nr,
           out);
  for (int id = 0; id < ctl->nd; id++)
    FWRITE(obs->tau[id], double,
           nr,
           out);
 
  /* Close file... */
  fclose(out);
}
 
/*****************************************************************************/
 
void write_obs_nc(
  const char *filename,
  const ctl_t *ctl,
  const obs_t *obs,
  const int profile) {
 
  char longname[LEN], varname[LEN];
  const char *spec_prefix = ctl->write_bbt ? "bt" : "rad";
 
  int ncid, varid, dim_profile, dim_ray;
 
  size_t ray_max;
 
  /* Check number of rays... */
  if (obs->nr < 1 || obs->nr > NR)
    ERRMSG("Number of ray paths out of range!");
 
  /* Open or create file... */
  if (nc_open(filename, NC_WRITE, &ncid) != NC_NOERR)
    NC(nc_create(filename, NC_NETCDF4, &ncid));
 
  /* Enter define mode... */
  int r = nc_redef(ncid);
  if (r != NC_NOERR && r != NC_EINDEFINE)
    NC(r);
 
  /* Define profile dimension (unlimited)... */
  if (nc_inq_dimid(ncid, "profile", &dim_profile) != NC_NOERR)
    NC(nc_def_dim(ncid, "profile", NC_UNLIMITED, &dim_profile));
 
  /* Define ray dimension (fixed)... */
  if (nc_inq_dimid(ncid, "ray", &dim_ray) == NC_NOERR) {
    NC(nc_inq_dimlen(ncid, dim_ray, &ray_max));
    if (ray_max < 1 || ray_max > (size_t) NR)
      ERRMSG("netCDF dimension ray is out of range!");
    if ((size_t) obs->nr > ray_max)
      ERRMSG("profile has too many rays!");
  } else {
    ray_max = (size_t) obs->nr;
    NC(nc_def_dim(ncid, "ray", ray_max, &dim_ray));
  }
 
  /* Dimension ID array... */
  int dimids[2] = { dim_profile, dim_ray };
 
  /* Tunables for compression/quantization... */
  const int deflate_level = 0;
  const int quant_digits = 0;
 
  /* Define nray (1D over profile)... */
  if (nc_inq_varid(ncid, "nray", &varid) != NC_NOERR)
    NC_DEF_VAR("nray", NC_INT, 1, dimids, "number of ray paths", "1", 0, 0);
 
  /* Define geometry variables (2D over profile, ray)... */
  if (nc_inq_varid(ncid, "time", &varid) != NC_NOERR)
    NC_DEF_VAR("time", NC_DOUBLE, 2, dimids,
               "time in seconds since 2000-01-01, 00:00 UTC", "s",
               deflate_level, 0);
 
  if (nc_inq_varid(ncid, "obs_z", &varid) != NC_NOERR)
    NC_DEF_VAR("obs_z", NC_DOUBLE, 2, dimids,
               "observer altitude", "km", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "obs_lon", &varid) != NC_NOERR)
    NC_DEF_VAR("obs_lon", NC_DOUBLE, 2, dimids,
               "observer longitude", "degrees_east", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "obs_lat", &varid) != NC_NOERR)
    NC_DEF_VAR("obs_lat", NC_DOUBLE, 2, dimids,
               "observer latitude", "degrees_north", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "vp_z", &varid) != NC_NOERR)
    NC_DEF_VAR("vp_z", NC_DOUBLE, 2, dimids,
               "view point altitude", "km", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "vp_lon", &varid) != NC_NOERR)
    NC_DEF_VAR("vp_lon", NC_DOUBLE, 2, dimids,
               "view point longitude", "degrees_east", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "vp_lat", &varid) != NC_NOERR)
    NC_DEF_VAR("vp_lat", NC_DOUBLE, 2, dimids,
               "view point latitude", "degrees_north", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "tp_z", &varid) != NC_NOERR)
    NC_DEF_VAR("tp_z", NC_DOUBLE, 2, dimids,
               "tangent point altitude", "km", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "tp_lon", &varid) != NC_NOERR)
    NC_DEF_VAR("tp_lon", NC_DOUBLE, 2, dimids,
               "tangent point longitude", "degrees_east", deflate_level, 0);
 
  if (nc_inq_varid(ncid, "tp_lat", &varid) != NC_NOERR)
    NC_DEF_VAR("tp_lat", NC_DOUBLE, 2, dimids,
               "tangent point latitude", "degrees_north", deflate_level, 0);
 
  /* Define radiance/transmittance per channel (2D profile,ray)... */
  for (int id = 0; id < ctl->nd; id++) {
 
    sprintf(varname, "%s_%.4f", spec_prefix, ctl->nu[id]);
    if (nc_inq_varid(ncid, varname, &varid) != NC_NOERR) {
      if (ctl->write_bbt) {
        sprintf(longname, "brightness temperature (%.4f cm^-1)", ctl->nu[id]);
        NC_DEF_VAR(varname, NC_DOUBLE, 2, dimids, longname, "K",
                   deflate_level, quant_digits);
      } else {
        sprintf(longname, "radiance (%.4f cm^-1)", ctl->nu[id]);
        NC_DEF_VAR(varname, NC_DOUBLE, 2, dimids, longname,
                   "W/(m^2 sr cm^-1)", deflate_level, quant_digits);
      }
    }
 
    sprintf(varname, "tau_%.4f", ctl->nu[id]);
    if (nc_inq_varid(ncid, varname, &varid) != NC_NOERR) {
      sprintf(longname, "transmittance (%.4f cm^-1)", ctl->nu[id]);
      NC_DEF_VAR(varname, NC_DOUBLE, 2, dimids, longname, "1",
                 deflate_level, quant_digits);
    }
  }
 
  /* Leave define mode... */
  NC(nc_enddef(ncid));
 
  /* Hyperslabs... */
  size_t start[2] = { (size_t) profile, 0 };
  size_t count[2] = { 1, (size_t) obs->nr };
 
  /* Write nray(profile)... */
  int nr = obs->nr;
  NC(nc_inq_varid(ncid, "nray", &varid));
  NC(nc_put_vara_int(ncid, varid, start, count, &nr));
 
  /* Write geometry... */
  NC(nc_inq_varid(ncid, "time", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->time));
 
  NC(nc_inq_varid(ncid, "obs_z", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->obsz));
 
  NC(nc_inq_varid(ncid, "obs_lon", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->obslon));
 
  NC(nc_inq_varid(ncid, "obs_lat", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->obslat));
 
  NC(nc_inq_varid(ncid, "vp_z", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->vpz));
 
  NC(nc_inq_varid(ncid, "vp_lon", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->vplon));
 
  NC(nc_inq_varid(ncid, "vp_lat", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->vplat));
 
  NC(nc_inq_varid(ncid, "tp_z", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->tpz));
 
  NC(nc_inq_varid(ncid, "tp_lon", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->tplon));
 
  NC(nc_inq_varid(ncid, "tp_lat", &varid));
  NC(nc_put_vara_double(ncid, varid, start, count, obs->tplat));
 
  /* Write spectral variables per channel... */
  for (int id = 0; id < ctl->nd; id++) {
    sprintf(varname, "%s_%.4f", spec_prefix, ctl->nu[id]);
    NC(nc_inq_varid(ncid, varname, &varid));
    NC(nc_put_vara_double(ncid, varid, start, count, obs->rad[id]));
 
    sprintf(varname, "tau_%.4f", ctl->nu[id]);
    NC(nc_inq_varid(ncid, varname, &varid));
    NC(nc_put_vara_double(ncid, varid, start, count, obs->tau[id]));
  }
 
  /* Close file... */
  NC(nc_sync(ncid));
  NC(nc_close(ncid));
}
 
/*****************************************************************************/
 
void write_shape(
  const char *filename,
  const double *x,
  const double *y,
  const int n) {
 
  /* Write info... */
  LOG(1, "Write shape function: %s", filename);
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(filename, "w")))
    ERRMSG("Cannot create file!");
 
  /* Write header... */
  fprintf(out,
          "# $1 = shape function x-value [-]\n"
          "# $2 = shape function y-value [-]\n\n");
 
  /* Write data... */
  for (int i = 0; i < n; i++)
    fprintf(out, "%.10g %.10g\n", x[i], y[i]);
 
  /* Close file... */
  fclose(out);
}
 
/*****************************************************************************/
 
void write_stddev(
  const char *quantity,
  const ret_t *ret,
  const ctl_t *ctl,
  const atm_t *atm,
  const gsl_matrix *s) {
 
  /* Get sizes... */
  const size_t n = s->size1;
 
  /* Allocate... */
  atm_t *atm_aux;
  ALLOC(atm_aux, atm_t, 1);
  gsl_vector *x_aux = gsl_vector_alloc(n);
 
  /* Compute standard deviation... */
  for (size_t i = 0; i < n; i++)
    gsl_vector_set(x_aux, i, sqrt(gsl_matrix_get(s, i, i)));
 
  /* Write to disk... */
  char filename[LEN];
  const char *dirname;
  int profile;
  const char *shared_file = "-";
  copy_atm(ctl, atm_aux, atm, 1);
  x2atm(ctl, x_aux, atm_aux);
  if (strcmp(quantity, "total") == 0)
    shared_file = ret->shared_io_atm_err_total_file;
  else if (strcmp(quantity, "noise") == 0)
    shared_file = ret->shared_io_atm_err_noise_file;
  else if (strcmp(quantity, "formod") == 0)
    shared_file = ret->shared_io_atm_err_formod_file;
  sprintf(filename, "atm_err_%s.tab", quantity);
  const char *target =
    shared_io_output_target(ret, shared_file, filename, &dirname, &profile);
  write_atm(dirname, target, ctl, atm_aux, profile);
 
  /* Free... */
  gsl_vector_free(x_aux);
}
 
/*****************************************************************************/
 
void write_tbl(
  const ctl_t *ctl,
  const tbl_t *tbl) {
 
  /* Loop over emitters and detectors... */
  for (int ig = 0; ig < ctl->ng; ig++)
    for (int id = 0; id < ctl->nd; id++) {
 
      /* Skip empty tables... */
      if (tbl->np[id][ig] <= 0) {
        WARN("Skip writing empty emissivity table: emitter=%s, nu=%.4f",
             ctl->emitter[ig], ctl->nu[id]);
        continue;
      }
 
      /* Write ASCII look-up tables... */
      if (ctl->tblfmt == 1)
        write_tbl_asc(ctl, tbl, id, ig);
 
      /* Write binary look-up tables... */
      else if (ctl->tblfmt == 2)
        write_tbl_bin(ctl, tbl, id, ig);
 
      /* Write netCDF look-up tables... */
      else if (ctl->tblfmt == 3)
        write_tbl_nc(ctl, tbl, id, ig);
 
      /* Write info... */
      TBL_LOG(tbl, id, ig);
    }
 
  /* Write filter functions... */
  if (ctl->tblfmt == 1)
    for (int id = 0; id < ctl->nd; id++) {
      char filename[2 * LEN];
      sprintf(filename, "%s_%.4f.filt", ctl->tblbase, ctl->nu[id]);
      write_shape(filename, tbl->filt_nu[id], tbl->filt_f[id],
                  tbl->filt_n[id]);
    }
}
 
/*****************************************************************************/
 
void write_tbl_asc(
  const ctl_t *ctl,
  const tbl_t *tbl,
  const int id,
  const int ig) {
 
  /* Set filename... */
  char filename[2 * LEN];
  sprintf(filename, "%s_%.4f_%s.tab", ctl->tblbase,
          ctl->nu[id], ctl->emitter[ig]);
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(filename, "w"))) {
    ERRMSG("Cannot create emissivity table: %s", filename);
  } else
    LOG(1, "Write emissivity table: %s", filename);
 
  /* Write header... */
  fprintf(out,
          "# $1 = pressure [hPa]\n"
          "# $2 = temperature [K]\n"
          "# $3 = column density [molecules/cm^2]\n"
          "# $4 = emissivity [-]\n");
 
  /* Save table file... */
  for (int ip = 0; ip < tbl->np[id][ig]; ip++)
    for (int it = 0; it < tbl->nt[id][ig][ip]; it++) {
      fprintf(out, "\n");
      for (int iu = 0; iu < tbl->nu[id][ig][ip][it]; iu++)
        fprintf(out, "%g %g %e %e\n",
                tbl->p[id][ig][ip], tbl->t[id][ig][ip][it],
                exp(tbl->logu[id][ig][ip][it][iu]),
                exp(tbl->logeps[id][ig][ip][it][iu]));
    }
 
  /* Close file... */
  fclose(out);
}
 
/*****************************************************************************/
 
void write_tbl_bin(
  const ctl_t *ctl,
  const tbl_t *tbl,
  const int id,
  const int ig) {
 
  /* Set filename... */
  char filename[2 * LEN];
  sprintf(filename, "%s_%.4f_%s.bin",
          ctl->tblbase, ctl->nu[id], ctl->emitter[ig]);
 
  /* Create file... */
  FILE *out;
  if (!(out = fopen(filename, "w"))) {
    ERRMSG("Cannot create emissivity table: %s", filename);
  } else
    LOG(1, "Write emissivity table: %s", filename);
 
  /* Pack... */
  size_t used = 0;
  const size_t need = tbl_packed_size(tbl, id, ig);
  uint8_t *work = NULL;
  ALLOC(work, uint8_t, need);
  tbl_pack(tbl, id, ig, work, &used);
  if (used != need)
    ERRMSG("Internal error: packed size mismatch!");
 
  /* Write length and packed blob... */
  FWRITE(&used, size_t,
         1,
         out);
  FWRITE(work, uint8_t, used, out);
 
  /* Close file... */
  fclose(out);
 
  /* Free... */
  free(work);
}
 
/*****************************************************************************/
 
void write_tbl_nc(
  const ctl_t *ctl,
  const tbl_t *tbl,
  const int id,
  const int ig) {
 
  /* Set filename... */
  char filename[2 * LEN];
  sprintf(filename, "%s_%s.nc", ctl->tblbase, ctl->emitter[ig]);
 
  /* Open or create file... */
  int ncid;
  if (nc_open(filename, NC_WRITE, &ncid) != NC_NOERR) {
    if (nc_create(filename, NC_NETCDF4 | NC_CLOBBER, &ncid) != NC_NOERR)
      ERRMSG("Cannot open or create emissivity table: %s", filename);
    NC_PUT_ATT_GLOBAL("format_version", "1");
    NC_PUT_ATT_GLOBAL("emitter", ctl->emitter[ig]);
    NC(nc_enddef(ncid));
  }
 
  /* Set variable and dimension name... */
  char varname[LEN], dimname[LEN];
  sprintf(varname, "tbl_%.4f", ctl->nu[id]);
  sprintf(dimname, "len_%.4f", ctl->nu[id]);
 
  /* Write info... */
  LOG(1, "Write emissivity table: %s in %s", varname, filename);
 
  /* Allocate work space... */
  size_t used = 0;
  const size_t need = tbl_packed_size(tbl, id, ig);
  uint8_t *work = NULL;
  ALLOC(work, uint8_t, need);
 
  /* Pack table... */
  tbl_pack(tbl, id, ig, work, &used);
  if (used != need)
    ERRMSG("Internal error: packed size mismatch!");
 
  /* Prevent overwrite... */
  int tmp;
  if (nc_inq_varid(ncid, varname, &tmp) == NC_NOERR)
    ERRMSG("Table already present!");
 
  /* Add dimension and variable... */
  int dimid, varid;
  NC(nc_redef(ncid));
  NC(nc_def_dim(ncid, dimname, used, &dimid));
  int dimids[1] = { dimid };
  NC_DEF_VAR(varname, NC_UBYTE, 1, dimids,
             "Packed lookup table blob", "1", 0, 0);
  NC(nc_enddef(ncid));
 
  /* Write data... */
  NC(nc_put_var_uchar(ncid, varid, (const unsigned char *) work));
 
  /* Free... */
  free(work);
 
  /* Close file... */
  NC(nc_close(ncid));
}
 
/*****************************************************************************/
 
void x2atm(
  const ctl_t *ctl,
  const gsl_vector *x,
  atm_t *atm) {
 
  size_t n = 0;
 
  /* Get pressure... */
  for (int ip = 0; ip < atm->np; ip++)
    if (atm->z[ip] >= ctl->retp_zmin && atm->z[ip] <= ctl->retp_zmax)
      x2atm_help(&atm->p[ip], x, &n);
 
  /* Get temperature... */
  for (int ip = 0; ip < atm->np; ip++)
    if (atm->z[ip] >= ctl->rett_zmin && atm->z[ip] <= ctl->rett_zmax)
      x2atm_help(&atm->t[ip], x, &n);
 
  /* Get volume mixing ratio... */
  for (int ig = 0; ig < ctl->ng; ig++)
    for (int ip = 0; ip < atm->np; ip++)
      if (atm->z[ip] >= ctl->retq_zmin[ig]
          && atm->z[ip] <= ctl->retq_zmax[ig])
        x2atm_help(&atm->q[ig][ip], x, &n);
 
  /* Get extinction... */
  for (int iw = 0; iw < ctl->nw; iw++)
    for (int ip = 0; ip < atm->np; ip++)
      if (atm->z[ip] >= ctl->retk_zmin[iw]
          && atm->z[ip] <= ctl->retk_zmax[iw])
        x2atm_help(&atm->k[iw][ip], x, &n);
 
  /* Get cloud data... */
  if (ctl->ret_clz)
    x2atm_help(&atm->clz, x, &n);
  if (ctl->ret_cldz)
    x2atm_help(&atm->cldz, x, &n);
  if (ctl->ret_clk)
    for (int icl = 0; icl < ctl->ncl; icl++)
      x2atm_help(&atm->clk[icl], x, &n);
 
  /* Get surface data... */
  if (ctl->ret_sft)
    x2atm_help(&atm->sft, x, &n);
  if (ctl->ret_sfeps)
    for (int isf = 0; isf < ctl->nsf; isf++)
      x2atm_help(&atm->sfeps[isf], x, &n);
}
 
/*****************************************************************************/
 
void x2atm_help(
  double *value,
  const gsl_vector *x,
  size_t *n) {
 
  /* Get state vector element... */
  *value = gsl_vector_get(x, *n);
  (*n)++;
}
 
/*****************************************************************************/
 
void y2obs(
  const ctl_t *ctl,
  const gsl_vector *y,
  obs_t *obs) {
 
  size_t m = 0;
 
  /* Decompose measurement vector... */
  for (int ir = 0; ir < obs->nr; ir++)
    for (int id = 0; id < ctl->nd; id++)
      if (isfinite(obs->rad[id][ir])) {
        obs->rad[id][ir] = gsl_vector_get(y, m);
        m++;
      }
}