ARTS: methods.cc Source File

00001 /* Copyright (C) 2000-2008
00002    Stefan Buehler <sbuehler@uni-bremen.de>
00003    Patrick Eriksson <patrick@rss.chalmers.se>
00004    Oliver Lemke <olemke@ltu.se>
00005 
00006    This program is free software; you can redistribute it and/or modify it
00007    under the terms of the GNU General Public License as published by the
00008    Free Software Foundation; either version 2, or (at your option) any
00009    later version.
00010 
00011    This program is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU General Public License for more details.
00015 
00016    You should have received a copy of the GNU General Public License
00017    along with this program; if not, write to the Free Software
00018    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
00019    USA. */
00020 
00033 #include "arts.h"
00034 #include "make_array.h"
00035 #include "methods.h"
00036 #include "wsv_aux.h"
00037 
00038 // Some #defines and typedefs to make the records better readable:
00039 #define NAME(x) x
00040 #define DESCRIPTION(x) x
00041 #define AUTHORS     MakeArray<String>
00042 #define OUT         MakeArray<String>
00043 #define GOUT        MakeArray<String>
00044 #define GOUT_TYPE   MakeArray<String>
00045 #define GOUT_DESC   MakeArray<String>
00046 #define IN          MakeArray<String>
00047 #define GIN         MakeArray<String>
00048 #define GIN_TYPE    MakeArray<String>
00049 #define GIN_DEFAULT MakeArray<String>
00050 #define GIN_DESC    MakeArray<String>
00051 #define SETMETHOD(x) x
00052 #define AGENDAMETHOD(x) x
00053 #define SUPPRESSHEADER(x) x
00054 #define PASSWORKSPACE(x) x
00055 #define PASSWSVNAMES(x) x
00056 
00057 
00058 /* Here's a template record entry:  (PE 2008-09-20)
00059 
00060   md_data_raw.push_back
00061     ( MdRecord
00062       ( NAME("MethodName"),
00063         DESCRIPTION
00064         (
00065          "A concise summary of the method.\n"
00066          "\n"
00067          "A more detailed description of the method. Try to describe the\n"
00068          "purpose of the method and important considerations. Try to avoid\n"
00069          "references to other WSMs as they might change. Refer to the user\n"
00070          "guide for more complex information (as long as it exists, or that\n"
00071          "you add it to AUG!).\n"
00072          "\n"
00073          "You do not need to describe workspace variables used. That\n"
00074          "information is found in workspace.cc. Generic\n"
00075          "output and input variables must be described in GIN_DESC and\n"
00076          "GOUT_DESC below.\n"
00077         ),
00078         AUTHORS( "Your Name" ),
00079         OUT(),
00080         GOUT(),
00081         GOUT_TYPE(),
00082         GOUT_DESC(),
00083         IN(),
00084         GIN(         "descriptive_name_for_generic_input1" ),
00085         GIN_TYPE(    "GenericInput1Type" ),
00086         GIN_DEFAULT( NODEF ),
00087         GIN_DESC(    "Description for Generic Input Variable 1" )
00088       ));
00089 
00090 */
00091 
00092 
00093 
00094 void define_md_data_raw()
00095 {
00096   // The variable md_data is defined in file methods_aux.cc.
00097   extern Array<MdRecord> md_data_raw;
00098 
00099   // Initialize to zero, just in case:
00100   md_data_raw.resize(0);
00101 
00102   const String ARRAY_GROUPS = get_array_groups_as_string();
00103 
00105   // Let's put in the functions in alphabetical order. This gives a clear rule
00106   // for where to place a new function and this gives a nicer results when
00107   // the functions are listed by "arts -m all".
00108   // No distinction is made between uppercase and lowercase letters. The sign
00109   // "_" comes after all letters.
00110   // Patrick Eriksson 2002-05-08
00112 
00113   md_data_raw.push_back
00114     ( MdRecord
00115       ( NAME( "AbsInputFromAtmFields" ),
00116         DESCRIPTION(
00117                     "Initialize the WSVs *abs_p*, *abs_t* and *abs_vmrs* from\n"
00118                     "*p_grid, *t_field* and *vmr_field*.\n"
00119                     "\n"
00120                     "This only works for a 1D atmosphere!\n"
00121                    ),
00122         AUTHORS( "Stefan Buehler" ),
00123         OUT( "abs_p", "abs_t", "abs_vmrs" ),
00124         GOUT(),
00125         GOUT_TYPE(),
00126         GOUT_DESC(),
00127         IN( "atmosphere_dim", "p_grid", "t_field", "vmr_field" ),
00128         GIN(),
00129         GIN_TYPE(),
00130         GIN_DEFAULT(),
00131         GIN_DESC()
00132       ));
00133 
00134   md_data_raw.push_back
00135     ( MdRecord
00136       ( NAME( "AbsInputFromRteScalars" ),
00137         DESCRIPTION(
00138                     "Initialize absorption input WSVs from local atmospheric conditions.\n"
00139                     "\n"
00140                     "The purpose of this method is to allow an explicit line-by-line\n"
00141                     "calculation, e.g., by *abs_coefCalc*, to be put inside the\n"
00142                     "*abs_scalar_gas_agenda*. What the method does is to prepare absorption\n"
00143                     "input parameters (pressure, temperature, VMRs, frequency grid), from\n"
00144                     "the input parameters to *abs_scalar_gas_agenda*.\n"
00145                     "There is a matching method to turn the output of *abs_coefCalc*\n"
00146                     "into what the agenda expects (*abs_scalar_gasFromAbsCoef*).\n"
00147                     "\n"
00148                     "Note that the original *f_grid* is distroyed. (This is not a problem\n"
00149                     "if the method is used inside an agenda.)\n"
00150                    ),
00151         AUTHORS( "Stefan Buehler" ),
00152         OUT( "abs_p", "abs_t", "abs_vmrs" ),
00153         GOUT(),
00154         GOUT_TYPE(),
00155         GOUT_DESC(),
00156         IN( "rte_pressure", "rte_temperature", "rte_vmr_list" ),
00157         GIN(),
00158         GIN_TYPE(),
00159         GIN_DEFAULT(),
00160         GIN_DESC()
00161       ));
00162 
00163   md_data_raw.push_back
00164     ( MdRecord
00165       ( NAME( "abs_coefCalc" ),
00166         DESCRIPTION(
00167                     "Calculate absorption coefficients. \n"
00168                     "\n"
00169                     "This function calculates both, the total absorption (*abs_coef*), and\n"
00170                     "the absorption per species (*abs_coef_per_species*).\n"
00171                     "\n"
00172                     "The method calls four other  methods:\n"
00173                     "\n"
00174                     "1. *abs_xsec_per_speciesInit*:\n"
00175                     "   Initialize *abs_xsec_per_species* \n"
00176                     "\n"
00177                     "2. *abs_xsec_per_speciesAddLines*:\n"
00178                     "   Calculate cross sections per tag group for line spectra.\n"
00179                     "\n"
00180                     "3. *abs_xsec_per_speciesAddConts*:\n"
00181                     "   Calculate cross sections per tag group for continua.\n"
00182                     "\n"
00183                     "4. *abs_coefCalcFromXsec*:\n"
00184                     "   Calculate absorption coefficients from the cross sections by\n"
00185                     "   multiplying each cross section by n*VMR.\n"
00186                     "\n"
00187                     "This is done once for each tag group (output *abs_coef_per_species*),\n"
00188                     "and for the sum of all tag groups (output *abs_coef*).\n"
00189                    ),
00190         AUTHORS( "Axel von Engeln", "Stefan Buehler" ),
00191         OUT( "abs_coef"  , "abs_coef_per_species" ),
00192         GOUT(),
00193         GOUT_TYPE(),
00194         GOUT_DESC(),
00195         IN( "abs_species", "f_grid", "abs_p", "abs_t", "abs_n2", "abs_h2o",
00196                "abs_vmrs", "abs_lines_per_species", "abs_lineshape",
00197                "abs_cont_names", "abs_cont_models", 
00198                "abs_cont_parameters" ),
00199         GIN(),
00200         GIN_TYPE(),
00201         GIN_DEFAULT(),
00202         GIN_DESC()
00203       ));
00204 
00205   md_data_raw.push_back
00206     ( MdRecord
00207       ( NAME("abs_coefCalcFromXsec"),
00208         DESCRIPTION(
00209                     "Calculate absorption coefficients from cross sections.\n"
00210                     "\n"
00211                     "This calculates both the total absorption and the\n"
00212                     "absorption per tag group. \n"
00213                     "\n"
00214                     "Cross sections are multiplied by n*VMR.\n"
00215                    ),
00216         AUTHORS( "Stefan Buehler", "Axel von Engeln" ),
00217         OUT( "abs_coef", "abs_coef_per_species" ),
00218         GOUT(),
00219         GOUT_TYPE(),
00220         GOUT_DESC(),
00221         IN( "abs_xsec_per_species", "abs_vmrs", "abs_p", "abs_t" ),
00222         GIN(),
00223         GIN_TYPE(),
00224         GIN_DEFAULT(),
00225         GIN_DESC()
00226       ));
00227 
00228   md_data_raw.push_back
00229     ( MdRecord
00230       ( NAME( "abs_coefCalcSaveMemory" ),
00231         DESCRIPTION(
00232                     "Calculate absorption coefficients, trying to conserve memory. \n"
00233                     "\n"
00234                     "This function calculates only the total absorption (*abs_coef*),\n"
00235                     "NOT the absorption per tag group (*abs_coef_per_species*).\n"
00236                     "\n"
00237                     "This means you cannot use it if you want to calculate Jacobians\n"
00238                     "later.\n"
00239                     "\n"
00240                     "The implementation follows abs_coefCalc.\n"
00241                    ),
00242         AUTHORS( "Stefan Buehler" ),
00243         OUT( "abs_coef" ),
00244         GOUT(),
00245         GOUT_TYPE(),
00246         GOUT_DESC(),
00247         IN( "abs_species", "f_grid", "abs_p", "abs_t", "abs_n2", "abs_h2o",
00248                "abs_vmrs", "abs_lines_per_species", "abs_lineshape",
00249                "abs_cont_names", "abs_cont_models", 
00250                "abs_cont_parameters" ),
00251         GIN(),
00252         GIN_TYPE(),
00253         GIN_DEFAULT(),
00254         GIN_DESC()
00255       ));
00256 
00257   md_data_raw.push_back
00258     ( MdRecord
00259       ( NAME("abs_cont_descriptionAppend"),
00260         DESCRIPTION
00261         (
00262          "Appends the description of a continuum model or a complete absorption\n"
00263          "model to *abs_cont_names* and *abs_cont_parameters*.\n"
00264          "\n"
00265          "See online documentation for *abs_cont_names* for a list of\n"
00266          "allowed models and for information what parameters they require. See\n"
00267          "file cont.arts in the doc/examples directory for usage examples and\n"
00268          "default parameters for the various models. \n"
00269          "\n"
00270          "Keywords:\n"
00271          "   name       : The name of a continuum model. Must match one of the models\n"
00272          "                implemented in ARTS. \n"
00273          "   option     : give here the option of this continuum/full model.\n"
00274          "   parameters : A Vector containing the required number of parameters\n"
00275          "                for the model given. The meaning of the parameters and\n"
00276          "                how many parameters are required depends on the model.\n"
00277         ),
00278         AUTHORS( "Stefan Buehler" ),
00279         OUT( "abs_cont_names", 
00280                 "abs_cont_models",
00281                 "abs_cont_parameters" ),
00282         GOUT(),
00283         GOUT_TYPE(),
00284         GOUT_DESC(),
00285         IN(  "abs_cont_names", 
00286                 "abs_cont_models",
00287                 "abs_cont_parameters" ),
00288         GIN( "tagname", "model",  "userparameters" ),
00289         GIN_TYPE(    "String",  "String", "Vector" ),
00290         GIN_DEFAULT( NODEF,     NODEF,    NODEF),
00291         GIN_DESC("FIXME DOC",
00292                  "FIXME DOC",
00293                  "FIXME DOC")
00294       ));
00295 
00296   md_data_raw.push_back
00297     ( MdRecord
00298       ( NAME("abs_cont_descriptionInit"),
00299         DESCRIPTION
00300         (
00301          "Initializes the two workspace variables for the continuum description,\n"
00302          "*abs_cont_names* and *abs_cont_parameters*.\n"
00303          " \n"
00304          "This method does not really do anything, except setting the two\n"
00305          "variables to empty Arrays. It is just necessary because the method\n"
00306          "*abs_cont_descriptionAppend* wants to append to the variables.\n"
00307          "   Formally, the continuum description workspace variables are required\n"
00308          "by the absorption calculation methods (e.g., *abs_coefCalc*). Therefore you\n"
00309          "always have to call at least *abs_cont_descriptionInit*, even if you do\n"
00310          "not want to use any continua.\n"
00311         ),
00312         AUTHORS( "Stefan Buehler" ),
00313         OUT( "abs_cont_names", 
00314                 "abs_cont_models",
00315                 "abs_cont_parameters" ),
00316         GOUT(),
00317         GOUT_TYPE(),
00318         GOUT_DESC(),
00319         IN(),
00320         GIN(),
00321         GIN_TYPE(),
00322         GIN_DEFAULT(),
00323         GIN_DESC()
00324       ));
00325 
00326   md_data_raw.push_back
00327     ( MdRecord
00328       ( NAME("abs_h2oSet"),
00329         DESCRIPTION(
00330                     "Sets abs_h2o to the profile of the first tag group containing\n"
00331                     "water.\n" 
00332                     "\n"
00333                     "This is necessary, because for example *abs_coefCalc* requires abs_h2o\n"
00334                     "to contain the water vapour profile(the reason for this is the\n"
00335                     "calculation of oxygen line brodening requires water vapour profile).\n"
00336                     "Then this function can be used to copy the profile of the first tag\n"
00337                     "group of water.\n"
00338                    ),
00339         AUTHORS( "Patrick Eriksson" ),
00340         OUT( "abs_h2o" ),
00341         GOUT(),
00342         GOUT_TYPE(),
00343         GOUT_DESC(),
00344         IN( "abs_species", "abs_vmrs" ),
00345         GIN(),
00346         GIN_TYPE(),
00347         GIN_DEFAULT(),
00348         GIN_DESC()
00349       ));
00350 
00351   md_data_raw.push_back
00352     ( MdRecord
00353       ( NAME("abs_lineshapeDefine"),
00354         DESCRIPTION(
00355                     "Sets the lineshape for all calculated lines.\n"
00356                     "\n"
00357                     "   A general lineshape profile is specified, according to a given  \n"
00358                     "approximation. Alongside a normalization factor is to be set - a \n"
00359                     "multiplicative forefactor through which the profile can be \n"
00360                     "modified. This factor is just the 0th or 1st, or 2nd power of the\n"
00361                     "ratio between the frequency of calculation f and the center frequency\n"
00362                     "for a specific line f0. A cutoff frequency must also be specified in\n"
00363                     "order to restrict the calculation within a desired frequency region or\n"
00364                     "not, when there's no such region.\n"
00365                     "   The general lineshape profile is given by the keyword shape,\n"
00366                     "while the normalization factor and the cutoff frequency by\n"
00367                     "normalizationfactor and cutoff respectively.\n"
00368                     "   We generate only 1 copy of the lineshape settings. Absorption\n"
00369                     "routines check for this case and use it for all species.\n"
00370                     "\n"
00371                     "   The available values for these keywords are given below.\n"
00372                     "shape - \"no_shape\" : no specified shape\n"
00373                     "        \"Doppler\" : Doppler lineshape\n"
00374                     "        \"Lorentz\" : Lorentz lineshape\n"
00375                     "        \"Voigt_Kuntz3\" : Kuntz approximation to the Voigt profile,\n"
00376                     "                         accuracy > 2x10^(-3)\n"
00377                     "        \"Voigt_Kuntz4\" : Kuntz approximation to the Voigt profile,\n"
00378                     "                         accuracy > 2x10^(-4)\n"
00379                     "        \"Voigt_Kuntz6\" : Kuntz approximation to the Voigt profile,\n"
00380                     "                         accuracy > 2x10^(-6)\n"   
00381                     "        \"Voigt_Drayson\" : Drayson approximation to the Voigt profile \n"
00382                     "        \"Rosenkranz_Voigt_Drayson\" : Rosenkrantz oxygen absortion with overlap correction\n" 
00383                     "                                     on the basis of Drayson routine\n"                                    
00384                     "        \"Rosenkranz_Voigt_Kuntz6\" : Rosenkrantz oxygen absortion with overlap correction\n"
00385                     "                                    on the basis of Kuntz routine, accuracy > 2x10^(-6)\n"
00386                     "        \"CO2_Lorentz\" : Lorentz multiplicated with Cousin's chi factors\n"
00387                     "        \"CO2_Drayson\" : Drayson multiplicated with Cousin's chi factors\n"
00388                     "\n"
00389                     "normalizationfactor - \"no_norm\": 1\n"
00390                     "                      \"linear\": f/f0\n" 
00391                     "                      \"quadratic\": (f/f0)^2.\n"
00392                     "                      \"VVH\": (f*tanh(h*f/(2*k*T))) / (f0*tanh(h*f0/(2*k*T))).\n"
00393                     "\n"
00394                     "cutoff - \" -1\" : no cutoff\n"
00395                     "         \"Number\": positive cutoff frequency in Hz.\n"
00396                     "\n"
00397                     "Example usage:\n"
00398                     "shape=[\"Lorentz\"]\n"
00399                     "normalizationfactor=[\"linear\"]\n"
00400                     "cutoff= [650e9]"
00401                     "\n"
00402                     "Keywords:\n"
00403                     "   shape               : The general profile according to an approximation.\n"
00404                     "   normalizationfactor : The multiplicative forefactor for the general profile.\n"
00405                     "   cutoff              : The frequency at which a cutoff can be made.\n" ),
00406         AUTHORS( "Axel von Engeln", "Stefan Buehler" ),
00407         OUT( "abs_lineshape" ),
00408         GOUT(),
00409         GOUT_TYPE(),
00410         GOUT_DESC(),
00411         IN(),
00412         GIN( "shape",  "normalizationfactor", "cutoff" ),
00413         GIN_TYPE(    "String", "String",              "Numeric" ),
00414         GIN_DEFAULT( NODEF,    NODEF,                 NODEF ),
00415         GIN_DESC("FIXME DOC",
00416                  "FIXME DOC",
00417                  "FIXME DOC")
00418       ));
00419 
00420   md_data_raw.push_back
00421     ( MdRecord
00422       ( NAME("abs_lineshape_per_tgDefine"),
00423         DESCRIPTION(
00424                     "Sets the lineshape per tag group for all calculated lines.\n\n"
00425                     "\n" 
00426                     "   A general lineshape profile is specified, according to a given  \n"
00427                     "approximation for each tag group. Alongside a normalization factor\n" 
00428                     "is to be set also for each tag group - a multiplicative forefactor through\n"
00429                     "which the profile can be modified. This factor is just the 0th or 1st,\n"
00430                     "or 2nd power of the ratio between the frequency of calculation f and\n"
00431                     "the center frequency for a specific line f0. A cutoff frequency must also be\n"
00432                     "specified for each of the tags in  order to restrict the calculation within\n" 
00433                     "a desired region or not, when there's no such region.\n"
00434                     "   The general lineshape profile is given by the keyword shape,\n"
00435                     "while the normalization factor and the cutoff frequency by\n"
00436                     "normalizationfactor and cutoff respectively.\n"
00437                     "\n"
00438                     "   The available values for these keywords are given below.\n"
00439                     "shape - \"no_shape\" : no specified shape\n"
00440                     "        \"Doppler\" : Doppler lineshape\n"
00441                     "        \"Lorentz\" : Lorentz lineshape\n"
00442                     "        \"Voigt_Kuntz3\" : Kuntz approximation to the Voigt profile,\n"
00443                     "                        accuracy > 2x10^(-3)\n"
00444                     "        \"Voigt_Kuntz4\" : Kuntz approximation to the Voigt profile,\n"
00445                     "                         accuracy > 2x10^(-4)\n"
00446                     "        \"Voigt_Kuntz6\" : Kuntz approximation to the Voigt profile,\n"
00447                     "                         accuracy > 2x10^(-6)\n"   
00448                     "        \"Voigt_Drayson\" : Drayson approximation to the Voigt profile \n"
00449                     "        \"Rosenkranz_Voigt_Drayson\" : Rosenkrantz oxygen absortion with overlap correction\n" 
00450                     "                                     on the basis of Drayson routine\n"                                    
00451                     "        \"Rosenkranz_Voigt_Kuntz6\" : Rosenkrantz oxygen absortion with overlap correction\n"
00452                     "                                    on the basis of Kuntz routine, accuracy > 2x10^(-6)\n"
00453                     "normalizationfactor - \"no_norm\": 1\n"
00454                     "                      \"linear\": f/f0\n" 
00455                     "                      \"quadratic\": (f/f0)^2.\n"
00456                     "cutoff - \" -1\" : no cutoff\n"
00457                     "           \"Number\": positive cutoff frequency in Hz.\n"
00458                     "\n"
00459                     "Example usage:\n"
00460                     "shape = [\"Lorentz\",\"Voigt_Kuntz6\"] \n"
00461                     "normalizationfactor= [\"linear\", \"quadratic\"] \n"
00462                     "cutoff = [ 650e9, -1 ]"
00463                     "\n"
00464                     "Keywords:\n"
00465                     "   shape               : The general profile according to an approximation.\n"
00466                     "   normalizationfactor : The multiplicative forefactor for the general profile.\n"
00467                     "   cutoff              : The frequency at which a cutoff can be made.\n" ),
00468         AUTHORS( "Axel von Engeln", "Stefan Buehler" ),
00469         OUT( "abs_lineshape" ),
00470         GOUT(),
00471         GOUT_TYPE(),
00472         GOUT_DESC(),
00473         IN( "abs_species" ),
00474         GIN( "shape",        "normalizationfactor", "cutoff" ),
00475         GIN_TYPE(    "ArrayOfString", "ArrayOfString",        "Vector" ),
00476         GIN_DEFAULT( NODEF,          NODEF,                 NODEF ),
00477         GIN_DESC("FIXME DOC",
00478                  "FIXME DOC",
00479                  "FIXME DOC")
00480       ));
00481 
00482   md_data_raw.push_back
00483     ( MdRecord
00484       ( NAME("abs_linesReadFromArts"),
00485         DESCRIPTION(
00486                     "Read all the lines from an Arts catalogue file in the \n"
00487                     "given frequency range. Otherwise a runtime error will be\n"
00488                     "thrown \n"
00489                     "\n"
00490                     "Please note that all lines must correspond\n"
00491                     "to the legal species / isotope combinations\n"
00492                     "\n"
00493                     "Keywords: \n"
00494                     "   filename : Name (and path) of the catalogue file.\n"
00495                     "   fmin     : Minimum frequency for lines to read in Hz.\n"
00496                     "   fmax     : Maximum frequency for lines to read in Hz.\n" ),
00497         AUTHORS( "Stefan Buehler" ),
00498         OUT( "abs_lines" ),
00499         GOUT(),
00500         GOUT_TYPE(),
00501         GOUT_DESC(),
00502         IN(),
00503         GIN( "filename", "fmin",    "fmax" ),
00504         GIN_TYPE(    "String",   "Numeric", "Numeric" ),
00505         GIN_DEFAULT( NODEF,      NODEF,     NODEF ),
00506         GIN_DESC("FIXME DOC",
00507                  "FIXME DOC",
00508                  "FIXME DOC")
00509       ));
00510 
00511   md_data_raw.push_back
00512     ( MdRecord
00513       ( NAME("abs_linesReadFromArtsObsolete"),
00514         DESCRIPTION(
00515                     "Read all the lines from an Arts catalogue file in the \n"
00516                     "given frequency range. Otherwise a runtime error will be\n"
00517                     "thrown \n"
00518                     "\n"
00519                     "Please note that all lines must correspond\n"
00520                     "to the legal species / isotope combinations\n"
00521                     "\n"
00522                     "Keywords: \n"
00523                     "   filename : Name (and path) of the catalogue file.\n"
00524                     "   fmin     : Minimum frequency for lines to read in Hz.\n"
00525                     "   fmax     : Maximum frequency for lines to read in Hz.\n" ),
00526         AUTHORS( "Stefan Buehler" ),
00527         OUT( "abs_lines" ),
00528         GOUT(),
00529         GOUT_TYPE(),
00530         GOUT_DESC(),
00531         IN(),
00532         GIN( "filename", "fmin",    "fmax" ),
00533         GIN_TYPE(    "String",   "Numeric", "Numeric" ),
00534         GIN_DEFAULT( NODEF,      NODEF,     NODEF ),
00535         GIN_DESC("FIXME DOC",
00536                  "FIXME DOC",
00537                  "FIXME DOC")
00538       ));
00539 
00540   md_data_raw.push_back
00541     ( MdRecord
00542       ( NAME("abs_linesReadFromHitran"),
00543         DESCRIPTION
00544         (
00545          "Read all the lines from a HITRAN 1986-2001 catalogue file in\n"
00546          "the given frequency range. Otherwise a runtime error will be\n"
00547          "thrown. For HITRAN 2004 line data use the workspace method \n"
00548          "abs_linesReadFromHitran. \n"
00549          "\n"
00550          "Please note that all lines must correspond to the legal\n"
00551          "species / isotope combinations and that the line data \n"
00552          "file must be sorted by increasing frequency\n"
00553          "\n"
00554          "WWW access of the HITRAN catalog: http://www.hitran.com/\n"
00555          "\n"
00556          "Keywords: \n"
00557          "   filename : Name (and path) of the catalogue file.\n"
00558          "   fmin     : Minimum frequency for lines to read in Hz.\n"
00559          "   fmax     : Maximum frequency for lines to read in Hz.\n" ),
00560         AUTHORS( "Thomas Kuhn" ),
00561         OUT( "abs_lines" ),
00562         GOUT(),
00563         GOUT_TYPE(),
00564         GOUT_DESC(),
00565         IN(),
00566         GIN( "filename",  "fmin",    "fmax" ),
00567         GIN_TYPE(    "String",    "Numeric", "Numeric"),
00568         GIN_DEFAULT( NODEF,       NODEF,     NODEF ),
00569         GIN_DESC("FIXME DOC",
00570                  "FIXME DOC",
00571                  "FIXME DOC")
00572       ));
00573 
00574   md_data_raw.push_back
00575     ( MdRecord
00576       ( NAME("abs_linesReadFromHitran2004"),
00577         DESCRIPTION(
00578                     "Read all the lines from a HITRAN 2004 catalogue file in the \n"
00579                     "given frequency range. Otherwise a runtime error is thrown. \n"
00580                     "\n"
00581                     "Records of molecules unknown to ARTS are ignored but a \n"
00582                     "warning is issued. In particular this happens to CH3OH \n"
00583                     "(HITRAN molecule number 39) because there is no total internal \n"
00584                     "partition sum available. \n"
00585                     "\n"
00586                     "The database must be sorted by increasing frequency!\n"
00587                     "\n"
00588                     "WWW access of the HITRAN catalog: http://www.hitran.com/\n"
00589                     "\n"
00590                     "For data in the Hitran 1986-2001 format use the workspace \n"
00591                     "method: abs_linesReadFromHitran\n"
00592                     "\n"
00593                     "Keywords: \n"
00594                     "   filename : Name (and path) of the catalogue file.\n"
00595                     "   fmin     : Minimum frequency for lines to read in Hz.\n"
00596                     "   fmax     : Maximum frequency for lines to read in Hz.\n" ),
00597         AUTHORS( "Hermann Berg", "Thomas Kuhn" ),
00598         OUT( "abs_lines" ),
00599         GOUT(),
00600         GOUT_TYPE(),
00601         GOUT_DESC(),
00602         IN(),
00603         GIN( "filename",  "fmin",    "fmax" ),
00604         GIN_TYPE( "String", "Numeric", "Numeric" ),
00605         GIN_DEFAULT( NODEF,       NODEF,     NODEF ),
00606         GIN_DESC("FIXME DOC",
00607                  "FIXME DOC",
00608                  "FIXME DOC")
00609       ));
00610 
00611   md_data_raw.push_back
00612     ( MdRecord
00613       ( NAME("abs_linesReadFromJpl"),
00614         DESCRIPTION(
00615                     "Read all the lines from a JPL catalogue file in the \n"
00616                     "given frequency range. Otherwise a runtime error will be\n"
00617                     "thrown\n"
00618                     "\n"
00619                     "Please note that all lines must correspond\n"
00620                     "to the legal species / isotope combinations.\n"
00621                     "\n"
00622                     "WWW access of the JPL catalog: http://spec.jpl.nasa.gov/\n"
00623                     "\n"
00624                     "Keywords: \n"
00625                     "   filename : Name (and path) of the catalogue file.\n"
00626                     "   fmin     : Minimum frequency for lines to read in Hz.\n"
00627                     "   fmax     : Maximum frequency for lines to read in Hz.\n" ),
00628         AUTHORS( "Thomas Kuhn" ),
00629         OUT( "abs_lines" ),
00630         GOUT(),
00631         GOUT_TYPE(),
00632         GOUT_DESC(),
00633         IN(),
00634         GIN( "filename",  "fmin", "fmax" ),
00635         GIN_TYPE( "String", "Numeric", "Numeric" ),
00636         GIN_DEFAULT( NODEF,       NODEF,     NODEF ),
00637         GIN_DESC("FIXME DOC",
00638                  "FIXME DOC",
00639                  "FIXME DOC")
00640       ));
00641 
00642   md_data_raw.push_back
00643     ( MdRecord
00644       ( NAME("abs_linesReadFromMytran2"),
00645         DESCRIPTION(
00646                     "Read all the lines from a MYTRAN2 catalogue file in the \n"
00647                     "given frequency range. Otherwise a runtime error will be\n"
00648                     "thrown\n"
00649                     "\n"
00650                     "Please note that all lines must correspond\n"
00651                     "to the legal species / isotope combinations\n"
00652                     "\n"
00653                     "Keywords: \n"
00654                     "   filename : Name (and path) of the catalogue file.\n"
00655                     "   fmin     : Minimum frequency for lines to read in Hz.\n"
00656                     "   fmax     : Maximum frequency for lines to read in Hz.\n" ),
00657         AUTHORS( "Axel von Engeln", "Stefan Buehler" ),
00658         OUT( "abs_lines" ),
00659         GOUT(),
00660         GOUT_TYPE(),
00661         GOUT_DESC(),
00662         IN(),
00663         GIN( "filename", "fmin", "fmax" ),
00664         GIN_TYPE( "String", "Numeric", "Numeric" ),
00665         GIN_DEFAULT( NODEF,       NODEF,     NODEF ),
00666         GIN_DESC("FIXME DOC",
00667                  "FIXME DOC",
00668                  "FIXME DOC")
00669       ));
00670 
00671   md_data_raw.push_back
00672     ( MdRecord
00673       ( NAME("abs_lines_per_speciesAddMirrorLines"),
00674         DESCRIPTION(
00675                     "Adds mirror lines at negative frequencies to the *abs_lines_per_species*.\n"
00676                     "\n"
00677                     "For each line at frequency +f in *abs_lines_per_species* a corresponding\n"
00678                     "entry at frequency -f is added to *abs_lines_per_species*.The mirror \n"
00679                     "lines are appended to the line lists after the original lines.\n" ),
00680         AUTHORS( "Axel von Engeln", "Stefan Buehler" ),
00681         OUT( "abs_lines_per_species" ),
00682         GOUT(),
00683         GOUT_TYPE(),
00684         GOUT_DESC(),
00685         IN( "abs_lines_per_species" ),
00686         GIN(),
00687         GIN_TYPE(),
00688         GIN_DEFAULT(),
00689         GIN_DESC()
00690       ));
00691 
00692   md_data_raw.push_back
00693     ( MdRecord
00694       ( NAME("abs_lines_per_speciesCompact"),
00695         DESCRIPTION(
00696                     "Removes all lines outside the defined lineshape cutoff frequency\n"
00697                     "from the *abs_lines_per_species*. This can save computation time.\n"
00698                     "It should be particularly useful to call this method after\n"
00699                     "*abs_lines_per_speciesAddMirrorLines*.\n" ),
00700         AUTHORS( "Axel von Engeln", "Stefan Buehler" ),
00701         OUT( "abs_lines_per_species" ),
00702         GOUT(),
00703         GOUT_TYPE(),
00704         GOUT_DESC(),
00705         IN( "abs_lines_per_species", "abs_lineshape", "f_grid" ),
00706         GIN(),
00707         GIN_TYPE(),
00708         GIN_DEFAULT(),
00709         GIN_DESC()
00710       ));
00711 
00712   md_data_raw.push_back
00713     ( MdRecord
00714       ( NAME("abs_lines_per_speciesCreateFromLines"),
00715         DESCRIPTION(
00716                     "Split lines up into the different tag groups.\n"
00717                     "\n"
00718                     "The tag groups are tested in the order in which they are\n" 
00719                     "specified in the controlfile. The lines are assigned to \n"
00720                     "the tag groups in the order as the groups  are specified.\n"
00721                     "That means if you do [\"O3-666\",\"O3\"],the last group O3 \n"
00722                     "gets assigned all the O3 lines that do not fit in the first group.\n" ),
00723         AUTHORS( "Stefan Buehler" ),
00724         OUT( "abs_lines_per_species" ),
00725         GOUT(),
00726         GOUT_TYPE(),
00727         GOUT_DESC(),
00728         IN( "abs_lines", "abs_species" ),
00729         GIN(),
00730         GIN_TYPE(),
00731         GIN_DEFAULT(),
00732         GIN_DESC()
00733       ));
00734 
00735   md_data_raw.push_back
00736     ( MdRecord
00737       ( NAME("abs_lines_per_speciesReadFromCatalogues"),
00738         DESCRIPTION(
00739                     "This method can read lines from different line \n"
00740                     "catalogues.\n"
00741                     "\n"
00742                     "For each tag group, you can specify which catalogue\n"
00743                     "to use. Because the method creates abs_lines_per_species directly,\n"
00744                     "it replaces for example thefollowing two method calls:\n"
00745                     "  - abs_linesReadFromHitran\n"
00746                     "  - abs_lines_per_speciesCreateFromLines\n"
00747                     "   This method needs as input WSVs the list of tag \n"
00748                     "groups. Keyword parameters must specify the names of\n"
00749                     "the catalogue files to use and the matching formats.\n"
00750                     "Names can be anything, formats can currently be \n"
00751                     "HITRAN96 (for HITRAN 1986-2001 databases), HITRAN04 \n"
00752                     "(for HITRAN 2004 database), MYTRAN2, JPL, or ARTS. \n"
00753                     "Furthermore, keyword parameters have to specify minimum \n"
00754                     "and maximum frequency for each tag group. To safe typing, \n"
00755                     "if there are less elements in the keyword parameters than \n"
00756                     "there are tag groups, the last parameters are applied to \n"
00757                     "all following tag groups.\n"
00758                     "\n"
00759                     "Example usage:\n"
00760                     "\n"
00761                     "abs_lines_per_speciesReadFromCatalogues{\n"
00762                     "  filenames = [ \"../data/cat1.dat\", \"../data/cat2.dat\" ]\n"
00763                     "  formats   = [ \"MYTRAN2\",          \"HITRAN96\"         ]\n"
00764                     "  fmin      = [ 0,                  0                  ]\n"
00765                     "  fmax      = [ 2000e9,             100e9              ]\n"
00766                     "}\n"
00767                     "   In this example, lines for the first tag group will\n"
00768                     "be taken from cat1, lines for all other tag groups \n"
00769                     "will be taken from cat2.\n"
00770                     "   This methods allows you for example to use a \n"
00771                     "special line file just for water vapor lines. This\n"
00772                     "could be the  improved water vapor line file \n"
00773                     "generated by Thomas Kuhn.\n"
00774                     "   Catalogues are only read once, even if several tag\n"
00775                     "groups have the same catalogue. However, in that case\n"
00776                     "the frequency ranges MUST be the same. (If you want \n"
00777                     "to do fine-tuning of the frequency ranges, you can do \n"
00778                     "this inside the tag definitions, e.g., \"H2O-*-0-2000e9\".)\n"
00779                     "   This function uses the various reading routines\n"
00780                     "(abs_linesReadFromHitran, etc.), as well as\n"
00781                     "abs_lines_per_speciesCreateFromLines.\n"
00782                     "\n"
00783                     "Keywords: \n"
00784                     "   filenames : Name (and path) of the catalogue files.\n"
00785                     "   formats   : allowed formats are HITRAN96,MYTRAN2,JPL,ARTS \n"
00786                     "   fmin      : Minimum frequency for lines to read in Hz.\n"
00787                     "   fmax      : Maximum frequency for lines to read in Hz.\n" ),
00788         AUTHORS( "Stefan Buehler" ),
00789         OUT( "abs_lines_per_species" ),
00790         GOUT(),
00791         GOUT_TYPE(),
00792         GOUT_DESC(),
00793         IN( "abs_species" ),
00794         GIN( "filenames",    "formats",      "fmin",   "fmax" ),
00795         GIN_TYPE(    "ArrayOfString", "ArrayOfString", "Vector", "Vector" ),
00796         GIN_DEFAULT( NODEF,          NODEF,          NODEF,    NODEF ),
00797         GIN_DESC("FIXME DOC",
00798                  "FIXME DOC",
00799                  "FIXME DOC",
00800                  "FIXME DOC")
00801       ));
00802 
00803   md_data_raw.push_back
00804     ( MdRecord
00805       ( NAME("abs_lines_per_speciesSetEmpty"),
00806         DESCRIPTION
00807         (
00808          "Sets abs_lines_per_species to empty line lists.\n"
00809          "\n"
00810          "You can use this method to set lines per tag if you do not reall want\n"
00811          "to compute line spectra. Formally, abs_coefCalc will still require\n"
00812          "abs_lines_per_species to be set.\n"
00813         ),
00814         AUTHORS( "Stefan Buehler" ),
00815         OUT( "abs_lines_per_species" ),
00816         GOUT(),
00817         GOUT_TYPE(),
00818         GOUT_DESC(),
00819         IN( "abs_species" ),
00820         GIN(),
00821         GIN_TYPE(),
00822         GIN_DEFAULT(),
00823         GIN_DESC()
00824       ));
00825 
00826   // New name: abs_lookupAdapt
00827   md_data_raw.push_back     
00828     ( MdRecord
00829       ( NAME("abs_lookupAdapt"),
00830         DESCRIPTION
00831         (
00832          "Adapts a gas absorption lookup table to the current calculation.\n"
00833          "\n"
00834          "The lookup table can contain more species and more frequencies than\n"
00835          "are needed for the current calculation. This method cuts down the\n"
00836          "table in memory, so that it contains just what is needed. Also, the\n"
00837          "species in the table are brought in the same order as the species in\n"
00838          "the current calculation.\n"
00839          "\n"
00840          "Of course, the method also performs quite a lot of checks on the\n"
00841          "table. If something is not ok, a runtime error is thrown.\n"
00842         ),
00843         AUTHORS( "Stefan Buehler" ),
00844         OUT( "abs_lookup", "abs_lookup_is_adapted" ),
00845         GOUT(),
00846         GOUT_TYPE(),
00847         GOUT_DESC(),
00848         IN(  "abs_lookup", "abs_species", "f_grid" ),
00849         GIN(),
00850         GIN_TYPE(),
00851         GIN_DEFAULT(),
00852         GIN_DESC()
00853       ));
00854 
00855   md_data_raw.push_back     
00856     ( MdRecord
00857       ( NAME("abs_lookupCreate"),
00858         DESCRIPTION
00859         (
00860          "Creates a gas absorption lookup table.\n"
00861          "\n"
00862          "The lookup table stores absorption cross-sections as a function of\n"
00863          "pressure. Additionally, absorption can be stored as a function of\n"
00864          "temperature for temperature perturbations from a reference\n"
00865          "profile. \n"
00866          "\n"
00867          "Additionally, absorption can be stored as a function of water vapor\n"
00868          "VMR perturbations from a reference profile. The variable *abs_nls*\n"
00869          "specifies, for which species water vapor perturbations should be\n"
00870          "generated. \n"
00871          "\n"
00872          "Note, that the absorbing gas can be any gas, but the perturbing gas is\n"
00873          "always H2O.\n"
00874          "\n"
00875          "In contrast to other absorption functions, this method does not use\n"
00876          "the input variable *abs_h2o*. This is because *abs_h2o* has to be set\n"
00877          "interally to allow perturbations. If there are more than one H2O\n"
00878          "species, the first is assumed to be the main one.\n"
00879          ),
00880         AUTHORS( "Stefan Buehler" ),
00881         OUT( "abs_lookup", "abs_lookup_is_adapted" ),
00882         GOUT(),
00883         GOUT_TYPE(),
00884         GOUT_DESC(),
00885         IN( "abs_species", 
00886                "abs_lines_per_species",
00887                "abs_lineshape",
00888                "abs_nls",
00889                "f_grid",
00890                "abs_p",
00891                "abs_vmrs",
00892                "abs_t", 
00893                "abs_t_pert", 
00894                "abs_nls_pert",
00895                "abs_n2",
00896                "abs_cont_names",
00897                "abs_cont_models", 
00898                "abs_cont_parameters"
00899                ),
00900         GIN(),
00901         GIN_TYPE(),
00902         GIN_DEFAULT(),
00903         GIN_DESC()
00904       ));
00905 
00906   // New name: abs_lookupInit
00907   md_data_raw.push_back     
00908     ( MdRecord
00909       ( NAME("abs_lookupInit"),
00910         DESCRIPTION
00911         (
00912          "Creates an empty gas absorption lookup table.\n"
00913          "\n"
00914          "This is mainly there to help developers. For example, you can write\n"
00915          "the empty table to an XML file, to see the file format.\n"
00916         ),
00917         AUTHORS( "Stefan Buehler" ),
00918         OUT( "abs_lookup" ),
00919         GOUT(),
00920         GOUT_TYPE(),
00921         GOUT_DESC(),
00922         IN(),
00923         GIN(),
00924         GIN_TYPE(),
00925         GIN_DEFAULT(),
00926         GIN_DESC()
00927       ));
00928 
00929   md_data_raw.push_back     
00930     ( MdRecord
00931       ( NAME("abs_lookupSetup"),
00932         DESCRIPTION
00933         (
00934          "Set up input parameters for abs_lookupCreate.\n"
00935          "\n"
00936          "More information can be found in the documentation for method\n"
00937          "*abs_lookupSetupBatch*\n"
00938          "\n"
00939          "Max and min values of H2O and temperature are adjusted to allow for\n"
00940          "numerical perturbations in Jacobian calculation.\n"
00941          "\n"
00942          "The input variables *abs_nls_interp_order* and *abs_t_interp_order*\n"
00943          "are used to make sure that there are enough points in *abs_nls_pert*\n"
00944          "and *abs_t_pert* for the chosen interpolation order.\n"
00945          "\n"
00946          "Keywords:\n"
00947          "   p_step   : Maximum step in log10(p[Pa]) (base 10 logarithm). If\n"
00948          "              the pressure grid is coarser than this, additional points\n"
00949          "              are added until each log step is smaller than this.\n"
00950          "              Has a default value.\n"
00951          "   t_step   : The temperature variation grid step in Kelvin, for a 2D\n"
00952          "              or 3D atmosphere. For a 1D atmosphere this parameter is\n"
00953          "              not used. Has a default value.\n"
00954          "   h2o_step : The H2O variation grid step [fractional], if H2O variations are done\n"
00955          "              (which is determined automatically, based on abs_species\n"
00956          "              and the atmospheric dimension). For a 1D atmosphere this parameter is\n"
00957          "              not used. Has a default value.\n"
00958          "\n"
00959          "See also: \n"
00960          "   *abs_lookupSetupBatch*\n"
00961          ),
00962         AUTHORS( "Stefan Buehler" ),
00963         OUT(  "abs_p",
00964                  "abs_t", 
00965                  "abs_t_pert", 
00966                  "abs_vmrs",
00967                  "abs_nls",
00968                  "abs_nls_pert" ),
00969         GOUT(),
00970         GOUT_TYPE(),
00971         GOUT_DESC(),
00972         IN(   "atmosphere_dim",
00973                  "p_grid",
00974                  "lat_grid",
00975                  "lon_grid",
00976                  "t_field",
00977                  "vmr_field",
00978                  "abs_species",
00979                  "abs_p_interp_order",
00980                  "abs_t_interp_order",
00981                  "abs_nls_interp_order" ),
00982         GIN( "p_step",  "t_step",  "h2o_step" ),
00983         GIN_TYPE(    "Numeric", "Numeric", "Numeric" ),
00984         GIN_DEFAULT( "0.05",    "100",       "100" ),
00985         GIN_DESC("FIXME DOC",
00986                  "FIXME DOC",
00987                  "FIXME DOC")
00988       ));
00989 
00990   md_data_raw.push_back     
00991     ( MdRecord
00992       ( NAME("abs_lookupSetupBatch"),
00993         DESCRIPTION
00994         (
00995          "Set up input parameters for abs_lookupCreate for batch calculations.\n"
00996          "\n"
00997          "This method performs a similar task as *abs_lookupSetup*, with the\n"
00998          "difference, that the lookup table setup is not for a single\n"
00999          "atmospheric state, but for a whole batch of them, stored in\n"
01000          "*batch_atm_fields_compact*.\n"
01001          "\n"
01002          "The method checks *abs_species* to decide, which species depend on\n"
01003          "*h2o_abs*, and hence require nonlinear treatment in the lookup table.\n"
01004          "\n"
01005          "The method also checks which range of pressures, temperatures, and\n"
01006          "VMRs occurs, and sets *abs_p*, *abs_t*, *abs_t_pert*, and *abs_vmrs*\n"
01007          "accordingly.\n"
01008          "\n"
01009          "If nonlinear species are present, *abs_nls* and *abs_nls_pert* are also\n"
01010          "generated. \n"
01011          "\n"
01012          "Max and min values of H2O and temperature are adjusted to allow for\n"
01013          "numerical perturbations in Jacobian calculation.\n"
01014          "\n"
01015          "The input variables *abs_nls_interp_order* and *abs_t_interp_order*\n"
01016          "are used to make sure that there are enough points in *abs_nls_pert*\n"
01017          "and *abs_t_pert* for the chosen interpolation order.\n"
01018          "\n"
01019          "Keywords:\n"
01020          "   p_step   : Maximum step in log10(p[Pa]) (base 10 logarithm). If\n"
01021          "              the pressure grid is coarser than this, additional points\n"
01022          "              are added until each log step is smaller than this.\n"
01023          "              Has a default value.\n"
01024          "   t_step   : The temperature variation grid step in Kelvin, for a 2D\n"
01025          "              or 3D atmosphere. For a 1D atmosphere this parameter is\n"
01026          "              not used. Has a default value.\n"
01027          "   h2o_step : The H2O variation grid step [fractional], if H2O variations are done\n"
01028          "              (which is determined automatically, based on abs_species\n"
01029          "                and the atmospheric dimension). For a 1D atmosphere this parameter is\n"
01030          "              not used. Has a default value.\n"
01031          "   extremes : You can give here explicit extreme values to add to\n"
01032          "              abs_t_pert and abs_nls_pert. The order is [t_pert_min,\n"
01033          "              t_pert_max, nls_pert_min, nls_pert_max]. Has a default value of empty.\n"
01034          "See also: \n"
01035          "   *abs_lookupSetup*\n"
01036          ),
01037         AUTHORS( "Stefan Buehler" ),
01038         OUT(  "abs_p",
01039                  "abs_t", 
01040                  "abs_t_pert", 
01041                  "abs_vmrs",
01042                  "abs_nls",
01043                  "abs_nls_pert" ),
01044         GOUT(),
01045         GOUT_TYPE(),
01046         GOUT_DESC(),
01047         IN(   "abs_species",
01048                  "batch_atm_fields_compact",
01049                  "abs_p_interp_order",
01050                  "abs_t_interp_order",
01051                  "abs_nls_interp_order" ),
01052         GIN( "p_step",  "t_step",  "h2o_step", "extremes" ),
01053         GIN_TYPE(    "Numeric", "Numeric", "Numeric",  "Vector" ),
01054         GIN_DEFAULT( "0.05",    "100",       "100",      "[]" ),
01055         GIN_DESC("FIXME DOC",
01056                  "FIXME DOC",
01057                  "FIXME DOC",
01058                  "FIXME DOC")
01059       ));
01060 
01061   md_data_raw.push_back     
01062     ( MdRecord
01063       ( NAME("abs_lookupSetupWide"),
01064         DESCRIPTION
01065         (
01066          "Set up input parameters for abs_lookupCalc for a wide range of\n"
01067          "atmospheric conditions.\n"
01068          "\n"
01069          "This method can be used to set up parameters for a lookup table that\n"
01070          "really covers all reasonable atmospheric conditions.\n"
01071          "\n"
01072          "Reference profiles of T and H2O will be constant, so that the\n"
01073          "different dimensions in the lookup table are actually \"orthogonal\",\n"
01074          "unlike the traditional case where we have pressure dependent reference\n"
01075          "profiles. This makes the table numerically somewhat more robust then\n"
01076          "the traditional ones, and it makes it straightforward to calculate the\n"
01077          "accuracy for the different interpolations with abs_lookupTestAccuracy.\n"
01078          "\n"
01079          "You can give min an max values for the atmospheric conditions. The\n"
01080          "default values are chosen such that they cover all Chevallier data set\n"
01081          "cases, and a bit more. The statistics of the Chevallier data are:\n"
01082          "\n"
01083          "min(p)   / max(p)   [Pa]:  1 / 104960\n"
01084          "min(T)   / max(T)   [K]:   158.21 / 320.39\n"
01085          "min(H2O) / max(H2O) [VMR]: -5.52e-07 / 0.049\n"
01086          "\n"
01087          "p_step is in log10(p[hPa])\n"
01088          "\n"
01089          "FIXME: Explicitly document keywords.\n"
01090          ),
01091         AUTHORS( "Stefan Buehler" ),
01092         OUT(  "abs_p",
01093               "abs_t", 
01094               "abs_t_pert", 
01095               "abs_vmrs",
01096               "abs_nls",
01097               "abs_nls_pert" ),
01098         GOUT(      ),
01099         GOUT_TYPE( ),
01100         GOUT_DESC(),
01101         IN(      "abs_species",
01102                  "abs_p_interp_order",
01103                  "abs_t_interp_order",
01104                  "abs_nls_interp_order" ),
01105         GIN( "p_min",   "p_max",   "p_step",  "t_min",   "t_max",   "h2o_min", "h2o_max" ),
01106         GIN_TYPE(    "Numeric", "Numeric", "Numeric", "Numeric", "Numeric", "Numeric", "Numeric" ),
01107         GIN_DEFAULT( "0.5",  "110000",  "0.05",    "100",     "400",     "0",       "0.1" ),
01108         GIN_DESC("FIXME DOC",
01109                  "FIXME DOC",
01110                  "FIXME DOC",
01111                  "FIXME DOC",
01112                  "FIXME DOC",
01113                  "FIXME DOC",
01114                  "FIXME DOC")
01115       ));
01116   
01117   md_data_raw.push_back     
01118     ( MdRecord
01119       ( NAME("abs_lookupTestAccuracy"),
01120         DESCRIPTION
01121         (
01122          "Test accuracy of absorption lookup table.\n"
01123          "\n"
01124          "Explicitly compare absorption from the lookup table with line-by-line\n"
01125          "calculations for strategically selected conditions (in-between the\n"
01126          "lookup table grid points).\n"
01127          "\n"
01128          "Produces no workspace output, only output to the output streams.\n"
01129          ),
01130         AUTHORS( "Stefan Buehler" ),
01131         OUT(),
01132         GOUT(),
01133         GOUT_TYPE(),
01134         GOUT_DESC(),
01135         IN(   "abs_lookup",
01136               "abs_lookup_is_adapted",
01137               "abs_p_interp_order",
01138               "abs_t_interp_order",
01139               "abs_nls_interp_order",
01140               "abs_n2",
01141               "abs_lines_per_species", 
01142               "abs_lineshape", 
01143               "abs_cont_names", 
01144               "abs_cont_models", 
01145               "abs_cont_parameters" ),
01146         GIN(),
01147         GIN_TYPE(),
01148         GIN_DEFAULT(),
01149         GIN_DESC()
01150       ));
01151 
01152   md_data_raw.push_back
01153     ( MdRecord
01154       ( NAME("abs_n2Set"),
01155         DESCRIPTION(
01156                     "Sets abs_n2 to the profile of the first tag group containing\n"
01157                     "molecular nitrogen. See *abs_h2oSet* for more details.\n"
01158                    ),
01159         AUTHORS( "Patrick Eriksson" ),
01160         OUT( "abs_n2" ),
01161         GOUT(),
01162         GOUT_TYPE(),
01163         GOUT_DESC(),
01164         IN( "abs_species", "abs_vmrs" ),
01165         GIN(),
01166         GIN_TYPE(),
01167         GIN_DEFAULT(),
01168         GIN_DESC()
01169       ));
01170 
01171   md_data_raw.push_back     
01172     ( MdRecord
01173       ( NAME("abs_scalar_gasCalcLBL"),
01174         DESCRIPTION
01175         (
01176          "Calculates scalar gas absorption coefficients line-by-line.\n"
01177          "\n"
01178          "This method can be used inside *abs_scalar_gas_agenda* just like\n"
01179          "*abs_scalar_gasExtractFromLookup*. It is a shortcut for putting in\n"
01180          "some other methods explicitly, namely:\n"
01181          "\n"
01182          "  f_gridSelectFIndex\n"
01183          "  AbsInputFromRteScalars\n"
01184          "  abs_h2oSet\n"
01185          "  abs_coefCalc\n"
01186          "  abs_scalar_gasFromAbsCoef\n"
01187          "\n"
01188          "Actually, all the method does is to call the above four methods.\n"
01189          "\n"
01190          "The calculation is for one specific atmospheric condition, i.e., a set\n"
01191          "of pressure, temperature, and VMR values. It can be either for a\n"
01192          "single frequency (f_index>=0), or for all frequencies (f_index<0). The\n"
01193          "dimension of the output abs_scalar_gas is adjusted accordingly.\n"
01194         ),
01195         AUTHORS( "Stefan Buehler" ),
01196         OUT( "abs_scalar_gas" ),
01197         GOUT(),
01198         GOUT_TYPE(),
01199         GOUT_DESC(),
01200         IN( "f_grid",
01201             "abs_species",
01202             "abs_n2",
01203             "abs_lines_per_species",
01204             "abs_lineshape",
01205             "abs_cont_names",
01206             "abs_cont_models",
01207             "abs_cont_parameters",
01208             "f_index", 
01209             "rte_pressure", "rte_temperature", "rte_vmr_list" ),
01210         GIN(),
01211         GIN_TYPE(),
01212         GIN_DEFAULT(),
01213         GIN_DESC()
01214       ));
01215 
01216   md_data_raw.push_back     
01217     ( MdRecord
01218       ( NAME("abs_scalar_gasExtractFromLookup"),
01219         DESCRIPTION
01220         (
01221          "Extract scalar gas absorption coefficients from lookup table.\n"
01222          "\n"
01223          "This extracts the absorption coefficient for all species in the\n"
01224          "current calculation from the lookup table. Extraction is for one\n"
01225          "specific atmospheric condition, i.e., a set of pressure, temperature,\n"
01226          "and VMR values.\n"
01227          "\n"
01228          "Extraction can be either for a single frequency (f_index>=0), or for\n"
01229          "all frequencies (f_index<0). The dimension of the output\n"
01230          "abs_scalar_gas is adjusted accordingly.\n"
01231          "\n"
01232          "The interpolation order in T and H2O is given by *abs_t_interp_order*\n"
01233          "and *abs_nls_interp_order*, respectively.\n"
01234          "\n"
01235          "See also: *abs_scalar_gasCalcLBL*.\n"
01236         ),
01237         AUTHORS( "Stefan Buehler" ),
01238         OUT( "abs_scalar_gas" ),
01239         GOUT(),
01240         GOUT_TYPE(),
01241         GOUT_DESC(),
01242         IN(  "abs_lookup", "abs_lookup_is_adapted",
01243                 "abs_p_interp_order", "abs_t_interp_order", "abs_nls_interp_order", 
01244                 "f_index", 
01245                 "rte_pressure", "rte_temperature", "rte_vmr_list" ),
01246         GIN(),
01247         GIN_TYPE(),
01248         GIN_DEFAULT(),
01249         GIN_DESC()
01250       ));
01251 
01252   md_data_raw.push_back     
01253     ( MdRecord
01254       ( NAME("abs_scalar_gasFromAbsCoef"),
01255         DESCRIPTION
01256         (
01257          "Copy *abs_scalar_gas* from *abs_coef*. This is handy for putting an\n"
01258          "explicit line-by-line calculation into the\n"
01259          "*abs_scalar_gas_agenda*. See also method *AbsInputFromRteScalars*.\n"
01260         ),
01261         AUTHORS( "Stefan Buehler" ),
01262         OUT( "abs_scalar_gas" ),
01263         GOUT(),
01264         GOUT_TYPE(),
01265         GOUT_DESC(),
01266         IN(  "abs_coef_per_species" ),
01267         GIN(),
01268         GIN_TYPE(),
01269         GIN_DEFAULT(),
01270         GIN_DESC()
01271       ));
01272 
01273   md_data_raw.push_back     
01274     ( MdRecord
01275       ( NAME("abs_fieldCalc"),
01276         DESCRIPTION
01277         (
01278          "Calculate scalar gas absorption for all points in the atmosphere.\n"
01279          "\n"
01280          "This is useful in two different contexts:\n"
01281          "\n"
01282          "1. For testing and plotting gas absorption. (For RT calculations, gas\n"
01283          "absorption is calculated or extracted locally, therefore there is no\n"
01284          "need to calculate a global field. But this method is handy for easy\n"
01285          "plotting of absorption vs. pressure, for example.)\n"
01286          "\n"
01287          "2. Inside the scattering region, monochromatic absorption is\n"
01288          "pre-calculated for the entire atmospheric field.\n"
01289          "\n"
01290          "Because of the different contexts, the method can calculate absorption\n"
01291          "either for all frequencies in the frequency grid (f_index<0), or just\n"
01292          "for the frequency indicated by f_index (f_index>=0).\n"
01293          "\n"
01294          "The calculation itself is performed by the\n"
01295          "*abs_scalar_gas_agenda*.\n"
01296         ),
01297         AUTHORS( "Stefan Buehler" ),
01298         OUT( "abs_field" ),
01299         GOUT(),
01300         GOUT_TYPE(),
01301         GOUT_DESC(),
01302         IN(  "abs_scalar_gas_agenda",
01303                 "f_index",
01304                 "f_grid",
01305                 "atmosphere_dim",
01306                 "p_grid", "lat_grid", "lon_grid",
01307                 "t_field", "vmr_field" ),
01308         GIN(),
01309         GIN_TYPE(),
01310         GIN_DEFAULT(),
01311         GIN_DESC()
01312       ));
01313 
01314   md_data_raw.push_back
01315     ( MdRecord
01316       ( NAME("abs_speciesAdd"),
01317         DESCRIPTION
01318         (
01319          "Adds species tag groups to the list of absorption species.\n"
01320          "\n"
01321          "This WSM is similar to *SpeciesSet*, the only difference is that\n"
01322          "this method appends species to an existing list of absorption species instead\n"
01323          "of creating the whole list.\n"
01324          "\n"
01325          "See *SpeciesSet* for details on how tags are defined and examples of\n"
01326          "how to input them in the control file.\n"
01327          "\n"
01328          "Keywords:\n"
01329          "   species : Specify one String for each tag group that you want to\n"
01330          "             add. Inside the String, separate the tags by commas\n"
01331          "             (plus optional blanks).\n"
01332          ),
01333         AUTHORS( "Stefan Buehler" ),
01334         OUT( "abs_species" ),
01335         GOUT(),
01336         GOUT_TYPE(),
01337         GOUT_DESC(),
01338         IN(  "abs_species" ),
01339         GIN( "species" ),
01340         GIN_TYPE(    "ArrayOfString"   ),
01341         GIN_DEFAULT( NODEF ),
01342         GIN_DESC("FIXME DOC")
01343       ));
01344  
01345   md_data_raw.push_back
01346     ( MdRecord
01347       ( NAME("abs_speciesAdd2"),
01348         DESCRIPTION
01349         (
01350          "Adds a species tag group to the list of absorption species and \n"
01351          "jacobian quantities.\n"
01352          "\n"
01353          "The method is basically a combined call of *abs_speciesAdd* and\n"
01354          "*jacobianAddAbsSpecies*. In this way it is not needed to specify a\n"
01355          "tag group in two different places. \n"
01356          "\n"
01357          "Arguments exactly as for *jacobianAddAbsSpecies*. Note that this\n"
01358          "method only handles a single tag group, in contrast to \n"
01359          "*abs_speciesAdd*\n"
01360          ),
01361         AUTHORS( "Patrick Eriksson" ),
01362         OUT( "abs_species", "jacobian_quantities", "jacobian_agenda" ),
01363         GOUT(),
01364         GOUT_TYPE(),
01365         GOUT_DESC(),
01366         IN( "abs_species", "jacobian", "atmosphere_dim", "p_grid", "lat_grid", 
01367                "lon_grid" ),
01368         GIN(      "gin1"      , "gin2"      , "gin3"      ,
01369                   "species", "method", "unit", "dx" ),
01370         GIN_TYPE(    "Vector", "Vector", "Vector",
01371                   "String", "String", "String", "Numeric" ),
01372         GIN_DEFAULT( NODEF   , NODEF   , NODEF   ,
01373                   NODEF,     NODEF,    NODEF,  NODEF ),
01374         GIN_DESC("FIXME DOC",
01375                  "FIXME DOC",
01376                  "FIXME DOC",
01377                  "FIXME DOC",
01378                  "FIXME DOC",
01379                  "FIXME DOC",
01380                  "FIXME DOC"),
01381         SETMETHOD(      false ),
01382         AGENDAMETHOD(   false  ),
01383         SUPPRESSHEADER( false ),
01384         PASSWORKSPACE(  true )
01385       ));
01386  
01387   md_data_raw.push_back
01388     ( MdRecord
01389       ( NAME("abs_speciesDefineAllInScenario"),
01390         DESCRIPTION
01391         (
01392          "Define one tag group for each species known to ARTS and included in an\n"
01393          "atmospheric scenario.\n"
01394          "\n"
01395          "You can use this as an alternative to tgsDefine if you want to make an\n"
01396          "absorption calculation that is as complete as possible. The method\n"
01397          "goes through all defined species and tries to open the VMR file. If\n"
01398          "this works the tag is included, otherwise it is skipped.\n"
01399          "\n"
01400          "Keywords:\n"
01401          "   basename : The name and path of a particular atmospheric scenario.\n"
01402          "              For example: /pool/lookup2/arts-data/atmosphere/fascod/tropical\n"
01403         ),
01404         AUTHORS( "Stefan Buehler" ),
01405         OUT( "abs_species" ),
01406         GOUT(),
01407         GOUT_TYPE(),
01408         GOUT_DESC(),
01409         IN(),
01410         GIN( "basename" ),
01411         GIN_TYPE( "String" ),
01412         GIN_DEFAULT( NODEF ),
01413         GIN_DESC("FIXME DOC")
01414       ));
01415 
01416   md_data_raw.push_back
01417     ( MdRecord
01418       ( NAME("abs_speciesInit"),
01419         DESCRIPTION
01420         (
01421          "Sets  *abs_speciesSet* to be empty.\n"
01422          ),
01423         AUTHORS( "Stefan Buehler" ),
01424         OUT( "abs_species" ),
01425         GOUT(),
01426         GOUT_TYPE(),
01427         GOUT_DESC(),
01428         IN(),
01429         GIN(),
01430         GIN_TYPE(),
01431         GIN_DEFAULT(),
01432         GIN_DESC()
01433       ));
01434 
01435   // This is duplicate with the 1-0 method tgsDefine. Merge!
01436   md_data_raw.push_back
01437     ( MdRecord
01438       ( NAME("SpeciesSet"),
01439         DESCRIPTION
01440         (
01441          "Set up a list of absorption species tag groups.\n"
01442          "\n"
01443          "Workspace variables like *abs_species* contain several tag\n"
01444          "groups. Each tag group contains one or more tags. This method converts\n"
01445          "descriptions of tag groups given in the keyword to the ARTS internal\n"
01446          "representation (an *ArrayOfArrayOfSpeciesTag*). A tag group selects\n"
01447          "spectral features which belong to the same species.\n"
01448          "\n"
01449          "A tag is defined in terms of the name of the species, isotope, and a\n"
01450          "range of frequencies. Species are named after the standard chemical\n"
01451          "names, e.g., \"O3\".  Isotopes are given by the last digit of the atomic\n"
01452          "weight, i.g., \"O3-668\" for the asymmetric ozone molecule including an\n"
01453          "oxygen 18 atom. Groups of transitions are specified by giving a lower\n"
01454          "and upper limit of a frequency range, e.g., \"O3-666-500e9-501e9\".\n"
01455          "\n"
01456          "The symbol \"*\" acts as a wild card. Furthermore, frequency range or\n"
01457          "frequency range and isotope may be omitted.\n"
01458          "\n"
01459          "Finally, instead of the isotope the special letter \"nl\" may be given,\n"
01460          "e.g., \"H2O-nl\". This means that no absorption at all is associated\n"
01461          "with this tag. (It is not quite clear if this feature is useful for\n"
01462          "anything right now.)\n"
01463          "\n"
01464          "This method used to be a specific method for *abs_species*. Now it is\n"
01465          "generic, so that it can also be used to set *abs_nls* and *abs_pts*.\n"
01466          "\n"
01467          "Generic Output:\n"
01468          "   ArrayOfArrayOfSpeciesTag : Output tag groups.\n"
01469          "\n"
01470          "Keywords:\n"
01471          "   species : Specify one String for each tag group that you want to\n"
01472          "             create. Inside the String, separate the tags by commas\n"
01473          "             (plus optional blanks).\n"
01474          "\n"
01475          "Example:\n"
01476          "\n"
01477          "   species = [ \"O3-666-500e9-501e9, O3-686\",\n"
01478          "               \"O3\",\n"
01479          "               \"H2O-PWR98\" ]\n"
01480          "\n"
01481          "   The first tag group selects all O3-666 lines between 500 and\n"
01482          "   501 GHz plus all O3-686 lines.  \n"
01483          "\n"
01484          "   The second tag group selects all remaining O3 transitions.\n"
01485          "\n"
01486          "   The third tag group selects H2O, with one of the complete\n"
01487          "   absorption models (Rosenkranz 98). No spectrocopic line catalogue\n"
01488          "   data will be used for that third tag group.\n"
01489          ),
01490         AUTHORS( "Stefan Buehler" ),
01491         OUT(),
01492         GOUT(       "gout1"                         ),
01493         GOUT_TYPE(  "ArrayOfArrayOfSpeciesTag" ),
01494         GOUT_DESC("FIXME DOC"),
01495         IN(),
01496         GIN( "species" ),
01497         GIN_TYPE(    "ArrayOfString"   ),
01498         GIN_DEFAULT( NODEF ),
01499         GIN_DESC("FIXME DOC")
01500       ));
01501 
01502   md_data_raw.push_back
01503     ( MdRecord
01504       ( NAME("abs_vecAddGas"),
01505         DESCRIPTION
01506         (
01507          "Add gas absorption to first element of absorption vector.\n"
01508          "\n"
01509          "The task of this method is to sum up the gas absorption of the\n"
01510          "different gas species and add the result to the first element of the\n"
01511          "absorption vector.\n"
01512          ),
01513         AUTHORS( "Stefan Buehler" ),
01514         OUT("abs_vec"),
01515         GOUT(),
01516         GOUT_TYPE(),
01517         GOUT_DESC(),
01518         IN("abs_vec", "abs_scalar_gas"),
01519         GIN(),
01520         GIN_TYPE(),
01521         GIN_DEFAULT(),
01522         GIN_DESC()
01523       ));
01524 
01525   md_data_raw.push_back
01526     ( MdRecord
01527       ( NAME("abs_vecAddPart"),
01528         DESCRIPTION
01529         (
01530          "The particle absorption is added to *abs_vec* \n"
01531          "\n"
01532          "This function sums up the absorption vectors for all particle \n"
01533          "types weighted with particle number density.\n"
01534          "The resluling absorption vector is added to the workspace \n"
01535          "variable *abs_vec* \n"
01536          "Output and input of this method is *abs_vec* (stokes_dim).\n"
01537          "The inputs are the absorption vector for the single particle type \n"
01538          "*abs_vec_spt* (part_types, stokes_dim) and the local particle\n"
01539          " number densities for all particle types namely the \n"
01540          "*pnd_field* (part_types, p_grid, lat_grid, lon_grid, ) for given \n"
01541          "*p_grid*, *lat_grid*, and *lon_grid*. The particle types required \n"
01542          "are specified in the control file.\n"
01543          ),
01544         AUTHORS( "Sreerekha T.R." ),
01545         OUT("abs_vec"),
01546         GOUT(),
01547         GOUT_TYPE(),
01548         GOUT_DESC(),
01549         IN("abs_vec", "abs_vec_spt", "pnd_field", "atmosphere_dim",
01550               "scat_p_index",  "scat_lat_index", "scat_lon_index"),
01551         GIN(),
01552         GIN_TYPE(),
01553         GIN_DEFAULT(),
01554         GIN_DESC()
01555       ));
01556 
01557   md_data_raw.push_back
01558     ( MdRecord
01559       ( NAME("abs_vecInit"),
01560         DESCRIPTION
01561         (
01562          "Initialize absorption vector.\n"
01563          "\n"
01564          "This method is necessary, because all other absorption methods just\n"
01565          "add to the existing absorption vector.\n"
01566          "\n"
01567          "So, here we have to make it the right size and fill it with 0.\n"
01568          "\n"
01569          "Note, that the vector is not really a vector, because it has a\n"
01570          "leading frequency dimension.\n"
01571         ),
01572         AUTHORS( "Stefan Buehler" ),
01573         OUT("abs_vec"),
01574         GOUT(),
01575         GOUT_TYPE(),
01576         GOUT_DESC(),
01577         IN("f_grid", "stokes_dim", "f_index"),
01578         GIN(),
01579         GIN_TYPE(),
01580         GIN_DEFAULT(),
01581         GIN_DESC()
01582       ));
01583 
01584   md_data_raw.push_back
01585     ( MdRecord
01586       ( NAME("abs_xsec_per_speciesAddConts"),
01587         DESCRIPTION(
01588                     "Calculate absorption cross sections per tag group for continua.\n"
01589                    ),
01590         AUTHORS( "Stefan Buehler" ),
01591         OUT( "abs_xsec_per_species" ),
01592         GOUT(),
01593         GOUT_TYPE(),
01594         GOUT_DESC(),
01595         IN( "abs_species", "f_grid", "abs_p", "abs_t", "abs_n2", "abs_h2o",
01596                "abs_vmrs", "abs_cont_names", "abs_cont_parameters",
01597                "abs_cont_models" ),
01598         GIN(),
01599         GIN_TYPE(),
01600         GIN_DEFAULT(),
01601         GIN_DESC()
01602       ));
01603 
01604   md_data_raw.push_back
01605     ( MdRecord
01606       ( NAME("abs_xsec_per_speciesAddLines"),
01607         DESCRIPTION(
01608                     "Calculates the line spectrum for each tag group and adds\n"
01609                     "it to abs_xsec_per_species.\n"
01610                    ),
01611         AUTHORS( "Stefan Buehler", "Axel von Engeln" ),
01612         OUT( "abs_xsec_per_species" ),
01613         GOUT(),
01614         GOUT_TYPE(),
01615         GOUT_DESC(),
01616         IN( "abs_species", "f_grid", "abs_p", "abs_t", "abs_h2o",
01617                "abs_vmrs", "abs_lines_per_species", "abs_lineshape" ),
01618         GIN(),
01619         GIN_TYPE(),
01620         GIN_DEFAULT(),
01621         GIN_DESC()
01622       ));
01623 
01624   md_data_raw.push_back
01625     ( MdRecord
01626       ( NAME( "abs_xsec_per_speciesInit" ),
01627         DESCRIPTION(
01628                     "Initialize *abs_xsec_per_species*.\n"
01629                     "\n"
01630                     "The initialization is\n"
01631                     "necessary, because methods *abs_xsec_per_speciesAddLines*\n"
01632                     "and *abs_xsec_per_speciesAddConts* just add to *abs_xsec_per_species*.\n"
01633                     "The size is determined from *tgs*.\n"
01634                    ),
01635         AUTHORS( "Stefan Buehler" ),
01636         OUT( "abs_xsec_per_species" ),
01637         GOUT(),
01638         GOUT_TYPE(),
01639         GOUT_DESC(),
01640         IN( "abs_species", "f_grid", "abs_p" ),
01641         GIN(),
01642         GIN_TYPE(),
01643         GIN_DEFAULT(),
01644         GIN_DESC()
01645       ));
01646 
01647   md_data_raw.push_back
01648     ( MdRecord
01649       ( NAME("AgendaExecute"),
01650         DESCRIPTION
01651         ( 
01652          "Execute an agenda.\n"
01653          "\n"
01654          "Generic input:\n"
01655          "   Agenda : The agenda.\n"
01656         ),
01657         AUTHORS( "Oliver Lemke" ),
01658         OUT(),
01659         GOUT(),
01660         GOUT_TYPE(),
01661         GOUT_DESC(),
01662         IN(),
01663         GIN(      "gin1"       ),
01664         GIN_TYPE(    "Agenda" ),
01665         GIN_DEFAULT( NODEF    ),
01666         GIN_DESC("FIXME DOC"),
01667         SETMETHOD(    false ),
01668         AGENDAMETHOD( false )
01669       ));
01670       
01671   md_data_raw.push_back
01672     ( MdRecord
01673       ( NAME("AgendaAppend"),
01674         DESCRIPTION
01675         ( 
01676          "Append methods to an agenda.\n"
01677          "\n"
01678          "An agenda is used to store a list of methods that are meant to be\n"
01679          "executed sequentially.\n"
01680          "\n"
01681          "This method takes the methods given in the body (in the curly braces)\n"
01682          "and appends them to the agenda given by the output argument (in the round\n"
01683          "braces).\n"
01684          "\n"
01685          "It also uses the agenda lookup data (defined in file agendas.cc) to\n"
01686          "check, whether the given methods use the right input WSVs and produce\n"
01687          "the right output WSVs.\n"
01688         ),
01689         AUTHORS( "Oliver Lemke" ),
01690         OUT(),
01691         GOUT(      "gout1"       ),
01692         GOUT_TYPE( "Agenda" ),
01693         GOUT_DESC("FIXME DOC"),
01694         IN(),
01695         GIN(      "gin1"       ),
01696         GIN_TYPE( "Agenda" ),
01697         GIN_DEFAULT( NODEF ),
01698         GIN_DESC( "Agenda to append to." ),
01699         SETMETHOD(      false ),
01700         AGENDAMETHOD(   true  ),
01701         SUPPRESSHEADER( false ),
01702         PASSWORKSPACE(  false ),
01703         PASSWSVNAMES(   true  )
01704       ));
01705 
01706   md_data_raw.push_back
01707     ( MdRecord
01708       ( NAME("AgendaSet"),
01709         DESCRIPTION
01710         ( 
01711          "Set up an agenda.\n"
01712          "\n"
01713          "An agenda is used to store a list of methods that are meant to be\n"
01714          "executed sequentially.\n"
01715          "\n"
01716          "This method takes the methods given in the body (in the curly braces)\n"
01717          "and puts them in the agenda given by the output argument (in the round\n"
01718          "braces).\n"
01719          "\n"
01720          "It also uses the agenda lookup data (defined in file agendas.cc) to\n"
01721          "check, whether the given methods use the right input WSVs and produce\n"
01722          "the right output WSVs.\n"
01723          " \n"
01724          "Generic output:\n"
01725          "   Agenda : The new agenda.\n"
01726          "\n"
01727          "Keywords:\n"
01728          "   No keywords, but other methods can appear in the method body.\n"
01729         ),
01730         AUTHORS( "Oliver Lemke" ),
01731         OUT(),
01732         GOUT(      "gout1"       ),
01733         GOUT_TYPE( "Agenda" ),
01734         GOUT_DESC("FIXME DOC"),
01735         IN(),
01736         GIN(),
01737         GIN_TYPE(),
01738         GIN_DEFAULT(),
01739         GIN_DESC(),
01740         SETMETHOD(      false ),
01741         AGENDAMETHOD(   true  ),
01742         SUPPRESSHEADER( false ),
01743         PASSWORKSPACE(  false ),
01744         PASSWSVNAMES(   true  )
01745       ));
01746 
01747   md_data_raw.push_back
01748     ( MdRecord
01749       ( NAME("AntennaOff"),
01750         DESCRIPTION
01751         (
01752          "Sets some antenna related variables\n"
01753          "\n"
01754          "Use this method to set *antenna_dim*, *mblock_za_grid* and\n"
01755          "*mblock_aa_grid* to suitable values (1, [0] and [], respectively)\n"
01756          "for cases when a sensor is included, but the antenna pattern is\n"
01757          "neglected.\n"
01758         ),
01759         AUTHORS( "Patrick Eriksson" ),
01760         OUT( "antenna_dim", "mblock_za_grid", "mblock_aa_grid" ),
01761         GOUT(),
01762         GOUT_TYPE(),
01763         GOUT_DESC(),
01764         IN(),
01765         GIN(),
01766         GIN_TYPE(),
01767         GIN_DEFAULT(),
01768         GIN_DESC()
01769       ));
01770 
01771   md_data_raw.push_back
01772     ( MdRecord
01773       ( NAME("AntennaSet1D"),
01774         DESCRIPTION
01775         (
01776          "Sets the antenna dimension to 1D.\n"
01777          "\n"
01778          "Sets *antenna_dim* to 1 and sets *mblock_aa_grid* to be empty.\n"
01779         ),
01780         AUTHORS( "Patrick Eriksson" ),
01781         OUT( "antenna_dim", "mblock_aa_grid" ),
01782         GOUT(),
01783         GOUT_TYPE(),
01784         GOUT_DESC(),
01785         IN(),
01786         GIN(),
01787         GIN_TYPE(),
01788         GIN_DEFAULT(),
01789         GIN_DESC()
01790       ));
01791 
01792   md_data_raw.push_back
01793     ( MdRecord
01794       ( NAME("AntennaSet2D"),
01795         DESCRIPTION
01796         (
01797          "Sets the antenna dimension to 2D.\n"
01798          "\n"
01799          "Sets *antenna_dim* to 2.\n"
01800          "\n"
01801          "It is only allowed to set *antenna_dim* to 2 when *atmosphere_dim*\n"
01802          "equals 3.\n"
01803         ),
01804         AUTHORS( "Patrick Eriksson" ),
01805         OUT( "antenna_dim" ),
01806         GOUT(),
01807         GOUT_TYPE(),
01808         GOUT_DESC(),
01809         IN( "atmosphere_dim" ),
01810         GIN(),
01811         GIN_TYPE(),
01812         GIN_DEFAULT(),
01813         GIN_DESC()
01814       ));
01815 
01816   md_data_raw.push_back
01817     ( MdRecord
01818       ( NAME("Append"),
01819         DESCRIPTION
01820         (
01821          "Append a workspace variable to another workspace variable.\n"
01822          "\n"
01823          "This is a supergeneric method. It can append a workspace variable\n"
01824          "to another workspace variable of the same group. (E.g., a Matrix to\n"
01825          "another Matrix.)\n"
01826          "\n"
01827          "This method is not implemented for all types, just for those where an\n"
01828          "append makes sense. (See variable list below.).\n"         
01829          "\n"
01830          "As allways, output comes first in the argument list!\n"
01831          ),
01832         AUTHORS( "Stefan Buehler" ),
01833         OUT(),
01834         GOUT(      "out"    ),
01835         GOUT_TYPE( ARRAY_GROUPS + ", Vector" + ", String"),
01836         GOUT_DESC("The variable to append to."),
01837         IN(),
01838         GIN(      "in"    ),
01839         GIN_TYPE(  ARRAY_GROUPS + ", Vector" + ", String"),
01840         GIN_DEFAULT( NODEF ),
01841         GIN_DESC("The variable to append."),
01842         SETMETHOD(      false ),
01843         AGENDAMETHOD(   false ),
01844         SUPPRESSHEADER( true  )
01845       ));
01846 
01847   md_data_raw.push_back
01848     ( MdRecord
01849       ( NAME( "ArrayOfGField1Create" ),
01850         DESCRIPTION
01851         (
01852          "Creates an empty ArrayOfGField1.\n"
01853          "\n"
01854          "If the variable already exists, it'll be reset.\n"
01855         ),
01856         AUTHORS( "Oliver Lemke" ),
01857         OUT(),
01858         GOUT(      "arrayofgfield1"       ),
01859         GOUT_TYPE( "ArrayOfGField1" ),
01860         GOUT_DESC("FIXME DOC"),
01861         IN(),
01862         GIN(),
01863         GIN_TYPE(),
01864         GIN_DEFAULT(),
01865         GIN_DESC()
01866       ));
01867 
01868   md_data_raw.push_back
01869     ( MdRecord
01870       ( NAME( "ArrayOfIndexCreate" ),
01871         DESCRIPTION
01872         (
01873          "Creates an empty ArrayOfIndex.\n"
01874          "\n"
01875          "If the variable already exists, it'll be reset.\n"
01876         ),
01877         AUTHORS( "Oliver Lemke" ),
01878         OUT(),
01879         GOUT(      "arrayofindex"       ),
01880         GOUT_TYPE( "ArrayOfIndex" ),
01881         GOUT_DESC("FIXME DOC"),
01882         IN(),
01883         GIN(),
01884         GIN_TYPE(),
01885         GIN_DEFAULT(),
01886         GIN_DESC()
01887       ));
01888 
01889   md_data_raw.push_back
01890     ( MdRecord
01891       ( NAME("ArrayOfIndexSet"),
01892         DESCRIPTION
01893         (
01894          "Create an ArrayOfIndex from the given list of numbers.\n"
01895         ),
01896         AUTHORS( "Oliver Lemke" ),
01897         OUT(),
01898         GOUT(      "arrayofindex"       ),
01899         GOUT_TYPE( "ArrayOfIndex" ),
01900         GOUT_DESC("FIXME DOC"),
01901         IN(),
01902         GIN(         "values" ),
01903         GIN_TYPE(    "ArrayOfIndex" ),
01904         GIN_DEFAULT( NODEF ),
01905         GIN_DESC("FIXME DOC"),
01906         SETMETHOD( true )
01907       ));
01908 
01909   md_data_raw.push_back
01910     ( MdRecord
01911       ( NAME( "ArrayOfLineRecordCreate" ),
01912         DESCRIPTION
01913         (
01914          "Creates an empty ArrayOfLineRecord.\n"
01915          "\n"
01916          "If the variable already exists, it will be reset.\n"
01917          "\n"
01918          "Generic output: \n"
01919          "   ArrayOfLineRecord: New empty ArrayOfLineRecord.\n"
01920         ),
01921         AUTHORS( "Oliver Lemke" ),
01922         OUT(),
01923         GOUT(      "gout1"                  ),
01924         GOUT_TYPE( "ArrayOfLineRecord" ),
01925         GOUT_DESC("FIXME DOC"),
01926         IN(),
01927         GIN(),
01928         GIN_TYPE(),
01929         GIN_DEFAULT(),
01930         GIN_DESC()
01931       ));
01932 
01933   md_data_raw.push_back
01934     ( MdRecord
01935       ( NAME( "ArrayOfLineshapeSpecCreate" ),
01936         DESCRIPTION
01937         (
01938          "Creates an empty ArrayOfLineshapeSpec.\n"
01939          "\n"
01940          "If the variable already exists, it will be reset.\n"
01941          "\n"
01942          "Generic output: \n"
01943          "   ArrayOfLineshapeSpec: New empty ArrayOfLineshapeSpec.\n"
01944         ),
01945         AUTHORS( "Oliver Lemke" ),
01946         OUT(),
01947         GOUT(      "gout1"                     ),
01948         GOUT_TYPE( "ArrayOfLineshapeSpec" ),
01949         GOUT_DESC("FIXME DOC"),
01950         IN(),
01951         GIN(),
01952         GIN_TYPE(),
01953         GIN_DEFAULT(),
01954         GIN_DESC()
01955       ));
01956 
01957   md_data_raw.push_back
01958     ( MdRecord
01959       ( NAME( "ArrayOfMatrixCreate" ),
01960         DESCRIPTION
01961         (
01962          "Creates an empty ArrayOfMatrix.\n"
01963          "\n"
01964          "If the variable already exists, it will be reset.\n"
01965          "\n"
01966          "Generic output: \n"
01967          "   ArrayOfMatrix: New empty ArrayOfMatrix.\n"
01968         ),
01969         AUTHORS( "Oliver Lemke" ),
01970         OUT(),
01971         GOUT(      "gout1"              ),
01972         GOUT_TYPE( "ArrayOfMatrix" ),
01973         GOUT_DESC("FIXME DOC"),
01974         IN(),
01975         GIN(),
01976         GIN_TYPE(),
01977         GIN_DEFAULT(),
01978         GIN_DESC()
01979       ));
01980 
01981   md_data_raw.push_back
01982     ( MdRecord
01983       ( NAME("ArrayOfMatrixInsert"),
01984         DESCRIPTION
01985         (
01986          "Inserts a Matrix in an ArrayOfMatrix.\n"
01987          "\n"
01988          "The keyword can be used to chose which element will be set, If a\n"
01989          "negative number is given, the matrix will be appended to the array.\n"
01990          "Note that zero-based indexing is used.\n"
01991          "\n"
01992          "Generic output:\n"
01993          "  ArrayOfMatrix : The new array.\n"
01994          "\n"
01995          "Generic input:\n"
01996          "  ArrayOfMatrix : The original array.\n"
01997          "         Matrix : The matrix to insert.\n"
01998          "Keywords:\n"
01999          "        element : The index to be set.\n"
02000         ),
02001         AUTHORS( "Mattias Ekstrom" ),
02002         OUT(),
02003         GOUT(      "gout1"              ),
02004         GOUT_TYPE( "ArrayOfMatrix" ),
02005         GOUT_DESC("FIXME DOC"),
02006         IN(),
02007         GIN(      "gin1"             , "gin2"      ,
02008                   "element" ),
02009         GIN_TYPE(    "ArrayOfMatrix", "Matrix",
02010                   "Index" ),
02011         GIN_DEFAULT( NODEF          , NODEF   ,
02012                   NODEF ),
02013         GIN_DESC("FIXME DOC",
02014                  "FIXME DOC",
02015                  "FIXME DOC")
02016       ));
02017 
02018   md_data_raw.push_back
02019     ( MdRecord
02020       ( NAME( "ArrayOfStringCreate" ),
02021         DESCRIPTION
02022         (
02023          "Creates an empty ArrayOfString.\n"
02024          "\n"
02025          "If the variable already exists, it'll be reset.\n"
02026          "\n"
02027          "Generic output: \n"
02028          "   ArrayOfString: New empty ArrayOfString.\n"
02029         ),
02030         AUTHORS( "Oliver Lemke" ),
02031         OUT(),
02032         GOUT(      "gout1"              ),
02033         GOUT_TYPE( "ArrayOfString" ),
02034         GOUT_DESC("FIXME DOC"),
02035         IN(),
02036         GIN(),
02037         GIN_TYPE(),
02038         GIN_DEFAULT(),
02039         GIN_DESC()
02040       ));
02041 
02042   md_data_raw.push_back
02043     ( MdRecord
02044       ( NAME("ArrayOfStringSet"),
02045         DESCRIPTION
02046         (
02047          "Sets a String array according the given text.\n"
02048          "The format is text = [\"String1\",\"String2\",...]\n"
02049         ),
02050         AUTHORS( "Patrick Eriksson" ),
02051         OUT(),
02052         GOUT(      "gout1"              ),
02053         GOUT_TYPE( "ArrayOfString" ),
02054         GOUT_DESC("FIXME DOC"),
02055         IN(),
02056         GIN( "text" ),
02057         GIN_TYPE(    "ArrayOfString" ),
02058         GIN_DEFAULT( NODEF ),
02059         GIN_DESC("FIXME DOC"),
02060         SETMETHOD( true )
02061       ));
02062 
02063   md_data_raw.push_back
02064     ( MdRecord
02065       ( NAME( "ArrayOfVectorCreate" ),
02066         DESCRIPTION
02067         (
02068          "Creates an empty ArrayOfVector.\n"
02069          "\n"
02070          "If the variable already exists, it'll be reset.\n"
02071         ),
02072         AUTHORS( "Oliver Lemke" ),
02073         OUT(),
02074         GOUT(      "arrayofvector"       ),
02075         GOUT_TYPE( "ArrayOfVector" ),
02076         GOUT_DESC("FIXME DOC"),
02077         IN(),
02078         GIN(),
02079         GIN_TYPE(),
02080         GIN_DEFAULT(),
02081         GIN_DESC()
02082       ));
02083 
02084   md_data_raw.push_back
02085     ( MdRecord
02086       ( NAME("Arts"),
02087         DESCRIPTION
02088         ( 
02089          "Run the agenda that is specified inside the curly braces. ARTS\n"
02090          "controlfiles must define this method. It is executed automatically\n"
02091          "when ARTS is run on the controlfile.\n" 
02092         ),
02093         AUTHORS( "Stefan Buehler" ),
02094         OUT(),
02095         GOUT(),
02096         GOUT_TYPE(),
02097         GOUT_DESC(),
02098         IN(),
02099         GIN(),
02100         GIN_TYPE(),
02101         GIN_DEFAULT(),
02102         GIN_DESC(),
02103         SETMETHOD(    false ),
02104         AGENDAMETHOD( true  )
02105       ));
02106 
02107   md_data_raw.push_back
02108     ( MdRecord
02109       ( NAME("AtmFieldsCalc"),
02110         DESCRIPTION
02111         (
02112          "Interpolate the atmospheric fields.\n"
02113          "\n"
02114          "An atmospheric scenario includes the following data for each \n"
02115          "position (pressure, latitude, longitude) in the atmosphere: \n"
02116          "           1. temperature field \n"
02117          "           2. the corresponding altitude field \n"
02118          "           3. vmr fields for the gaseous species \n"
02119          "This method interpolates the fields from the raw data\n"
02120          "(*t_field_raw*, *z_field_raw*) which can be stored on \n"
02121          "arbitrary grids on the grids for the calculation\n"
02122          "(*p_grid*, *lat_grid*, *lon_grid*).\n"
02123         ),
02124         AUTHORS( "Claudia Emde" ),
02125         OUT("t_field", "z_field", "vmr_field"),
02126         GOUT(),
02127         GOUT_TYPE(),
02128         GOUT_DESC(),
02129         IN("p_grid", "lat_grid", "lon_grid", "t_field_raw", "z_field_raw", 
02130               "vmr_field_raw", "atmosphere_dim"),
02131         GIN(),
02132         GIN_TYPE(),
02133         GIN_DEFAULT(),
02134         GIN_DESC()
02135       ));
02136 
02137   md_data_raw.push_back
02138     ( MdRecord
02139       ( NAME("AtmFieldsCalcExpand1D"),
02140         DESCRIPTION
02141         (
02142          "Interpolate 1D raw atmospheric fields to create 2D or 3D \n"
02143          "homogeneous atmospheric fields.\n"
02144          "\n"
02145          "The method works as *AtmFieldsCalc* but accepts only raw 1D\n"
02146          "atmospheres. The raw atmosphere is interpolated to *p_grid* and \n"
02147          "the obtained values are applied for all latitudes, and also \n"
02148          "longitudes for 3D, to create a homogeneous atmosphere. \n"
02149          "\n"
02150          "The method deals only with the atmospheric fields, and to create\n"
02151          "a true 2D or 3D version of a 1D case, a demand is also that the\n"
02152          "geoid radius is set to be constant for all latitudes/longitudes.\n"
02153         ),
02154         AUTHORS( "Patrick Eriksson", "Claudia Emde" ),
02155         OUT( "t_field", "z_field", "vmr_field" ),
02156         GOUT(),
02157         GOUT_TYPE(),
02158         GOUT_DESC(),
02159         IN( "p_grid", "lat_grid", "lon_grid", "t_field_raw", "z_field_raw", 
02160                "vmr_field_raw", "atmosphere_dim"),
02161         GIN(),
02162         GIN_TYPE(),
02163         GIN_DEFAULT(),
02164         GIN_DESC()
02165       ));
02166 
02167   md_data_raw.push_back
02168     ( MdRecord
02169       ( NAME("AtmFieldsRefinePgrid"),
02170         DESCRIPTION
02171         (
02172          "Refine the pressure grid in the atmospheric fields.\n"
02173          "\n"
02174          "This method is used for absorption lookup table testing. It probably\n"
02175          "has no other application.\n"
02176          "\n"
02177          "It adds additional vertical grid points to the atmospheric fields, by\n"
02178          "interpolating them in the usual ARTS way (linear in log pressure).\n"
02179          "\n"
02180          "How fine the new grid will be is determined by the keyword parameter\n"
02181          "p_step. The definition of p_step, and the interpolation behavior, is\n"
02182          "consistent with *abs_lookupSetup* and *abs_lookupSetupBatch*. (New\n"
02183          "points are added between the original ones, so that the spacing is\n"
02184          "always below p_step.)\n"
02185          "\n"
02186          "Keywords:\n"
02187          "   p_step   : Maximum step in log(p[Pa]) (natural logarithm, as always). If\n"
02188          "              the pressure grid is coarser than this, additional points\n"
02189          "              are added until each log step is smaller than this.\n"
02190         ),
02191         AUTHORS( "Stefan Buehler" ),
02192         OUT("p_grid",
02193                "t_field", "z_field", "vmr_field"),
02194         GOUT(),
02195         GOUT_TYPE(),
02196         GOUT_DESC(),
02197         IN( "p_grid", "lat_grid", "lon_grid",
02198                "t_field", "z_field", "vmr_field", "atmosphere_dim"),
02199         GIN( "p_step" ),
02200         GIN_TYPE(    "Numeric" ),
02201         GIN_DEFAULT( NODEF ),
02202         GIN_DESC("FIXME DOC")
02203       ));
02204 
02205   md_data_raw.push_back
02206     ( MdRecord
02207       ( NAME("atm_fields_compactAddConstant"),
02208         DESCRIPTION
02209         (
02210          "Adds a constant field to atm_fields_compact. \n"
02211          "\n"
02212          "This is handy for nitrogen or oxygen. The constant value is\n"
02213          "appended at the end of the fields that are already there.  All\n"
02214          "dimensions (pressure, latitude, longitude) are filled up, so this\n"
02215          "works for 1D, 2D, or 3D atmospheres.\n"
02216          "\n"
02217          "Keywords:\n"
02218          "   name  : The field name. Use, e.g., vmr_o2 for oxygen VMR.\n"
02219          "   value : The constant value of this field.\n"
02220          ),
02221         AUTHORS( "Stefan Buehler" ),
02222         OUT( "atm_fields_compact" ),
02223         GOUT(),
02224         GOUT_TYPE(),
02225         GOUT_DESC(),
02226         IN(  "atm_fields_compact" ),
02227         GIN( "name",   "value" ),
02228         GIN_TYPE(    "String", "Numeric" ),
02229         GIN_DEFAULT( NODEF,    NODEF ),
02230         GIN_DESC("FIXME DOC",
02231                  "FIXME DOC")
02232       ));
02233 
02234   md_data_raw.push_back
02235     ( MdRecord
02236       ( NAME("atm_fields_compactFromMatrix"),
02237         DESCRIPTION
02238         (
02239          "Set atm_fields_compact from 1D profiles in a matrix.\n"
02240          "\n"
02241          "For clear-sky batch calculations it is handy to store atmospheric\n"
02242          "profiles in an array of matrix. We take such a matrix, and create\n"
02243          "*atm_fields_compact* from it. \n"
02244          "\n"
02245          "The matrix must contain one row for each pressure level. Recommended\n"
02246          "row format:\n"
02247          "\n"
02248          "p[Pa] T[K] z[m] VMR_1[1] ... VMR[2]\n"
02249          "\n"
02250          "Works only for *atmosphere_dim==1.*\n"         
02251          "\n"
02252          "Keywords:\n"
02253          "   field_names : Field names to store in atm_fields_compact.\n"
02254          "                 This should be, e.g.:\n"
02255          "                 [\"T[K]\", \"z[m]\", \"vmr_h2o[1]\"]\n"
02256          "                 There must be one name less than matrix columns,\n"
02257          "                 because the first column must contain pressure.\n"
02258         ),
02259         AUTHORS( "Stefan Buehler" ),
02260         OUT( "atm_fields_compact" ),
02261         GOUT(),
02262         GOUT_TYPE(),
02263         GOUT_DESC(),
02264         IN(  "atmosphere_dim" ),
02265         GIN(      "gin1"      ,
02266                   "field_names" ),
02267         GIN_TYPE(    "Matrix",
02268                      "ArrayOfString" ),
02269         GIN_DEFAULT( NODEF   ,
02270                   NODEF ),
02271         GIN_DESC("FIXME DOC",
02272                  "FIXME DOC")
02273       ));
02274 
02275   md_data_raw.push_back
02276     ( MdRecord
02277       ( NAME("batch_atm_fields_compactFromArrayOfMatrix"),
02278         DESCRIPTION
02279         (
02280          "Expand batch of 1D atmospheric states to a batch_atm_fields_compact.\n"
02281          "\n"
02282          "This is used to handle 1D batch cases, for example from the Chevallier\n"
02283          "data set, stored in a matrix. \n"
02284          "\n"
02285          "The matrix must contain one row for each pressure level. Row format:\n"
02286          "\n"
02287          "p[Pa] T[K] z[m] VMR_1[1] ... VMR_N[1]\n"
02288          "\n"
02289          "Keywords:\n"
02290          "   field_names : Field names to store in atm_fields_compact.\n"
02291          "                 This should be, e.g.:\n"
02292          "                 [\"T\", \"z\", \"H2O\", \"O3\"]\n"
02293          "                 There must be one name less than matrix columns,\n"
02294          "                 because the first column must contain pressure.\n"
02295          "\n"
02296          "   extra_field_names : You can add additional constant VMR fields,\n"
02297          "                       which is handy for O2 and N2. Give here the\n"
02298          "                       field name, e.g., \"O2\". Default: Empty.\n"
02299          "\n"
02300          "   extra_field_values : Give here the constant field value. Default:\n"
02301          "                        Empty. Dimension must match extra_field_names.\n"
02302         ),
02303         AUTHORS( "Stefan Buehler" ),
02304         OUT( "batch_atm_fields_compact" ),
02305         GOUT(),
02306         GOUT_TYPE(),
02307         GOUT_DESC(),
02308         IN(  "atmosphere_dim" ),
02309         GIN(      "gin1"             ,
02310                   "field_names", "extra_field_names", "extra_field_values" ),
02311         GIN_TYPE(    "ArrayOfMatrix",
02312                      "ArrayOfString", "ArrayOfString",     "Vector" ),
02313         GIN_DEFAULT( NODEF          ,
02314                   NODEF,         "[]",                "[]" ),
02315         //KW_DEFAULT( NODEF,         NODEF,                NODEF ),
02316         GIN_DESC("FIXME DOC",
02317                  "FIXME DOC",
02318                  "FIXME DOC",
02319                  "FIXME DOC")
02320       ));
02321 
02322   md_data_raw.push_back
02323     ( MdRecord
02324       ( NAME("AtmFieldsFromCompact"),
02325         DESCRIPTION
02326         (
02327          "Extract pressure grid and atmospheric fields from\n"
02328          "*atm_fields_compact*.\n"
02329          "\n"
02330          "An atmospheric scenario includes the following data for each \n"
02331          "position (pressure, latitude, longitude) in the atmosphere: \n"
02332          "           1. temperature field \n"
02333          "           2. the corresponding altitude field \n"
02334          "           3. vmr fields for the gaseous species \n"
02335          "\n"
02336          "This method just splits up the data found in *atm_fields_compact* to\n"
02337          "p_grid, lat_grid, lon_grid, and the various fields. No interpolation.\n"
02338          "See documentation of *atm_fields_compact* for a definition of the data.\n"
02339          "\n"
02340          "There are some safety checks on the names of the fields: The first\n"
02341          "field must be called *T*, the second *z*.  Remaining fields must be\n"
02342          "trace gas species volume mixing ratios, named for example \"H2O\", \"O3\",\n"
02343          "and so on. The species names must fit the species in *abs_species*.\n"
02344          "(Same species in same order.) Only the species name must fit, not the\n"
02345          "full tag.\n"
02346          "\n"
02347          "Possible future extensions: Add a keyword parameter to refine the\n"
02348          "pressure grid if it is too coarse. Or a version that interpolates onto\n"
02349          "given grids, instead of using and returning the original grids.\n"
02350          ),
02351         AUTHORS( "Stefan Buehler" ),
02352         OUT( "p_grid", "lat_grid", "lon_grid", "t_field", "z_field", "vmr_field" ),
02353         GOUT(),
02354         GOUT_TYPE(),
02355         GOUT_DESC(),
02356         IN(  "abs_species", "atm_fields_compact", "atmosphere_dim" ),
02357         GIN(),
02358         GIN_TYPE(),
02359         GIN_DEFAULT(),
02360         GIN_DESC()
02361       ));
02362 
02363   md_data_raw.push_back
02364     ( MdRecord
02365       ( NAME("AtmosphereSet1D"),
02366         DESCRIPTION
02367         (
02368          "Sets the atmospheric dimension to 1D.\n"
02369          "\n"
02370          "Sets *atmosphere_dim* to 1 and gives some variables dummy values.\n"
02371          "\n"
02372          "The latitude and longitude grids are set to be empty.\n"
02373         ),
02374         AUTHORS( "Patrick Eriksson" ),
02375         OUT( "atmosphere_dim", "lat_grid", "lon_grid" ),
02376         GOUT(),
02377         GOUT_TYPE(),
02378         GOUT_DESC(),
02379         IN(),
02380         GIN(),
02381         GIN_TYPE(),
02382         GIN_DEFAULT(),
02383         GIN_DESC()
02384       ));
02385 
02386   md_data_raw.push_back
02387     ( MdRecord
02388       ( NAME("AtmosphereSet2D"),
02389         DESCRIPTION
02390         (
02391          "Sets the atmospheric dimension to be 2D.\n"
02392          "\n"
02393          "Sets *atmosphere_dim* to 2 and gives some variables dummy values.\n"
02394          "\n"
02395          "The longitude grid is set to be empty. The variables *lat_1d*\n"
02396          "and *meridian_angle_1d* are given values that cause an error\n"
02397          "message if used.\n"
02398         ),
02399         AUTHORS( "Patrick Eriksson" ),
02400         OUT( "atmosphere_dim", "lon_grid", "lat_1d", "meridian_angle_1d"),
02401         GOUT(),
02402         GOUT_TYPE(),
02403         GOUT_DESC(),
02404         IN(),
02405         GIN(),
02406         GIN_TYPE(),
02407         GIN_DEFAULT(),
02408         GIN_DESC()
02409       ));
02410 
02411   md_data_raw.push_back
02412     ( MdRecord
02413       ( NAME("AtmosphereSet3D"),
02414         DESCRIPTION
02415         (
02416          "Sets the atmospheric dimension to 3D.\n"
02417          "\n"
02418          "Sets *atmosphere_dim* to 3 and gives some variables dummy values.\n"
02419          "\n"
02420          "The variables *lat_1d* and *meridian_angle_1d* are given\n"
02421          "values that cause an error message if used.\n"
02422         ),
02423         AUTHORS( "Patrick Eriksson" ),
02424         OUT( "atmosphere_dim", "lat_1d", "meridian_angle_1d" ),
02425         GOUT(),
02426         GOUT_TYPE(),
02427         GOUT_DESC(),
02428         IN(),
02429         GIN(),
02430         GIN_TYPE(),
02431         GIN_DEFAULT(),
02432         GIN_DESC()
02433       ));
02434 
02435   md_data_raw.push_back
02436     ( MdRecord
02437       ( NAME("AtmRawRead"),
02438         DESCRIPTION
02439         (
02440          "Reads atmospheric data from a scenario.\n"
02441          "\n"
02442          "An atmospheric scenario includes the following data for each \n"
02443          "position (pressure, latitude, longitude) in the atmosphere: \n"
02444          "           1. temperature field \n"
02445          "           2. the corresponding altitude field \n"
02446          "           3. vmr fields for the gaseous species \n"
02447          "The data is stored in different files. This methods reads all \n"
02448          "files and creates the variables *t_field_raw*, *z_field_raw* \n"
02449          "\n"
02450          "Different atmospheric scenarios are available in arts data:\n"
02451          "For example tropical and midlatitude-summer. 3D scenarios are \n"
02452          "not available yet.\n"
02453          "\n"
02454          "Files in the scenarios look like this: tropical.H2O.xml \n"
02455          "\n"
02456          "The basename must include the path, i.e., the files can be \n"
02457          "anywhere, but they must be all in the same directory.\n"
02458          "The profile is chosen by the species name. If you have more than \n"
02459          "one tag group for the same species, the same profile will be \n"
02460          "used.\n"
02461          "\n"
02462          "Keywords: \n"
02463          "basename :The name and path of a particular atmospheric scenario.\n"
02464          "For example:\n"
02465          "/smiles_local/arts-data/atmosphere/fascod/tropical \n"
02466         ),
02467         AUTHORS( "Claudia Emde" ),
02468         OUT("t_field_raw", "z_field_raw", "vmr_field_raw"),
02469         GOUT(),
02470         GOUT_TYPE(),
02471         GOUT_DESC(),
02472         IN("abs_species"),
02473         GIN( "basename" ),
02474         GIN_TYPE(    "String" ),
02475         GIN_DEFAULT( NODEF ),
02476         GIN_DESC("FIXME DOC")
02477       ));
02478 
02479   md_data_raw.push_back
02480     ( MdRecord
02481       ( NAME( "CloudboxGetIncoming" ),
02482         DESCRIPTION
02483         (
02484          "Calculates incoming radiation field of cloudbox by repeated\n"
02485          "radiative transfer calculations.\n"
02486          "\n"
02487          "The method performs monochromatic pencil beam calculations for\n"
02488          "all grid positions on the cloudbox boundary, and all directions\n"
02489          "given by scattering angle grids (*scat_za/aa_grid*). Found radiances\n"
02490          "are stored in *scat_i_p/lat/lon* which can be used as boundary\n"
02491          "conditions when scattering inside the cloud box is solved by the\n"
02492          "DOIT method.\n"
02493          ),
02494         AUTHORS( "Sreerekha T.R.", "Claudia Emde" ),
02495         OUT( "scat_i_p", "scat_i_lat", "scat_i_lon", "cloudbox_on"),
02496         GOUT(),
02497         GOUT_TYPE(),
02498         GOUT_DESC(),
02499         IN( "ppath_step_agenda", "rte_agenda", "iy_space_agenda",
02500                "surface_prop_agenda", "iy_cloudbox_agenda",
02501                "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", "z_field", 
02502                "t_field", "vmr_field", "r_geoid", "z_surface", 
02503                "cloudbox_limits", "f_grid", "stokes_dim", 
02504                "scat_za_grid", "scat_aa_grid" ),
02505         GIN(),
02506         GIN_TYPE(),
02507         GIN_DEFAULT(),
02508         GIN_DESC()
02509       ));
02510 
02511   md_data_raw.push_back
02512     ( MdRecord
02513       ( NAME( "CloudboxGetIncoming1DAtm" ),
02514         DESCRIPTION
02515         (
02516          "As *CloudboxGetIncoming* but assumes clear sky part to be 1D."
02517          "\n"
02518          "The incoming field is calculated only for one position and azimuth\n"
02519          "angle for each cloud box boundary, and obtained values are used\n"
02520          "for all other postions and azimuth angles. This works if a 3D\n"
02521          "cloud box is put into an 1D background atmosphere.\n"
02522          "\n"
02523          "This method can only be used for 3D cases.\n"
02524          ),
02525         AUTHORS( "Sreerekha T.R.", "Claudia Emde" ),
02526         OUT( "scat_i_p", "scat_i_lat", "scat_i_lon", "cloudbox_on"),
02527         GOUT(),
02528         GOUT_TYPE(),
02529         GOUT_DESC(),
02530         IN( "ppath_step_agenda", "rte_agenda", "iy_space_agenda",
02531                "surface_prop_agenda", "iy_cloudbox_agenda",
02532                "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", "z_field", 
02533                "t_field", "vmr_field", "r_geoid", "z_surface", 
02534                "cloudbox_limits", "f_grid", "stokes_dim", 
02535                "scat_za_grid", "scat_aa_grid" ),
02536         GIN(),
02537         GIN_TYPE(),
02538         GIN_DEFAULT(),
02539         GIN_DESC()
02540       ));
02541 
02542   md_data_raw.push_back
02543     ( MdRecord
02544       ( NAME("cloudboxOff"),
02545         DESCRIPTION
02546         (
02547          "Deactivates the cloud box. \n"
02548          "\n"
02549          "The function sets *cloudbox_on* to 0, *cloudbox_limits* to be an\n"
02550          "empty vector and *iy_cloudbox_agenda* to an empty agenda.\n"
02551         ),
02552         AUTHORS( "Patrick Eriksson" ),
02553         OUT( "cloudbox_on", "cloudbox_limits", "iy_cloudbox_agenda" ),
02554         GOUT(),
02555         GOUT_TYPE(),
02556         GOUT_DESC(),
02557         IN(),
02558         GIN(),
02559         GIN_TYPE(),
02560         GIN_DEFAULT(),
02561         GIN_DESC()
02562       ));
02563   
02564    md_data_raw.push_back
02565     ( MdRecord
02566       ( NAME( "cloudboxSetDisort" ),
02567         DESCRIPTION
02568         (
02569          "For Disort calculation the cloudbox must be extended to \n"
02570          "cover the full atmosphere.\n"
02571          "This method sets *cloudbox_limits* accordingly. \n"
02572          ), 
02573         AUTHORS( "Claudia Emde" ),
02574         OUT("cloudbox_on", "cloudbox_limits"),
02575         GOUT(),
02576         GOUT_TYPE(),
02577         GOUT_DESC(),
02578         IN("p_grid"),
02579         GIN(),
02580         GIN_TYPE(),
02581         GIN_DEFAULT(),
02582         GIN_DESC()
02583       ));
02584 
02585 
02586   md_data_raw.push_back
02587     ( MdRecord
02588       ( NAME( "cloudboxSetEmpty" ),
02589         DESCRIPTION
02590         (
02591          "Sets the cloudbox empty for clearsky DOIT calculations. \n"
02592          "\n"
02593          "Scattering calculations using the DOIT method include \n"
02594          "interpolation errors. If one is interested in the cloud effect, \n"
02595          "should compare the DOIT result with a clearsky calculation using \n"
02596          "an empty cloudbox. That means that the iterative method is \n"
02597          "performed for a cloudbox including no particles. This method sets \n"
02598          "the particle number density field to zero and creates a \n"
02599          "dummy *scat_data_raw* structure. For a cleasky calculation, \n"
02600          "the methods *ParticleTypeAdd(All)* and *pnd_fieldCalc* can be \n"
02601          "replaced by this method. \n"
02602          ),
02603         AUTHORS( "Claudia Emde" ),
02604         OUT( "pnd_field", "scat_data_raw"),
02605         GOUT(),
02606         GOUT_TYPE(),
02607         GOUT_DESC(),
02608         IN( "p_grid", "lat_grid", "lon_grid" ),
02609         GIN(),
02610         GIN_TYPE(),
02611         GIN_DEFAULT(),
02612         GIN_DESC()
02613       ));
02614 
02615   md_data_raw.push_back
02616     ( MdRecord
02617       ( NAME( "cloudboxSetManually" ),
02618         DESCRIPTION
02619         (
02620          "Sets the cloud box to encompass the given positions.\n"
02621          "\n"
02622          "The function sets *cloudbox_on* to 1 and sets *cloudbox_limits*\n"
02623          "following the given pressure, latitude and longitude positions.\n"
02624          "The index limits in *cloudbox_limits* are selected to give the\n" 
02625          "smallest possible cloud box that encompass the given points. \n"
02626          "\n"
02627          "The points must be given in the same order as used in\n"
02628          "*cloudbox_limits*. That means that the first keyword argument \n"
02629          "shall be a higher pressure than argument two, while the latitude\n"
02630          "and longitude points are given in increasing order. Positions\n"
02631          "given for dimensions not used by the selected atmospheric\n"
02632          "dimensionality are ignored.\n"
02633          "\n"
02634          "The given pressure points can be outside the range of *p_grid*.\n"
02635          "The pressure limit is then set to the end point of *p_grid*.\n"
02636          "The given latitude and longitude points must be inside the range\n"
02637          "of the corresponding grid. In addition, the latitude and longitude\n"
02638          "points cannot be inside the outermost grid ranges as the latitude\n"
02639          "and longitude limits in *cloudbox_limits* are not allowed to be\n"
02640          "grid end points.\n"
02641          "\n"
02642          "Keywords: \n"
02643          "   p1   : Upper pressure point.\n"
02644          "   p2   : Lower pressure point.\n"
02645          "   lat1 : Lower latitude point.\n"
02646          "   lat2 : Upper latitude point.\n"
02647          "   lon1 : Lower longitude point.\n"
02648          "   lon2 : Upper longitude point.\n"
02649         ),
02650         AUTHORS( "Patrick Eriksson" ),
02651         OUT( "cloudbox_on", "cloudbox_limits"),
02652         GOUT(),
02653         GOUT_TYPE(),
02654         GOUT_DESC(),
02655         IN( "atmosphere_dim", "p_grid", "lat_grid", "lon_grid" ),
02656         GIN( "p1",      "p2",      "lat1",    "lat2",    "lon1",
02657                   "lon2" ),
02658         GIN_TYPE(    "Numeric", "Numeric", "Numeric", "Numeric", "Numeric", 
02659                   "Numeric" ),
02660         GIN_DEFAULT( NODEF,     NODEF,     NODEF,     NODEF,     NODEF,
02661                   NODEF ),
02662         GIN_DESC("FIXME DOC",
02663                  "FIXME DOC",
02664                  "FIXME DOC",
02665                  "FIXME DOC",
02666                  "FIXME DOC",
02667                  "FIXME DOC")
02668       ));
02669 
02670   md_data_raw.push_back
02671     ( MdRecord
02672       ( NAME( "cloudboxSetManuallyAltitude" ),
02673         DESCRIPTION
02674         (
02675          "Sets the cloud box to encompass the given positions.\n"
02676          "\n"
02677          "The function sets *cloudbox_on* to 1 and sets *cloudbox_limits*\n"
02678          "following the given altitude, latitude and longitude positions.\n"
02679          "The index limits in *cloudbox_limits* are selected to give the\n" 
02680          "smallest possible cloud box that encompass the given points. \n"
02681          "\n"
02682          "The points must be given in the same order as used in\n"
02683          "*cloudbox_limits*. That means that altitude, latitude\n"
02684          "and longitude points are given in increasing order. Positions\n"
02685          "given for dimensions not used by the selected atmospheric\n"
02686          "dimensionality are ignored.\n"
02687          "\n"
02688          "The given altitude points can be outside the range of *z_field*.\n"
02689          "The altitude limit is then set to the end point of *p_grid*.\n"
02690          "The given latitude and longitude points must be inside the range\n"
02691          "of the corresponding grid. In addition, the latitude and longitude\n"
02692          "points cannot be inside the outermost grid ranges as the latitude\n"
02693          "and longitude limits in *cloudbox_limits* are not allowed to be\n"
02694          "grid end points.\n"
02695          "\n"
02696          "Keywords: \n"
02697          "   z1   : Lower altitude point.\n"
02698          "   z2   : Upper altitude point.\n"
02699          "   lat1 : Lower latitude point.\n"
02700          "   lat2 : Upper latitude point.\n"
02701          "   lon1 : Lower longitude point.\n"
02702          "   lon2 : Upper longitude point.\n"
02703         ),
02704         AUTHORS( "Claudia Emde" ),
02705         OUT( "cloudbox_on", "cloudbox_limits"),
02706         GOUT(),
02707         GOUT_TYPE(),
02708         GOUT_DESC(),
02709         IN( "atmosphere_dim", "z_field", "lat_grid", "lon_grid" ),
02710         GIN( "z1",      "z2",      "lat1",    "lat2",    "lon1",
02711                   "lon2" ),
02712         GIN_TYPE(    "Numeric", "Numeric", "Numeric", "Numeric", "Numeric", 
02713                   "Numeric" ),
02714         GIN_DEFAULT( NODEF,     NODEF,     NODEF,     NODEF,     NODEF,
02715                   NODEF ),
02716         GIN_DESC("FIXME DOC",
02717                  "FIXME DOC",
02718                  "FIXME DOC",
02719                  "FIXME DOC",
02720                  "FIXME DOC",
02721                  "FIXME DOC")
02722       ));
02723 
02724   md_data_raw.push_back
02725     ( MdRecord
02726       ( NAME("complex_nWaterLiebe93"),
02727         DESCRIPTION
02728         (
02729          "Complex refractive index of liquid water according to Liebe 1993.\n"
02730          "\n"
02731          "The method treats liquid water without salt. Not valid below 10 GHz.\n"
02732          "Upper frequency limit not known and is here set to 1000 GHz. Model\n"
02733          "parameters taken from Atmlab function epswater93 (by C. Maetzler),\n"
02734          "which refer to Liebe 1993 without closer specifications.\n"
02735          "\n"
02736          "Temperature must be between 0 and 100 degrees Celsius.\n"
02737          "\n"
02738          "Global input:\n"
02739          "   t : Temperature [K].\n"
02740         ),
02741         AUTHORS( "Patrick Eriksson" ),
02742         OUT( "complex_n" ),
02743         GOUT(),
02744         GOUT_TYPE(),
02745         GOUT_DESC(),
02746         IN( "f_grid" ),
02747         GIN( "t" ),
02748         GIN_TYPE( "Numeric" ),
02749         GIN_DEFAULT( NODEF ),
02750         GIN_DESC("FIXME DOC")
02751       ));
02752 
02753   md_data_raw.push_back
02754     ( MdRecord
02755       ( NAME("Copy"),
02756         DESCRIPTION
02757         (
02758          "Copy a workspace variable.\n"
02759          "\n"
02760          "This is a supergeneric method. It can copy any workspace variable\n"
02761          "to another workspace variable of the same group. (E.g., a Matrix to\n"
02762          "another Matrix.)\n"
02763          "\n"
02764          "As allways, output comes first in the argument list!\n"
02765          "\n"
02766          "Usage example:\n"
02767          "\n"
02768          "Copy(f_grid,p_grid){}\n"
02769          "\n"
02770          "Will copy the content of *p_grid* to *f_grid*. The size of *f_grid*\n"
02771          "is adjusted automatically (the normal behaviour for workspace\n"
02772          "methods).\n"
02773          "\n"
02774          "Supergeneric output:\n"
02775          "   Any : The output variable.\n"
02776          "\n"
02777          "Supergeneric input:\n"
02778          "   Any : The input variable.\n"
02779          ),
02780         AUTHORS( "Stefan Buehler" ),
02781         OUT(),
02782         GOUT(      "gout1"    ),
02783         GOUT_TYPE( "Any" ),
02784         GOUT_DESC("FIXME DOC"),
02785         IN(),
02786         GIN(      "gin1"    ),
02787         GIN_TYPE(    "Any" ),
02788         GIN_DEFAULT( NODEF ),
02789         GIN_DESC("FIXME DOC"),
02790         SETMETHOD(      false ),
02791         AGENDAMETHOD(   false ),
02792         SUPPRESSHEADER( true  )
02793       ));
02794 
02795   md_data_raw.push_back
02796     ( MdRecord
02797       ( NAME("Delete"),
02798         DESCRIPTION
02799         (
02800          "Deletes a workspace variable.\n"
02801          "\n"
02802          "Supergeneric input:\n"
02803          "   Any     : The variable to delete.\n"
02804          ),
02805         AUTHORS( "Oliver Lemke" ),
02806         OUT(),
02807         GOUT(),
02808         GOUT_TYPE(),
02809         GOUT_DESC(),
02810         IN(),
02811         GIN(       "gin1"    ),
02812         GIN_TYPE(     "Any" ),
02813         GIN_DEFAULT(  NODEF ),
02814         GIN_DESC("FIXME DOC"),
02815         SETMETHOD(      false ),
02816         AGENDAMETHOD(   false ),
02817         SUPPRESSHEADER( true  ),
02818         PASSWORKSPACE(  true  ),
02819         PASSWSVNAMES(   true  )
02820       ));
02821 
02822   md_data_raw.push_back
02823     ( MdRecord
02824       ( NAME("ScatteringDisort"),
02825         DESCRIPTION
02826         (
02827          "Calls DISORT RT solver from ARTS.\n"
02828          "Detailed documentation to be added.\n"
02829          ),
02830         AUTHORS( "Claudia Emde" ),
02831         OUT("scat_i_p", "scat_i_lat", "scat_i_lon", 
02832                "f_index", "scat_data_mono", "doit_i_field1D_spectrum"),
02833         GOUT(),
02834         GOUT_TYPE(),
02835         GOUT_DESC(),
02836         IN("cloudbox_limits", "stokes_dim", "opt_prop_part_agenda", 
02837               "abs_scalar_gas_agenda", "spt_calc_agenda", 
02838               "pnd_field", "t_field", 
02839               "z_field", "p_grid", "vmr_field", "scat_data_raw", "f_grid", 
02840               "scat_za_grid", "surface_emissivity_DISORT" ),
02841         GIN(),
02842         GIN_TYPE(),
02843         GIN_DEFAULT(),
02844         GIN_DESC()
02845       ));
02846 
02847 
02848    md_data_raw.push_back
02849     ( MdRecord
02850       ( NAME("DoitAngularGridsSet"),
02851         DESCRIPTION
02852         (
02853          "Set angular grids for DOIT calculation."
02854          "\n"
02855          "In this method the angular grids for a DOIT calculation are "
02856          "specified.\n"
02857          "For down-looking geometries it is sufficient to define\n"
02858          "\n"  
02859          "N_za_grid: number of grid points in zenith angle grid\n"
02860          "           recommended value: 19\n"
02861          "N_aa_grid: number of grid points in zenith angle grid\n"
02862          "           recommended value: 37\n"
02863          "\n"
02864          "From these numbers equally spaced grids are created and stored in "
02865          "the\n" 
02866          "WSVs *scat_za_grid* and *scat_aa_grid*.\n" 
02867          "\n"
02868          "For limb simulations it is important to use an optimized zenith "
02869          "angle \n"
02870          "grid with a very fine resolution about 90° for the "
02871          "RT calculations.\n"
02872          "Such a grid can be generated using *doit_za_grid_optCalc*. \n"
02873          "The filename of the optimized zenith angle grid can be given \n"
02874          "as a keyword. If a filename is given, the equidistant grid is \n"
02875          "taken for the calculation of the scattering integrals and the\n"
02876          "optimized grid is taken for the radiative transfer part.\n"
02877          "Otherwise, if no filename is specified \n"
02878          "( za_grid_opt_file = \"\" ) the equidistant grid is \n"
02879          "taken for the calculation of the scattering integrals and for \n"
02880          "the RT calculations. This option makes sense for down-looking \n"
02881          "cases to speed up the calculation. \n"
02882          ),
02883         AUTHORS( "Claudia Emde" ),
02884         OUT( "doit_za_grid_size", "scat_aa_grid", "scat_za_grid"),
02885         GOUT(),
02886         GOUT_TYPE(),
02887         GOUT_DESC(),
02888         IN(),
02889         GIN( "N_za_grid", "N_aa_grid", "za_grid_opt_file"),
02890         GIN_TYPE(    "Index",     "Index",     "String"),
02891         GIN_DEFAULT( NODEF,       NODEF,       NODEF ),
02892         GIN_DESC("FIXME DOC",
02893                  "FIXME DOC",
02894                  "FIXME DOC")
02895       ));
02896 
02897   md_data_raw.push_back
02898     ( MdRecord
02899       ( NAME( "DoitCloudboxFieldPut" ),
02900         DESCRIPTION
02901         (
02902          "Method for the communication between cloudbox and clearsky.\n"
02903          "\n"
02904          "This method puts the scattered radiation field into the interface\n"
02905          "variables between the cloudbox and the clearsky, which are \n"
02906          "*scat_i_p*, *scat_i_lat* and *scat_i_lon*.\n"
02907          "\n"
02908          "The best way to calculate spectra including the influence of\n" 
02909          "scattering is to set up the *scat_mono_agenda* where this method \n"
02910          "can be included.\n"
02911          ),
02912         AUTHORS( "Claudia Emde" ),
02913         OUT( "scat_i_p", "scat_i_lat", "scat_i_lon",
02914                 "doit_i_field1D_spectrum" ),
02915         GOUT(),
02916         GOUT_TYPE(),
02917         GOUT_DESC(),
02918         IN( "doit_i_field", "f_grid", "f_index",   "p_grid", "lat_grid", 
02919                "lon_grid", "scat_za_grid", "scat_aa_grid", "stokes_dim",
02920                "atmosphere_dim", "cloudbox_limits", "sensor_pos", "z_field" ),
02921         GIN(),
02922         GIN_TYPE(),
02923         GIN_DEFAULT(),
02924         GIN_DESC()
02925       ));
02926 
02927 md_data_raw.push_back     
02928     ( MdRecord
02929       ( NAME("doit_conv_flagAbs"),
02930         DESCRIPTION
02931         (
02932          "Convergence test (maximum absolute difference).\n"
02933          "\n"
02934          "The function calculates the absolute differences for two " 
02935          "successive\n"
02936          "iteration fields. It picks out the maximum values for each Stokes \n"
02937          "component separately. The convergence test is fullfilled under the\n"
02938          "following conditions: \n"
02939          "|I(m+1) - I(m)| < epsilon_1     Intensity.\n"
02940          "|Q(m+1) - Q(m)| < epsilon_2     The other Stokes components.\n" 
02941          "|U(m+1) - U(m)| < epsilon_3    \n"
02942          "|V(m+1) - V(m)| < epsilon_4    \n" 
02943          "These conditions have to be valid for all positions in the \n"
02944          "cloudbox and for all directions.\n"  
02945          "\n"
02946          "The limits for convergence are set in the controlfile by \n"
02947          "setting the vector *epsilon* to appropriate values.\n"
02948          "The unit of *epsilon* is radiance [W / (m^2 Hz sr)].\n"
02949          "\n"
02950          "This method can be used in *doit_convergence_test_agenda*.\n"
02951         ),
02952         AUTHORS( "Claudia Emde" ),
02953         OUT("doit_conv_flag", "doit_iteration_counter"),
02954         GOUT(),
02955         GOUT_TYPE(),
02956         GOUT_DESC(),
02957         IN("doit_conv_flag", "doit_iteration_counter",
02958               "doit_i_field", "doit_i_field_old"),
02959         GIN( "epsilon" ),
02960         GIN_TYPE(    "Vector" ),
02961         GIN_DEFAULT( NODEF ),
02962         GIN_DESC("FIXME DOC")
02963       ));
02964 
02965   md_data_raw.push_back     
02966     ( MdRecord
02967       ( NAME("doit_conv_flagLsq"),
02968         DESCRIPTION
02969         (
02970          "Convergence test (Least square).\n"
02971          "\n"
02972          "This method performs a least square convergence test for two \n"
02973          "successive iteration fields.\n"
02974          "\n"
02975          "The limits for convergence are set in the controlfile by \n"
02976          "setting the vector *epsilon* to appropriate values.\n"
02977          "The unit of *epsilon* is Rayleigh Jeans BT [K].\n"
02978          "\n"
02979          "Warning: This method is not recommended because this kind of \n"
02980          "convergence test is not sufficiently strict, so that the \n"
02981          "DOIT result might be wrong. \n" 
02982         ),
02983         AUTHORS( "Claudia Emde" ),
02984         OUT("doit_conv_flag", "doit_iteration_counter"),
02985         GOUT(),
02986         GOUT_TYPE(),
02987         GOUT_DESC(),
02988         IN("doit_conv_flag", "doit_iteration_counter", 
02989               "doit_i_field", "doit_i_field_old", "f_grid", "f_index"),
02990         GIN( "epsilon" ),
02991         GIN_TYPE(    "Vector" ),
02992         GIN_DEFAULT( NODEF ),
02993         GIN_DESC("FIXME DOC")
02994       ));
02995   
02996   md_data_raw.push_back     
02997     ( MdRecord
02998       ( NAME("doit_conv_flagAbsBT"),
02999         DESCRIPTION
03000         (
03001          "Convergence test (maximum absolute difference in Rayleigh Jeans "
03002          "BT)\n"
03003          "\n"
03004          "The function calculates the absolute differences for two " 
03005          "successive\n"
03006          "iteration fields. It picks out the maximum values for each Stokes \n"
03007          "component separately. The convergence test is fullfilled under the\n"
03008          "following conditions: \n"
03009          "|I(m+1) - I(m)| < epsilon_1     Intensity.\n"
03010          "|Q(m+1) - Q(m)| < epsilon_2     The other Stokes components.\n" 
03011          "|U(m+1) - U(m)| < epsilon_3    \n"
03012          "|V(m+1) - V(m)| < epsilon_4    \n" 
03013          "These conditions have to be valid for all positions in the \n"
03014          "cloudbox and for all directions.\n"  
03015          "\n"
03016          "The limits for convergence are set in the controlfile by \n"
03017          "setting the vector *epsilon* to appropriate values.\n"
03018          "The unit of *epsilon* is Rayleigh Jeans BT [K].\n"
03019          "\n"
03020          "This method can be used in *doit_convergence_test_agenda*.\n"
03021          ),
03022         AUTHORS( "Sreerekha T.R.", "Claudia Emde" ),
03023         OUT("doit_conv_flag", "doit_iteration_counter"),
03024         GOUT(),
03025         GOUT_TYPE(),
03026         GOUT_DESC(),
03027         IN("doit_conv_flag", "doit_iteration_counter",
03028               "doit_i_field", "doit_i_field_old", "f_grid", "f_index"),
03029         GIN( "epsilon" ),
03030         GIN_TYPE(    "Vector" ),
03031         GIN_DEFAULT( NODEF ),
03032         GIN_DESC("FIXME DOC")
03033       ));
03034 
03035   md_data_raw.push_back
03036     ( MdRecord
03037       ( NAME( "DoitInit" ),
03038         DESCRIPTION
03039         (
03040          "Initialize variables for DOIT scattering calculations. \n"
03041          "\n"
03042          "Before using the WSM *ScatteringDOIT*, please use this method \n"
03043          "to initialize the required WSVs. \n"
03044          ),
03045         AUTHORS( "Claudia Emde" ),
03046         OUT( "scat_p_index", "scat_lat_index", "scat_lon_index", 
03047                 "scat_za_index", "scat_aa_index", "doit_scat_field",
03048                 "doit_i_field", "doit_za_interp", "doit_is_initialized" ),
03049         GOUT(),
03050         GOUT_TYPE(),
03051         GOUT_DESC(),
03052         IN( "stokes_dim", "atmosphere_dim", "scat_za_grid", "scat_aa_grid",
03053                "doit_za_grid_size", "cloudbox_limits", "scat_data_raw" ),
03054         GIN(),
03055         GIN_TYPE(),
03056         GIN_DEFAULT(),
03057         GIN_DESC()
03058       ));
03059 
03060   md_data_raw.push_back
03061     ( MdRecord
03062       ( NAME( "doit_i_fieldIterate" ),
03063         DESCRIPTION
03064         (
03065          "Iterative solution of the VRTE (DOIT method).\n"
03066          "\n"
03067          "A solution for the RTE with scattering is found using the\n"
03068          "DOIT method:\n"
03069          "\n"
03070          "1. Calculate scattering integral using *doit_scat_field_agenda*.\n"
03071          "2. Calculate RT with fixed scattered field using \n"
03072          "   *doit_rte_agenda*.\n"
03073          "3. Convergence test using *doit_conv_test_agenda*.\n"
03074          "\n"
03075          "Note: The atmospheric dimensionality *atmosphere_dim* can be \n"
03076          "      either 1 or 3. To these dimensions the method adapts \n"
03077          "      automatically. 2D scattering calculations are not \n"
03078          "      supported.\n"
03079          ),
03080         AUTHORS( "Claudia Emde" ),
03081         OUT("doit_i_field"),
03082         GOUT(),
03083         GOUT_TYPE(),
03084         GOUT_DESC(),
03085         IN( "doit_i_field", "doit_scat_field_agenda", "doit_rte_agenda", 
03086                "doit_conv_test_agenda"),
03087         GIN(),
03088         GIN_TYPE(),
03089         GIN_DEFAULT(),
03090         GIN_DESC()
03091       ));
03092 
03093   md_data_raw.push_back
03094     ( MdRecord
03095       ( NAME( "doit_i_fieldSetClearsky" ),
03096         DESCRIPTION
03097         (
03098          "Interpolate clearsky field on all gridpoints in cloudbox. \n"
03099          "\n"
03100          "This method uses a linear 1D/3D interpolation scheme to obtain the\n"
03101          "radiation field on all grid points inside the cloud box from the\n"
03102          "clear sky field on the cloud box boundary. This radiation field\n"
03103          "is taken as the first guess radiation field in the DOIT module. \n"
03104          "\n"
03105          "The inputs to this method are *scat_i_p*, *scat_i_lat*\n"
03106          "*scat_i_lon*.  The method picks the \n"
03107          "monochromatic radiation field out of these variables.  The \n"
03108          "output of the method is the first guess field stored in the \n"
03109          "workspace variable *doit_i_field*.\n"
03110          "\n"
03111          "Set keyword *all_frequencies* to 1 if for each frequency the \n"
03112          "clearsky field should be used as initial field. Set it to 0 if \n"
03113          "only for the first frequency in *f_grid* the clearsky field should\n"
03114          "be used and for the next frequencies *doit_i_field* of the \n"
03115          "previous frequency should be used. Default is 1. \n"
03116          ),
03117         AUTHORS( "Sreerekha T.R. and Claudia Emde" ),
03118         OUT("doit_i_field"),
03119         GOUT(),
03120         GOUT_TYPE(),
03121         GOUT_DESC(),
03122         IN( "scat_i_p", "scat_i_lat", "scat_i_lon", "f_grid", 
03123                "f_index", "p_grid", "lat_grid", "lon_grid", 
03124                "cloudbox_limits", "atmosphere_dim"),
03125         GIN("all_frequencies"),
03126         GIN_TYPE("Index"),
03127         GIN_DEFAULT( "1" ),
03128         GIN_DESC("FIXME DOC")
03129       ));
03130 
03131   md_data_raw.push_back
03132     ( MdRecord
03133       ( NAME( "doit_i_fieldSetConst" ),
03134         DESCRIPTION
03135         (
03136          "This method sets the initial field inside the cloudbox to a\n"
03137          "constant value. The method works only for monochromatic\n"
03138          "calculations (number of elements in f_grid=1).\n"
03139          "\n"
03140          "The user can specify a value for each Stokes dimension in the\n"
03141          "control file by the variable doit_i_field_value, which is a\n"
03142          "vector containing 4 elements, the value of the initial field\n"
03143          "for each Stokes dimension.\n"
03144          "\n"
03145          "Output of the method is the first guess field stored in the \n"
03146          "workspace variable *doit_i_field*.\n"
03147          ),
03148         AUTHORS( "Claudia Emde" ),
03149         OUT("doit_i_field"),
03150         GOUT(),
03151         GOUT_TYPE(),
03152         GOUT_DESC(),
03153         IN( "scat_i_p", "scat_i_lat", "scat_i_lon", "p_grid", "lat_grid", 
03154                "lon_grid", 
03155                "cloudbox_limits", "atmosphere_dim", "stokes_dim"),
03156         GIN( "value" ),
03157         GIN_TYPE(    "Vector" ),
03158         GIN_DEFAULT( NODEF ),
03159         GIN_DESC("FIXME DOC")
03160       ));
03161 
03162   md_data_raw.push_back
03163     ( MdRecord
03164       ( NAME( "doit_i_fieldUpdate1D" ),
03165         DESCRIPTION
03166         (
03167          "RT calculation in cloudbox with fixed scattering integral (1D). \n"
03168          "\n"
03169          "Update the radiation field (DOIT method). The method loops\n"
03170          "through the cloudbox to update the radiation field for all \n"
03171          "positions and directions in the 1D cloudbox.\n"
03172          "\n"
03173          "Note: This method is very inefficient, because the number of \n"
03174          "iterations scales with the number of cloudbox pressure levels.\n"
03175          "It is recommended to use *doit_i_fieldUpdateSeq1D*.\n"
03176         ),
03177         AUTHORS( "Claudia Emde" ),
03178         OUT("doit_i_field"),
03179         GOUT(),
03180         GOUT_TYPE(),
03181         GOUT_DESC(),
03182         IN("doit_i_field_old", "doit_scat_field", "cloudbox_limits", 
03183               "abs_scalar_gas_agenda",
03184               "vmr_field", "spt_calc_agenda", "scat_za_grid", "pnd_field", 
03185               "opt_prop_part_agenda", "opt_prop_gas_agenda",
03186               "ppath_step_agenda", "p_grid", "z_field", "r_geoid", "z_surface",
03187               "t_field", "f_grid", "f_index", "surface_prop_agenda",
03188               "doit_za_interp"),
03189         GIN(),
03190         GIN_TYPE(),
03191         GIN_DEFAULT(),
03192         GIN_DESC()
03193       ));
03194 
03195   md_data_raw.push_back
03196     ( MdRecord
03197       ( NAME( "doit_i_fieldUpdateSeq1D" ),
03198         DESCRIPTION
03199         (
03200          "RT calculation in cloudbox with fixed scattering integral. \n"
03201          "\n"
03202          "Update radiation field (*doit_i_field*) in DOIT module.\n"
03203          "This method loops through the cloudbox to update the \n"
03204          "radiation field for all positions and directions in the 1D \n"
03205          "cloudbox. The method applies the sequential update. For more \n"
03206          "information refer to AUG.\n"
03207          "\n"
03208          "Note: This is the commonly used WSM for the radiation field \n"
03209          "update (can be used in *doit_rte_agenda*). It is recommended \n"
03210          "because it is the most efficient and accurate method.\n"
03211          ),
03212         AUTHORS( "Claudia Emde" ),
03213         OUT("doit_i_field"),
03214         GOUT(),
03215         GOUT_TYPE(),
03216         GOUT_DESC(),
03217         IN("doit_i_field", "doit_scat_field", "cloudbox_limits", 
03218               "abs_scalar_gas_agenda",
03219               "vmr_field", "spt_calc_agenda", "scat_za_grid", "pnd_field",
03220               "opt_prop_part_agenda", "opt_prop_gas_agenda",
03221               "ppath_step_agenda", "p_grid", "z_field", "r_geoid", "z_surface",
03222               "t_field", "f_grid", "f_index", "surface_prop_agenda",
03223               "doit_za_interp"),
03224         GIN(),
03225         GIN_TYPE(),
03226         GIN_DEFAULT(),
03227         GIN_DESC()
03228       ));
03229 
03230   md_data_raw.push_back
03231     ( MdRecord
03232       ( NAME( "doit_i_fieldUpdateSeq1DPP" ),
03233         DESCRIPTION
03234         (
03235          "RT calculation in cloudbox with fixed scattering integral. \n"
03236          "\n " 
03237          "Update radiation field (*doit_i_field*) in DOIT module.\n"
03238          "This method loops through the cloudbox to update the \n"
03239          "radiation field for all \n"
03240          "positions and directions in the 1D cloudbox. The method applies\n"
03241          "the sequential update and the plane parallel approximation.\n"
03242          "This method is only slightly faster than \n"
03243          "*doit_i_fieldUpdateSeq1D* and it is less accurate. It can not \n"
03244          "be used for limb simulations. \n"
03245          ),
03246         AUTHORS( "Sreerekha T.R." ),
03247         OUT("doit_i_field", "scat_za_index"),
03248         GOUT(),
03249         GOUT_TYPE(),
03250         GOUT_DESC(),
03251         IN("doit_scat_field", "cloudbox_limits", 
03252               "abs_scalar_gas_agenda",
03253               "vmr_field", "spt_calc_agenda", "scat_za_grid", "pnd_field", 
03254               "opt_prop_part_agenda", "opt_prop_gas_agenda",
03255               "ppath_step_agenda", "p_grid", "z_field", "r_geoid", "t_field",
03256               "f_grid", "f_index"),
03257         GIN(),
03258         GIN_TYPE(),
03259         GIN_DEFAULT(),
03260         GIN_DESC()
03261       ));
03262 
03263   md_data_raw.push_back
03264     ( MdRecord
03265       ( NAME( "doit_i_fieldUpdateSeq3D" ),
03266         DESCRIPTION
03267         (
03268          "RT calculation in cloudbox with fixed scattering integral. \n"
03269          "\n"
03270          "Update radiation field (*doit_i_field*) in DOIT module.\n"
03271          "This method loops through the cloudbox to update the \n"
03272          "radiation field for all positions and directions in the 3D \n"
03273          "cloudbox. The method applies the sequential update. For more \n"
03274          "information please refer to AUG.\n"
03275          "Surface reflections are not yet implemented in 3D scattering \n"
03276          "calculations.\n"
03277          "\n"
03278          "Note: DOIT calculations in 3D are computationally expensive. \n"
03279          "For large 3D cloud fields it is recommended to use the Monte Carlo \n"
03280          "module or an independent pixel approach applying DOIT-1D. \n"
03281          ),
03282         AUTHORS( "Claudia Emde" ),
03283         OUT("doit_i_field"),
03284         GOUT(),
03285         GOUT_TYPE(),
03286         GOUT_DESC(),
03287         IN("doit_i_field", "doit_scat_field", "cloudbox_limits", 
03288               "abs_scalar_gas_agenda",
03289               "vmr_field", "spt_calc_agenda", "scat_za_grid", "scat_aa_grid",
03290               "pnd_field",
03291               "opt_prop_part_agenda", "opt_prop_gas_agenda",
03292               "ppath_step_agenda", "p_grid", "lat_grid", "lon_grid", "z_field",
03293               "r_geoid", "z_surface", "t_field",
03294               "f_grid", "f_index", "doit_za_interp"),
03295         GIN(),
03296         GIN_TYPE(),
03297         GIN_DEFAULT(),
03298         GIN_DESC()
03299       ));
03300   
03301   md_data_raw.push_back
03302     ( MdRecord
03303       ( NAME( "doit_scat_fieldCalc" ),
03304         DESCRIPTION
03305         (
03306          "This method calculates the scattering integral field in the DOIT module.\n"
03307          "\n"
03308          "The scattering integral field is generated by integrating\n"
03309          "the product of phase matrix and Stokes vector over all incident\n"
03310          "angles. For more information please refer to AUG.\n" 
03311          "\n"
03312          "The output of this method is *doit_scat_field*\n"
03313          "which is used in the radiative transfer part (*doit_i_fieldUpdateXXX*).\n"
03314          ),
03315         AUTHORS( "Sreerekha T.R.", "Claudia Emde" ),
03316         OUT( "doit_scat_field" ),
03317         GOUT(),
03318         GOUT_TYPE(),
03319         GOUT_DESC(),
03320         IN( "doit_scat_field", "pha_mat_spt_agenda",
03321                "doit_i_field", "pnd_field", "t_field", "atmosphere_dim", 
03322                "cloudbox_limits", "scat_za_grid", "scat_aa_grid",  
03323                "doit_za_grid_size"),
03324         GIN(),
03325         GIN_TYPE(),
03326         GIN_DEFAULT(),
03327         GIN_DESC()
03328       ));
03329 
03330   md_data_raw.push_back
03331     ( MdRecord
03332       ( NAME( "doit_scat_fieldCalcLimb" ),
03333         DESCRIPTION
03334         (
03335          "This method calculates the scattering integral field in the DOIT module (Limb).\n"
03336          "\n"
03337          "The scattering integral field is the field generated by integrating\n"
03338          "the product of phase matrix and the Stokes vector over all incident \n"
03339          "angles.\n"
03340          "\n"
03341          "The output of this method is the scattering integral field "
03342          "*doit_scat_field*\n"
03343          "which is used in the radiative transfer part (*doit_i_fieldUpdateXXX*). \n"
03344          "For limb simulations it "
03345          "makes sense to use different \n"
03346          "zenith angle grids for the scattering integral part and the RT part, \n"
03347          "because the latter part requires a much finer resolution about \n"
03348          "90°. Taking an optimized grid for the RT part and an equidistant \n"
03349          "grid for the scattering integral part saves very much CPU time.\n"
03350          "This method uses the equidistant za_grid defined in \n"
03351          "*doit_angular_gridsSet* and it should always be used for limb \n"
03352          "simulations.\n"
03353          "\n"
03354          "For more information please refer to AUG.\n"
03355          ),
03356         AUTHORS( "Claudia Emde" ),
03357         OUT( "doit_scat_field"),
03358         GOUT(),
03359         GOUT_TYPE(),
03360         GOUT_DESC(),
03361         IN( "doit_scat_field", "pha_mat_spt_agenda",
03362                "doit_i_field", "pnd_field", "t_field", "atmosphere_dim", 
03363                "cloudbox_limits", "scat_za_grid", "scat_aa_grid",  
03364                "doit_za_grid_size", "doit_za_interp" ),
03365         GIN(),
03366         GIN_TYPE(),
03367         GIN_DEFAULT(),
03368         GIN_DESC()
03369       ));
03370 
03371   md_data_raw.push_back
03372     ( MdRecord
03373       ( NAME("DoitScatteringDataPrepare"),
03374         DESCRIPTION
03375         (
03376          "Prepare single scattering data for a DOIT scattering calculation.\n"
03377          "\n"
03378          "This function can be used for scattering calculations using the \n" 
03379          "DOIT method. \n"
03380          "\n"
03381          "First the scattering data is interpolated on the frequency using\n"
03382          "*scat_data_monoCalc*. Then the phase matrix data is \n"
03383          "transformed or interpolated from the raw data to the laboratory frame \n"
03384          "for all possible combinations of the angles contained in the "
03385          "angular\n"
03386          "grids which are set in *doit_angulat_gridsSet*."
03387          "The resultung phase matrices are \n"
03388          "stored in *pha_mat_sptDOITOpt*, "
03389          "which is used in the method\n"
03390          "*pha_mat_sptFromDataDOITOpt*. \n"
03391           ),
03392         AUTHORS( "Claudia Emde" ),
03393         OUT( "pha_mat_sptDOITOpt", "scat_data_mono" ),
03394         GOUT(),
03395         GOUT_TYPE(),
03396         GOUT_DESC(),
03397         IN( "doit_za_grid_size", "scat_aa_grid", "scat_data_raw", "f_grid", 
03398                "f_index", "atmosphere_dim", "stokes_dim" ),
03399         GIN(),
03400         GIN_TYPE(),
03401         GIN_DEFAULT(),
03402         GIN_DESC()
03403       ));
03404 
03405   md_data_raw.push_back
03406     ( MdRecord
03407       ( NAME("DoitWriteIterationFields"),
03408         DESCRIPTION
03409         (
03410          "Write DOIT iteration fields.\n"
03411          "\n"
03412          "This method writes intermediate iteration fields \n"
03413          "to xml-files which is useful to check the DOIT method. \n"
03414          "It can be interesting to look how the radiation fields \n"
03415          "(*doit_i_field*) behave. The method can be used as a part of \n"
03416          "*convergence_test_agenda*.\n"
03417          "\n"
03418          "The keyword 'iterations' includes the numbers of the iterations\n"
03419          "which should be stored, e.g.,\n"
03420          "    'iterations = [3, 6, 9]'. \n"
03421          "In this case the 3rd, 6th and 9th iterations are \n"
03422          "stored in the files 'doit_iteration_3.xml', \n"
03423          "'doit_iteration_6.xml' ...\n If a number is larger than the \n"
03424          "total number of iterations, this number is ignored. \n"
03425          "\n"
03426          "If all iterations should be stored please set the keyword \n"
03427          "   'iterations = [0]'.\n"
03428          ),
03429         AUTHORS( "Claudia Emde" ),
03430         OUT(),
03431         GOUT(),
03432         GOUT_TYPE(),
03433         GOUT_DESC(),
03434         IN( "doit_iteration_counter", "doit_i_field" ),
03435         GIN( "iterations" ),
03436         GIN_TYPE(    "ArrayOfIndex" ),
03437         GIN_DEFAULT( NODEF ),
03438         GIN_DESC("FIXME DOC")
03439       ));
03440 
03441   md_data_raw.push_back
03442     ( MdRecord
03443       ( NAME( "doit_za_grid_optCalc" ),
03444         DESCRIPTION
03445         (
03446          "Zenith angle grid optimization for scattering calculation.\n"
03447          "\n"
03448          "This method optimizes the zenith angle grid. As input it requires \n"
03449          "a radiation field (*doit_i_field*) which is calculated on a very \n"
03450          "fine zenith angle grid (*scat_za_grid*).  Based on this field \n"
03451          "zenith angle grid points are selected, such that the maximum\n"
03452          "difference between the radiation field represented on the very \n"
03453          "fine zenith angle grid and the radiation field represented on the\n"
03454          "optimized grid (*doit_za_grid_opt*) is less than the accuracy \n"
03455          "(*acc*) provided as a keyword. The accuracy must be given in %.\n"
03456          "Between the grid points theradiation field is interpolated \n"
03457          "linearly or polynomially depending on *doit_za_interp*.\n"
03458          "\n"
03459          "Note: The method works only for a 1D atmosphere and for one \n"
03460          "frequency.\n"
03461          ),
03462         AUTHORS( "Claudia Emde" ),
03463         OUT( "doit_za_grid_opt" ),
03464         GOUT(),
03465         GOUT_TYPE(),
03466         GOUT_DESC(),
03467         IN( "doit_i_field", "scat_za_grid", "doit_za_interp" ),
03468         GIN( "acc" ),
03469         GIN_TYPE(    "Numeric" ),
03470         GIN_DEFAULT( NODEF ),
03471         GIN_DESC("FIXME DOC")
03472       ));
03473                                                                                
03474   md_data_raw.push_back
03475     ( MdRecord
03476       ( NAME( "doit_za_interpSet" ),
03477         DESCRIPTION
03478         (
03479          "Define interpolation method for zenith angle dimension.\n"
03480          "\n"
03481          "You can use this method to choose the interpolation method for \n"
03482          "interpolations in the zenith angle dimension. \n"
03483          "By default, linear interpolation is used.\n"
03484          "\n"
03485          "Keyword:\n"
03486          "  interp_method - 'linear' or 'polynomial' \n"
03487          ),
03488         AUTHORS( "Claudia Emde" ),
03489         OUT( "doit_za_interp" ),
03490         GOUT(),
03491         GOUT_TYPE(),
03492         GOUT_DESC(),
03493         IN( "atmosphere_dim" ),
03494         GIN( "interp_method" ),
03495         GIN_TYPE(    "String" ),
03496         GIN_DEFAULT( NODEF ),
03497         GIN_DESC("FIXME DOC")
03498       ));
03499  
03500   md_data_raw.push_back
03501     ( MdRecord
03502       ( NAME("DoNothing"),
03503         DESCRIPTION
03504         (
03505          "As *Ignore* but for agenda output.\n"
03506          "\n"
03507          "This method is handy for use in agendas in order to suppress\n"
03508          "warnings about unused output workspace variables. What it does is:\n"
03509          "Nothing!\n"
03510          "\n"
03511          "To ensure that the variable is already set, the variable must be \n"
03512          "given is both global input and output. An example:\n"
03513          "   DoNothing(emission,emission){}\n"
03514          "Input and output MUST be identical.\n"
03515          "\n"
03516          "Supergeneric output:\n"
03517          "   Any : The input variable.\n"
03518          ),
03519         AUTHORS( "Stefan Buehler" ),
03520         OUT(),
03521         GOUT(      "gout1"    ),
03522         GOUT_TYPE( "Any" ),
03523         GOUT_DESC("FIXME DOC"),
03524         IN(),
03525         GIN(      "gin1"    ),
03526         GIN_TYPE(    "Any" ),
03527         GIN_DEFAULT( NODEF ),
03528         GIN_DESC("FIXME DOC"),
03529         SETMETHOD(      false ),
03530         AGENDAMETHOD(   false ),
03531         SUPPRESSHEADER( true  )
03532       ));
03533 
03534   md_data_raw.push_back
03535     ( MdRecord
03536       ( NAME("emissionPlanck"),
03537         DESCRIPTION
03538         (
03539          "Emission source term for LTE.\n"
03540          "\n"
03541          "Sets *emission* for cases when emission is considered and local\n"
03542          "thermodynamic equilibrium is valid.\n"
03543         ),
03544         AUTHORS( "Patrick Eriksson" ),
03545         OUT( "emission" ),
03546         GOUT(),
03547         GOUT_TYPE(),
03548         GOUT_DESC(),
03549         IN( "f_grid", "rte_temperature" ),
03550         GIN(),
03551         GIN_TYPE(),
03552         GIN_DEFAULT(),
03553         GIN_DESC()
03554       ));
03555 
03556   md_data_raw.push_back
03557     ( MdRecord
03558       ( NAME("Error"),
03559         DESCRIPTION
03560         (
03561          "Issues an error and exits ARTS.\n"
03562          "\n"
03563          "This method can be placed in agendas that must be specified , but\n"
03564          "are expected not to be used for the particular case. An inclusion\n"
03565          "in *surface_prop_agenda* could look like:\n   "
03566          "Error{\"Surface interceptions of propagation path not expected.\"}\n"
03567          "(ignore and other dummy method calls must still be included)\n"
03568          "\n"
03569          "Keywords: \n"
03570          "   msg : String describing the error.\n"
03571         ),
03572         AUTHORS( "Patrick Eriksson" ),
03573         OUT(),
03574         GOUT(),
03575         GOUT_TYPE(),
03576         GOUT_DESC(),
03577         IN(),
03578         GIN( "msg" ),
03579         GIN_TYPE(    "String" ),
03580         GIN_DEFAULT( NODEF ),
03581         GIN_DESC("FIXME DOC")
03582       ));
03583 
03584   md_data_raw.push_back
03585     ( MdRecord
03586       ( NAME("Exit"),
03587         DESCRIPTION
03588         (
03589          "Stops the execution and exits ARTS.\n"
03590          "\n"
03591          "This method is handy if you want to debug one of your control\n"
03592          "files. You can insert it anywhere in the control file. When\n"
03593          "it is reached, it will terminate the program.\n"
03594         ),
03595         AUTHORS( "Patrick Eriksson" ),
03596         OUT(),
03597         GOUT(),
03598         GOUT_TYPE(),
03599         GOUT_DESC(),
03600         IN(),
03601         GIN(),
03602         GIN_TYPE(),
03603         GIN_DEFAULT(),
03604         GIN_DESC()
03605       ));
03606 
03607   md_data_raw.push_back
03608     ( MdRecord
03609       ( NAME("Extract"),
03610         DESCRIPTION
03611         (
03612          "Extract an element from an array.\n"
03613          "\n"
03614          "Copies the element with the given Index from the input\n"
03615          "variable to the output variable.\n"
03616          "\n"
03617          "For a Tensor3 as an input, it copies the page with the given\n"
03618          "Index from the input Tensor3 variable to the output Matrix.\n"
03619          "\n"
03620          "In other words, the selection is always done on the first dimension.\n"
03621         ),
03622         AUTHORS( "Oliver Lemke" ),
03623         OUT(),
03624         GOUT( "needle" ),
03625         GOUT_TYPE( "ArrayOfIndex,        Numeric, Matrix,        Matrix, Tensor3,  Tensor4,        Tensor4, ArrayOfGField3,        GField4" ),
03626         GOUT_DESC("Extracted element."),
03627         IN(),
03628         GIN( "haystack", "index" ),
03629         GIN_TYPE(  "ArrayOfArrayOfIndex, Vector,  ArrayOfMatrix, Tensor3, Tensor4, ArrayOfTensor4, Tensor5, ArrayOfArrayOfGField3, ArrayOfGField4",
03630 
03631                    "Index" ),
03632         GIN_DEFAULT( NODEF, NODEF ),
03633         GIN_DESC("Container.",
03634                  "Position of the element which should be extracted."),
03635         SETMETHOD(      false ),
03636         AGENDAMETHOD(   false ),
03637         SUPPRESSHEADER( true  )
03638       ));
03639 
03640   md_data_raw.push_back
03641     ( MdRecord
03642       ( NAME("ext_matAddGas"),
03643         DESCRIPTION
03644         (
03645          "Add gas absorption to all diagonal elements of extinction matrix.\n"
03646          " \n"
03647          "The task of this method is to sum up the gas absorption of the\n"
03648          "different gas species and add the result to the extinction matrix.\n"
03649          ),
03650         AUTHORS( "Stefan Buehler" ),
03651         OUT( "ext_mat" ),
03652         GOUT(),
03653         GOUT_TYPE(),
03654         GOUT_DESC(),
03655         IN( "ext_mat", "abs_scalar_gas" ),
03656         GIN(),
03657         GIN_TYPE(),
03658         GIN_DEFAULT(),
03659         GIN_DESC()
03660       ));
03661 
03662   md_data_raw.push_back
03663     ( MdRecord
03664       ( NAME("ext_matAddPart"),
03665         DESCRIPTION
03666         (
03667          "The particle extinction is added to *ext_mat* \n"
03668          "\n"
03669          "This function sums up the extinction matrices for all particle \n"
03670          "types weighted with particle number density.\n"
03671          "The resulting extinction matrix is added to the workspace \n"
03672          "variable *ext_mat* \n"
03673          "The output of this method is *ext_mat* (stokes_dim, stokes_dim).\n"
03674          "The inputs are the extinction matrix for the single particle type \n"
03675          "*ext_mat_spt* (part_types, stokes_dim, stokes_dim) and the local \n"
03676          "particle number densities for all particle types namely the \n"
03677          "*pnd_field* (part_types, p_grid, lat_grid, lon_grid ) for given \n"
03678          "*p_grid*, *lat_grid*, and *lon_grid*. The particle types required \n"
03679          "are specified in the control file.\n"
03680          ),
03681         AUTHORS( "Sreerekha T.R." ),
03682         OUT( "ext_mat" ),
03683         GOUT(),
03684         GOUT_TYPE(),
03685         GOUT_DESC(),
03686         IN( "ext_mat", "ext_mat_spt", "pnd_field", "atmosphere_dim", 
03687                "scat_p_index", "scat_lat_index", "scat_lon_index" ),
03688         GIN(),
03689         GIN_TYPE(),
03690         GIN_DEFAULT(),
03691         GIN_DESC()
03692       ));
03693  
03694   md_data_raw.push_back
03695     ( MdRecord
03696       ( NAME("ext_matInit"),
03697         DESCRIPTION
03698         (
03699          "Initialize extinction matrix.\n"
03700          "\n"
03701          "This method is necessary, because all other extinction methods just\n"
03702          "add to the existing extinction matrix. \n"
03703          "\n"
03704          "So, here we have to make it the right size and fill it with 0.\n"
03705          "\n"
03706          "Note, that the matrix is not really a matrix, because it has a\n"
03707          "leading frequency dimension.\n"
03708          ),
03709         AUTHORS( "Stefan Buehler" ),
03710         OUT( "ext_mat" ),
03711         GOUT(),
03712         GOUT_TYPE(),
03713         GOUT_DESC(),
03714         IN( "f_grid", "stokes_dim", "f_index" ),
03715         GIN(),
03716         GIN_TYPE(),
03717         GIN_DEFAULT(),
03718         GIN_DESC()
03719       ));
03720 
03721   md_data_raw.push_back     
03722     ( MdRecord
03723       ( NAME("f_gridFromSensorAMSU"),
03724         DESCRIPTION
03725         (
03726          "Automatically calculate f_grid to match the sensor.\n"
03727          "\n"
03728          "This method is handy if you are simulating an AMSU-type instrument,\n"
03729          "consisting of a few discrete channels.\n"
03730          "\n"
03731          "It calculates f_grid to match the instrument, as given by the local\n"
03732          "oscillator frequencies *lo_multi*, the backend frequencies *f_backend_multi*, and\n"
03733          "the backend channel responses *backend_channel_response_multi*.\n"
03734          "\n"
03735          "You have to specify the desired spacing in the keyword *spacing*, which\n"
03736          "has a default value of 100 MHz. (The actual value is 0.1e9, since our\n"
03737          "unit is Hz.)\n"
03738          "\n"
03739          "The produced grid will not have exactly the requested spacing, but\n"
03740          "will not be coarser than requested. The algorithm starts with the band\n"
03741          "edges, then adds additional points until the spacing is at least as\n"
03742          "fine as requested.\n"
03743          "\n"
03744          "There is a similar method for HIRS-type instruments, see\n"
03745          "*f_gridFromSensorHIRS*.\n"
03746          ),
03747         AUTHORS( "Stefan Buehler" ),
03748         OUT( "f_grid" ),
03749         GOUT(),
03750         GOUT_TYPE(),
03751         GOUT_DESC(),
03752         IN( "lo_multi", "f_backend_multi", "backend_channel_response_multi" ),
03753         GIN( "spacing" ),
03754         GIN_TYPE(    "Numeric" ),
03755         GIN_DEFAULT( ".1e9" ),
03756         GIN_DESC("FIXME DOC")
03757       ));
03758 
03759   md_data_raw.push_back     
03760     ( MdRecord
03761       ( NAME("f_gridFromSensorHIRS"),
03762         DESCRIPTION
03763         (
03764          "Automatically calculate f_grid to match the sensor.\n"
03765          "\n"
03766          "This method is handy if you are simulating a HIRS-type instrument,\n"
03767          "consisting of a few discrete channels.\n"
03768          "\n"
03769          "It calculates f_grid to match the instrument, as given by the nominal\n"
03770          "band frequencies *f_backend* and the spectral channel response\n"
03771          "functions given by *backend_channel_response*.\n"
03772          "\n"
03773          "You have to specify the desired spacing in the keyword *spacing*, which\n"
03774          "has a default value of 5e8 Hz.\n"
03775          "\n"
03776          "The produced grid will not have exactly the requested spacing, but\n"
03777          "will not be coarser than requested. The algorithm starts with the band\n"
03778          "edges, then adds additional points until the spacing is at least as\n"
03779          "fine as requested.\n"
03780          "\n"
03781          "There is a similar method for AMSU-type instruments, see\n"
03782          "*f_gridFromSensorAMSU*.\n"
03783          ),
03784         AUTHORS( "Stefan Buehler" ),
03785         OUT( "f_grid" ),
03786         GOUT(      ),
03787         GOUT_TYPE( ),
03788         GOUT_DESC(),
03789         IN( "f_backend", "backend_channel_response" ),
03790         GIN( "spacing" ),
03791         GIN_TYPE( "Numeric" ),
03792         GIN_DEFAULT( "5e8"),
03793         GIN_DESC("FIXME DOC")
03794       ));
03795 
03796   md_data_raw.push_back     
03797     ( MdRecord
03798       ( NAME("f_gridSelectFIndex"),
03799         DESCRIPTION
03800         (
03801          "Reduce f_grid to the frequency given by f_index.\n"
03802          "\n"
03803          "This is one of the methods necessary to do line by line absorption\n"
03804          "calculations inside *abs_scalar_gas_agenda*.\n"
03805          "\n"
03806          "It reduces the f_grid to only one frequency, the one given by\n"
03807          "f_index. If f_index is -1, then all frequencies are kept. This\n"
03808          "behavior is consistent with *abs_scalar_gasExtractFromLookup*.\n"
03809          ),
03810         AUTHORS( "Stefan Buehler" ),
03811         OUT( "f_grid" ),
03812         GOUT(),
03813         GOUT_TYPE(),
03814         GOUT_DESC(),
03815         IN( "f_grid", "f_index" ),
03816         GIN(),
03817         GIN_TYPE(),
03818         GIN_DEFAULT(),
03819         GIN_DESC()
03820       ));
03821 
03822   md_data_raw.push_back     
03823     ( MdRecord
03824       ( NAME("FlagOff"),
03825         DESCRIPTION
03826         (
03827          "Sets an index variable that acts as an on/off flag to 0.\n"
03828         ),
03829         AUTHORS( "Patrick Eriksson" ),
03830         OUT(),
03831         GOUT(      "gout1"      ),
03832         GOUT_TYPE( "Index" ),
03833         GOUT_DESC("FIXME DOC"),
03834         IN(),
03835         GIN(),
03836         GIN_TYPE(),
03837         GIN_DEFAULT(),
03838         GIN_DESC()
03839       ));
03840 
03841   md_data_raw.push_back     
03842     ( MdRecord
03843       ( NAME("FlagOn"),
03844         DESCRIPTION
03845         (
03846          "Sets an index variable that acts as an on/off flag to 1.\n"
03847         ),
03848         AUTHORS( "Patrick Eriksson" ),
03849         OUT(),
03850         GOUT(      "gout1"      ),
03851         GOUT_TYPE( "Index" ),
03852         GOUT_DESC("FIXME DOC"),
03853         IN(),
03854         GIN(),
03855         GIN_TYPE(),
03856         GIN_DEFAULT(),
03857         GIN_DESC()
03858       ));
03859 
03860   md_data_raw.push_back     
03861     ( MdRecord
03862       ( NAME("f_gridFromGasAbsLookup"),
03863         DESCRIPTION
03864         (
03865          "Sets *f_grid* to the frequency grid of *abs_lookup*.\n"
03866          "\n"
03867          "Must be called between importing/creating raw absorption table and\n"
03868          "call of *abs_lookupAdapt*.\n"
03869         ),
03870         AUTHORS( "Patrick Eriksson" ),
03871         OUT( "f_grid"  ),
03872         GOUT(),
03873         GOUT_TYPE(),
03874         GOUT_DESC(),
03875         IN(  "abs_lookup" ),
03876         GIN(),
03877         GIN_TYPE(),
03878         GIN_DEFAULT(),
03879         GIN_DESC()
03880       ));
03881 
03882   md_data_raw.push_back     
03883     ( MdRecord
03884       ( NAME("ForLoop"),
03885         DESCRIPTION
03886         (
03887          "A simple for loop.\n"
03888          "\n"
03889          "This method is handy when you quickly want to test out a calculation\n"
03890          "with a set of different settings.\n"
03891          "\n"
03892          "It does a for loop from start to stop in steps of step. (Who would\n"
03893          "have guessed that.) For each iteration, the agenda *forloop_agenda* is\n"
03894          "executed. Inside the agenda, the variable *forloop_index* is available\n"
03895          "as index counter. \n"
03896          "\n"
03897          "There are no other inputs to *forloop_agenda*, and also no outputs. That\n"
03898          "means, if you want to get any results out of this loop, you have to\n"
03899          "save it to files (for example with *WriteXMLIndexed*), since\n"
03900          "variables used inside the agenda will only be local.\n"
03901          "\n"
03902          "Note that this kind of for loop is not parallel. \n"
03903          "\n"
03904          "The method is intended for simple testing, not as a replacement of\n"
03905          "*ybatchCalc*. However, it is compatible with *ybatchCalc*, in the sense\n"
03906          "that *ybatchCalc* may occur inside *forloop_agenda*.\n"
03907         ),
03908         AUTHORS( "Stefan Buehler" ),
03909         OUT(),
03910         GOUT(),
03911         GOUT_TYPE(),
03912         GOUT_DESC(),
03913         IN(  "forloop_agenda" ),
03914         GIN( "start", "stop",  "step" ),
03915         GIN_TYPE(    "Index", "Index", "Index" ),
03916         GIN_DEFAULT( NODEF,   NODEF,   NODEF ),
03917         GIN_DESC("FIXME DOC",
03918                  "FIXME DOC",
03919                  "FIXME DOC")
03920       ));
03921 
03922   md_data_raw.push_back
03923     ( MdRecord
03924       ( NAME( "GField1Create" ),
03925         DESCRIPTION
03926         (
03927          "Creates an empty GField1.\n"
03928          "\n"
03929          "If the variable already exists, it'll be reset.\n"
03930         ),
03931         AUTHORS( "Patrick Eriksson" ),
03932         OUT(),
03933         GOUT(      "gfield"       ),
03934         GOUT_TYPE( "GField1" ),
03935         GOUT_DESC( "Gridded field to create." ),
03936         IN(),
03937         GIN(),
03938         GIN_TYPE(),
03939         GIN_DEFAULT(),
03940         GIN_DESC()
03941       ));
03942 
03943   md_data_raw.push_back
03944     ( MdRecord
03945       ( NAME( "GField2Create" ),
03946         DESCRIPTION
03947         (
03948          "Creates an empty GField2.\n"
03949          "\n"
03950          "If the variable already exists, it'll be reset.\n"
03951         ),
03952         AUTHORS( "Patrick Eriksson" ),
03953         OUT(),
03954         GOUT(      "gfield"       ),
03955         GOUT_TYPE( "GField2" ),
03956         GOUT_DESC( "Gridded field to create." ),
03957         IN(),
03958         GIN(),
03959         GIN_TYPE(),
03960         GIN_DEFAULT(),
03961         GIN_DESC()
03962       ));
03963 
03964   md_data_raw.push_back
03965     ( MdRecord
03966       ( NAME( "GField3Create" ),
03967         DESCRIPTION
03968         (
03969          "Creates an empty GField3.\n"
03970          "\n"
03971          "If the variable already exists, it'll be reset.\n"
03972         ),
03973         AUTHORS( "Patrick Eriksson" ),
03974         OUT(),
03975         GOUT(      "gfield"       ),
03976         GOUT_TYPE( "GField3" ),
03977         GOUT_DESC( "Gridded field to create." ),
03978         IN(),
03979         GIN(),
03980         GIN_TYPE(),
03981         GIN_DEFAULT(),
03982         GIN_DESC()
03983       ));
03984 
03985   md_data_raw.push_back
03986     ( MdRecord
03987       ( NAME( "GField4Create" ),
03988         DESCRIPTION
03989         (
03990          "Creates an empty GField4.\n"
03991          "\n"
03992          "If the variable already exists, it'll be reset.\n"
03993         ),
03994         AUTHORS( "Patrick Eriksson" ),
03995         OUT(),
03996         GOUT(      "gfield"       ),
03997         GOUT_TYPE( "GField4" ),
03998         GOUT_DESC( "Gridded field to create." ),
03999         IN(),
04000         GIN(),
04001         GIN_TYPE(),
04002         GIN_DEFAULT(),
04003         GIN_DESC()
04004       ));
04005 
04006   md_data_raw.push_back
04007     ( MdRecord
04008       ( NAME("Ignore"),
04009         DESCRIPTION
04010         (
04011          "Ignore a workspace variable.\n"
04012          "\n"
04013          "This method is handy for use in agendas in order to suppress warnings\n"
04014          "about unused input workspace variables. What it does is: Nothing!\n"
04015          "In other words, it just ignores the variable it is called on.\n"
04016          "\n"
04017          "This is a supergeneric method. It can ignore any workspace variable\n"
04018          "you want.\n"
04019          "\n"
04020          "Usage example:\n"
04021          "\n"
04022          "AgendaSet(els_agenda){\n"
04023          "  Ignore(ls_sigma){}\n"
04024          "  elsLorentz{}\n"
04025          "}\n"
04026          "\n"
04027          "Without Ignore you would get an error message, because els_agenda is\n"
04028          "supposed to use the Doppler width *ls_sigma*, but the Lorentz lineshape\n"
04029          "*elsLorentz* does not need it.\n"
04030          "\n"
04031          "Supergeneric input:\n"
04032          "   Any : The input variable.\n"
04033          ),
04034         AUTHORS( "Stefan Buehler" ),
04035         OUT(),
04036         GOUT(),
04037         GOUT_TYPE(),
04038         GOUT_DESC(),
04039         IN(),
04040         GIN(       "gin1"    ),
04041         GIN_TYPE(     "Any" ),
04042         GIN_DEFAULT(  NODEF ),
04043         GIN_DESC("FIXME DOC"),
04044         SETMETHOD(      false ),
04045         AGENDAMETHOD(   false ),
04046         SUPPRESSHEADER( true  )
04047       ));
04048 
04049   md_data_raw.push_back     
04050     ( MdRecord
04051       ( NAME("INCLUDE"),
04052         DESCRIPTION
04053         (
04054          "Includes the contents of another controlfile.\n"
04055          "\n"
04056          "The INCLUDE statement inserts the contents of the controlfile\n"
04057          "with the given name into the current controlfile.\n"
04058          "If the filename is given without path information, ARTS will\n"
04059          "first search for the file in all directories specified with the\n"
04060          "-I (see arts -h) commandline option and then in directories given\n"
04061          "in the environment variable ARTS_INCLUDE_PATH. In the environment\n"
04062          "variable multiple paths have to be separated by colons.\n"
04063          "\n"
04064          "Note that INCLUDE is not a workspace method and thus the\n"
04065          "syntax is different:\n"
04066          "\n"
04067          "Arts {\n"
04068          "  INCLUDE \"general.arts\"\n"
04069          "}\n"
04070          "\n"
04071          "Includes can also be nested. In the example above general.arts\n"
04072          "can contain further includes which will then be treated\n"
04073          "the same way.\n"
04074          "\n"
04075          "The idea behind this mechanism is that you can write common settings\n"
04076          "for a bunch of calculations into one file. Then, you can create\n"
04077          "several controlfiles which include the basic settings and tweak them\n"
04078          "for different cases. When you decide to make changes to your setup\n"
04079          "that should apply to all calculations, you only have to make a\n"
04080          "single change in the include file instead of modifying all your\n"
04081          "controlfiles.\n"
04082         ),
04083         AUTHORS( "Oliver Lemke" ),
04084         OUT(),
04085         GOUT(),
04086         GOUT_TYPE(),
04087         GOUT_DESC(),
04088         IN(),
04089         GIN(),
04090         GIN_TYPE(),
04091         GIN_DEFAULT(),
04092         GIN_DESC()
04093       ));
04094 
04095   md_data_raw.push_back
04096     ( MdRecord
04097       ( NAME( "IndexCreate" ),
04098         DESCRIPTION
04099         (
04100          "Creates an Index variable.\n"
04101          "\n"
04102          "If the variable already exists, it'll be reset.\n"
04103          "\n"
04104          "Generic output: \n"
04105          "   Index: New Index variable.\n"
04106         ),
04107         AUTHORS( "Oliver Lemke" ),
04108         OUT(),
04109         GOUT(      "gout1"      ),
04110         GOUT_TYPE( "Index" ),
04111         GOUT_DESC("FIXME DOC"),
04112         IN(),
04113         GIN(),
04114         GIN_TYPE(),
04115         GIN_DEFAULT(),
04116         GIN_DESC()
04117       ));
04118 
04119   md_data_raw.push_back     
04120     ( MdRecord
04121       ( NAME("IndexSet"),
04122         DESCRIPTION
04123         (
04124          "Sets an index workspace variable to the given value. \n"
04125          "\n"
04126          "Generic output: \n"
04127          "   Index : The index variable to be set. \n"
04128          "\n"
04129          "Keywords:\n"
04130          "   value : A positive integer.\n" 
04131         ),
04132         AUTHORS( "Patrick Eriksson" ),
04133         OUT(),
04134         GOUT(      "gout1"      ),
04135         GOUT_TYPE( "Index" ),
04136         GOUT_DESC("FIXME DOC"),
04137         IN(),
04138         GIN( "value" ),
04139         GIN_TYPE(    "Index" ),
04140         GIN_DEFAULT( NODEF ),
04141         GIN_DESC("FIXME DOC"),
04142         SETMETHOD( true )
04143       ));
04144 
04145   md_data_raw.push_back     
04146     ( MdRecord
04147       ( NAME("IndexStep"),
04148         DESCRIPTION
04149         (
04150          "Performs GOUT_TYPE = GIN_TYPE + 1\n"
04151          "\n"
04152          "Input and output can be same variable.\n"
04153         ),
04154         AUTHORS( "Patrick Eriksson" ),
04155         OUT(),
04156         GOUT(      "gout1"      ),
04157         GOUT_TYPE( "Index" ),
04158         GOUT_DESC("FIXME DOC"),
04159         IN(),
04160         GIN(      "gin1"      ),
04161         GIN_TYPE(    "Index" ),
04162         GIN_DEFAULT( NODEF   ),
04163         GIN_DESC("FIXME DOC")
04164       ));
04165 
04166   md_data_raw.push_back     
04167     ( MdRecord
04168       ( NAME("InterpAtmFieldToRteGps"),
04169         DESCRIPTION
04170         (
04171          "Scalar interpolation of atmospheric fields.\n" 
04172          "\n"
04173          "The position is specified by the combination of *rte_gp_p*, \n"
04174          "*rte_gp_lat* and *rte_gp_lon*.\n"
04175          "\n"
04176          "Generic output: \n"
04177          "   Numeric : Value obtained by interpolation. \n"
04178          "\n"
04179          "Generic input:\n"
04180          "   Tensor3 : Field to interpolate.\n"
04181         ),
04182         AUTHORS( "Patrick Eriksson" ),
04183         OUT(),
04184         GOUT(      "gout1"        ),
04185         GOUT_TYPE( "Numeric" ),
04186         GOUT_DESC("FIXME DOC"),
04187         IN( "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", 
04188                "rte_gp_p", "rte_gp_lat", "rte_gp_lon" ),
04189         GIN(      "gin1"        ),
04190         GIN_TYPE(    "Tensor3" ),
04191         GIN_DEFAULT( NODEF     ),
04192         GIN_DESC("FIXME DOC")
04193       ));
04194   
04195   md_data_raw.push_back     
04196     ( MdRecord
04197       ( NAME("InterpSurfaceEmissivityFieldIncLatLon"),
04198         DESCRIPTION
04199         (
04200          "Interpolation of surface emissivity specified as a function of\n"
04201          "incidence angle, latitude and longitude.\n"
04202          "\n"
04203          "The surface emissivity field has here three dimension, with\n"
04204          "incidence angle as first/column dimension, latitude as second/row\n"
04205          "dimension and longitude as third/page dimension. Grid names must\n"
04206          "be set exactly to \"Incidence angle\", \"Latitude\" and\n"
04207          "\"Longitude\". No extrapolation is allowed.\n"
04208          "\n"
04209          "For 1D cases it is expected that the latitude and longitude grids\n"
04210          "have both a length of 1. For 2D the same apllies to the longitude\n"
04211          "grid.\n"
04212          "\n"
04213          "This method can be used togetehr with e.g.\n"
04214          "*surfaceFlatSingleEmissivity*.\n" 
04215         ),
04216         AUTHORS( "Patrick Eriksson" ),
04217         OUT(),
04218         GOUT(      "outvalue"        ),
04219         GOUT_TYPE( "Numeric" ),
04220         GOUT_DESC( "Value obtained by interpolation" ),
04221         IN( "atmosphere_dim", "rte_pos", "rte_los" ),
04222         GIN(      "gfield"       ),
04223         GIN_TYPE( "GField3" ),
04224         GIN_DEFAULT( NODEF    ),
04225         GIN_DESC( "Gridded field to be interpolated." )
04226       ));
04227 
04228   md_data_raw.push_back     
04229     ( MdRecord
04230       ( NAME("InterpSurfaceFieldToRteGps"),
04231         DESCRIPTION
04232         (
04233          "Scalar interpolation of surface fields.\n" 
04234          "\n"
04235          "The position is specified by the combination of *rte_gp_lat* and \n"
04236          "*rte_gp_lon*.\n"
04237          "\n"
04238          "Generic output: \n"
04239          "   Numeric : Value obtained by interpolation. \n"
04240          "\n"
04241          "Generic input:\n"
04242          "   Matrix : Field to interpolate.\n"
04243         ),
04244         AUTHORS( "Patrick Eriksson" ),
04245         OUT(),
04246         GOUT(      "gout1"        ),
04247         GOUT_TYPE( "Numeric" ),
04248         GOUT_DESC("FIXME DOC"),
04249         IN( "atmosphere_dim", "lat_grid", "lon_grid", 
04250                "rte_gp_lat", "rte_gp_lon" ),
04251         GIN(      "gin1"       ),
04252         GIN_TYPE(    "Matrix" ),
04253         GIN_DEFAULT( NODEF    ),
04254         GIN_DESC("FIXME DOC")
04255       ));
04256   
04257   md_data_raw.push_back
04258     ( MdRecord
04259       ( NAME( "iyInterpCloudboxField" ),
04260         DESCRIPTION
04261         (
04262          "Interpolates the intensity field of the cloud box.\n"
04263          "\n"
04264          "This is the standard method to put in *iy_cloudbox_agenda* if the\n"
04265          "the scattering inside the cloud box is handled by the DOIT method.\n"
04266          "\n"
04267          "The intensity field is interpolated to the position and direction\n"
04268          "given (specified by *rte_XXX*). A linear interpolation is used for\n"
04269          "all dimensions.\n"
04270          "\n"
04271          "The intensity field on the cloux box boundaries is provided by\n"
04272          "*scat_i_p/lat/lon* and these variables are interpolated if the.\n"
04273          "given position is at any boundary.\n"
04274          "\n"
04275          "Interpolation of the internal field is not yet possible.\n"
04276          ),
04277         AUTHORS( "Claudia Emde" ),
04278         OUT( "iy" ),
04279         GOUT(),
04280         GOUT_TYPE(),
04281         GOUT_DESC(),
04282         IN( "scat_i_p", "scat_i_lat", "scat_i_lon", "doit_i_field1D_spectrum",
04283                "rte_gp_p", "rte_gp_lat", "rte_gp_lon", "rte_los",  "cloudbox_on",
04284                "cloudbox_limits", "atmosphere_dim", "stokes_dim", "scat_za_grid",
04285                "scat_aa_grid", "f_grid" ),
04286         GIN(),
04287         GIN_TYPE(),
04288         GIN_DEFAULT(),
04289         GIN_DESC()
04290       ));
04291 
04292   md_data_raw.push_back
04293     ( MdRecord
04294       ( NAME( "iyInterpPolyCloudboxField" ),
04295         DESCRIPTION
04296         (
04297          "As *iyInterpCloudboxField* but performs cubic interpolation.\n"
04298          "\n"
04299          "Works so far only for 1D cases, and accordingly a cubic\n"
04300          "interpolation along *scat_za_grid* is performed.\n"
04301          ),
04302         AUTHORS( "Claudia Emde" ),
04303         OUT( "iy" ),
04304         GOUT(),
04305         GOUT_TYPE(),
04306         GOUT_DESC(),
04307         IN( "scat_i_p", "scat_i_lat", "scat_i_lon", "doit_i_field1D_spectrum",
04308                "rte_gp_p", "rte_gp_lat",
04309                "rte_gp_lon", "rte_los",  "cloudbox_on", "cloudbox_limits",
04310                "atmosphere_dim", "stokes_dim", "scat_za_grid", "scat_aa_grid", 
04311                "f_grid" ),
04312         GIN(),
04313         GIN_TYPE(),
04314         GIN_DEFAULT(),
04315         GIN_DESC()
04316       ));
04317 
04318   md_data_raw.push_back
04319     ( MdRecord
04320       ( NAME( "jacobianAddAbsSpecies" ),
04321         DESCRIPTION
04322         (
04323          "Adds a absorption species as a retrieval quantity to the Jacobian.\n"
04324          "\n"
04325          "For 1D or 2D calculations the latitude and/or longitude grid of\n"
04326          "the retrieval field should be set to zero length.\n"
04327          "\n"
04328          "There are two possible calculation methods:\n"
04329          "   \"analytical\"   : (semi-)analytical expressions are used\n"
04330          "   \"perturbation\" : pure numerical perturbations are used\n"
04331          "\n"
04332          "The retrieval unit can be:\n"
04333          "   \"vmr\" : volume mixing ratio \n"
04334          "   \"nd\"  : number density \n"
04335          "   \"rel\" : relative unit (e.g. 1.1 means 10% more of the gas) \n"
04336          "\n"
04337          "For perturbation calculations the size of the perturbation is set\n"
04338          "by the user. The unit of the perturbation size is identical to \n"
04339          "the retrieval unit.\n"
04340          "\n"
04341          "Generic input:\n"
04342          "  Vector : The pressure grid of the retrieval field.\n"
04343          "  Vector : The latitude grid of the retrieval field.\n"
04344          "  Vector : The longitude grid of the retrieval field.\n"
04345          "\n"
04346          "Keywords:\n"
04347          "  species : The SpeciesTag of the retrieval quantity.\n"
04348          "  method  : Calculation method. See above.\n"
04349          "  unit    : Retrieval unit. See above.\n"
04350          "  dx      : Size of perturbation.\n"
04351         ),
04352         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
04353         OUT( "jacobian_quantities", "jacobian_agenda" ),
04354         GOUT(),
04355         GOUT_TYPE(),
04356         GOUT_DESC(),
04357         IN( "jacobian_quantities", "jacobian_agenda", "jacobian", 
04358             "atmosphere_dim", "p_grid", "lat_grid", "lon_grid" ),
04359         GIN( "gin1", "gin2", "gin3", "species", "method", "unit","dx" ),
04360         GIN_TYPE( "Vector", "Vector", "Vector", "String", "String", "String", 
04361                   "Numeric" ),
04362         GIN_DEFAULT( NODEF, NODEF, NODEF, NODEF, "analytical", "rel", "0.001" ),
04363         GIN_DESC("FIXME DOC",
04364                  "FIXME DOC",
04365                  "FIXME DOC",
04366                  "FIXME DOC",
04367                  "FIXME DOC",
04368                  "FIXME DOC",
04369                  "FIXME DOC"),
04370         SETMETHOD(      false ),
04371         AGENDAMETHOD(   false ),
04372         SUPPRESSHEADER( false ),
04373         PASSWORKSPACE(  true )
04374       ));
04375          
04376   md_data_raw.push_back
04377     ( MdRecord
04378       ( NAME("jacobianAddPointing"),
04379         DESCRIPTION
04380         (
04381          "...\n"
04382         ),
04383         AUTHORS( "Patrick Eriksson" ),
04384         OUT( "jacobian_quantities", "jacobian_agenda" ),
04385         GOUT(),
04386         GOUT_TYPE(),
04387         GOUT_DESC(),
04388         IN( "jacobian_quantities", "jacobian_agenda", "jacobian", 
04389             "sensor_pos", "sensor_time" ),
04390         GIN( "dza", "poly_order" ),
04391         GIN_TYPE( "Numeric", "Index" ),
04392         GIN_DEFAULT( "0.01", "0" ),
04393         GIN_DESC( "FIXME DOC", "FIXME DOC" ),
04394         SETMETHOD(      false ),
04395         AGENDAMETHOD(   false ),
04396         SUPPRESSHEADER( false ),
04397         PASSWORKSPACE(  true )
04398       ));
04399 
04400   md_data_raw.push_back
04401     ( MdRecord
04402       ( NAME("jacobianAddPolyfit"),
04403         DESCRIPTION
04404         (
04405          "...\n"
04406         ),
04407         AUTHORS( "Patrick Eriksson" ),
04408         OUT( "jacobian_quantities", "jacobian_agenda" ),
04409         GOUT(),
04410         GOUT_TYPE(),
04411         GOUT_DESC(),
04412         IN( "jacobian_quantities", "jacobian_agenda", "jacobian", 
04413             "sensor_response_pol_grid", "sensor_response_f_grid",
04414             "sensor_response_za_grid", "sensor_pos" ),
04415         GIN( "poly_order", "no_pol_variation", "no_za_variation", 
04416              "no_mblock_variation" ),
04417         GIN_TYPE( "Index", "Index", "Index", "Index" ),
04418         GIN_DEFAULT( NODEF, "0", "0", "0" ),
04419         GIN_DESC("FIXME DOC", "FIXME DOC", "FIXME DOC", "FIXME DOC"),
04420         SETMETHOD(      false ),
04421         AGENDAMETHOD(   false  ),
04422         SUPPRESSHEADER( false ),
04423         PASSWORKSPACE(  true )
04424       ));
04425 
04426   md_data_raw.push_back
04427     ( MdRecord
04428       ( NAME( "jacobianAddTemperature" ),
04429         DESCRIPTION
04430         (
04431          "Adds atmospheric temperatures as a retrieval quantity.\n"
04432          "\n"
04433          "The calculations can be performed by (semi-)analytical expressions\n"
04434          "or perturbations. Hydrostatic equilibrium can be included for\n"
04435          "perturbation calculations. These choices are selected by\n"
04436          "corresponding general input variables.\n"
04437          "\n"
04438          "For 1D or 2D calculations the latitude and/or longitude grid of\n"
04439          "the retrieval field should be set to zero length.\n"
04440          "The WSM *jacobianCalcTemperature* is automatically added to\n"
04441          "*jacobian_agenda*.\n"
04442         ),
04443         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
04444         OUT( "jacobian_quantities", "jacobian_agenda" ),
04445         GOUT(),
04446         GOUT_TYPE(),
04447         GOUT_DESC(),
04448         IN( "jacobian_quantities", "jacobian_agenda", "jacobian", 
04449             "atmosphere_dim", "p_grid", "lat_grid", "lon_grid" ),
04450         GIN( "gin1", "gin2", "gin3", "hse", "method", "dx" ),
04451         GIN_TYPE( "Vector", "Vector", "Vector", "String", "String", "Numeric" ),
04452         GIN_DEFAULT( NODEF, NODEF, NODEF, "off", "analytical", "1" ),
04453         GIN_DESC("FIXME DOC",
04454                  "FIXME DOC",
04455                  "FIXME DOC",
04456                  "FIXME DOC",
04457                  "FIXME DOC",
04458                  "FIXME DOC"),
04459         SETMETHOD(      false ),
04460         AGENDAMETHOD(   false ),
04461         SUPPRESSHEADER( false ),
04462         PASSWORKSPACE(  true )
04463       ));
04464 
04465   /*
04466   md_data_raw.push_back
04467     ( MdRecord
04468       ( NAME( "jacobianAddParticle" ),
04469         DESCRIPTION
04470         (
04471          "Add particle number density as retrieval quantity to the Jacobian.\n"
04472          "\n"
04473          "The Jacobian is done by perturbation calculation by adding elements\n"
04474          "of *pnd_field_perturb* to *pnd_field*. Only 1D and 3D atmospheres\n"
04475          "can be handled by this method.\n"
04476          "\n"
04477          "The perturbation field and the unit of it are defined outside ARTS.\n"
04478          "This method only returns the difference between the reference and\n"
04479          "perturbed spectra. The division by the size of the perturbation\n"
04480          "also has to be done outside ARTS.\n"
04481          "The unit of the particle jacobian is the same as for *y*.\n"
04482          "\n"
04483          "Generic input:\n"
04484          "  Vector : The pressure grid of the retrieval field.\n"
04485          "  Vector : The latitude grid of the retrieval field.\n"
04486          "  Vector : The longitude grid of the retrieval field.\n"
04487         ),
04488         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
04489         OUT( "jacobian_quantities", "jacobian_agenda" ),
04490         GOUT(),
04491         GOUT_TYPE(),
04492         GOUT_DESC(),
04493         IN( "jacobian", "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", 
04494                "pnd_field", "pnd_field_perturb", "cloudbox_limits" ),
04495         GIN(      "gin1"      , "gin2"      , "gin3"       ),
04496         GIN_TYPE(    "Vector", "Vector", "Vector" ),
04497         GIN_DEFAULT( NODEF   , NODEF   , NODEF    ),
04498         GIN_DESC("FIXME DOC",
04499                  "FIXME DOC",
04500                  "FIXME DOC")
04501       ));
04502   */
04503   
04504   md_data_raw.push_back
04505     ( MdRecord
04506       ( NAME( "jacobianCalc" ),
04507         DESCRIPTION
04508         (
04509          "Executes *jacobian_agenda* to calculate (parts of) *jacobian*."
04510          "\n"
04511          "It is important that *y* holds the original output of *RteCalc*\n"
04512          "as the methods called performs perturbations to obtain cahnges in\n"
04513          "*y*.\n"
04514         ),
04515         AUTHORS( "Mattias Ekstrom" ),
04516         OUT( "jacobian" ),
04517         GOUT(),
04518         GOUT_TYPE(),
04519         GOUT_DESC(),
04520         IN( "jacobian_agenda", "jacobian_indices" ),
04521         GIN(),
04522         GIN_TYPE(),
04523         GIN_DEFAULT(),
04524         GIN_DESC()
04525       ));
04526 
04527   md_data_raw.push_back
04528     ( MdRecord
04529       ( NAME("jacobianCalcAbsSpecies"),
04530         DESCRIPTION
04531         (
04532         "Calculates absorption species jacobians by perturbations.\n"
04533         "\n"
04534         "This function is added to *jacobian_agenda* by jacobianAddAbsSpecies\n"
04535         "and should normally not be called by the user.\n"
04536         ),
04537         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
04538         OUT( "jacobian" ),
04539         GOUT(),
04540         GOUT_TYPE(),
04541         GOUT_DESC(),
04542         IN( "jacobian_y_agenda", "jacobian_quantities", "jacobian_indices", 
04543             "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", "abs_species", 
04544             "vmr_field", "t_field", "pnd_field", "sensor_los", "y" ),
04545         GIN( "species" ),
04546         GIN_TYPE(    "String" ),
04547         GIN_DEFAULT( NODEF ),
04548         GIN_DESC("FIXME DOC"),
04549         SETMETHOD( true )
04550       ));
04551 
04552   md_data_raw.push_back
04553     ( MdRecord
04554       ( NAME("jacobianCalcPointing"),
04555         DESCRIPTION
04556         (
04557         "Calculates pointing deviation jacobians by perturnbations.\n"
04558         "\n"
04559         "This function is added to *jacobian_agenda* by jacobianAddPointing\n"
04560         "and should normally not be called by the user.\n"
04561         ),
04562         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
04563         OUT( "jacobian" ),
04564         GOUT(),
04565         GOUT_TYPE(),
04566         GOUT_DESC(),
04567         IN( "jacobian_y_agenda", "jacobian_quantities", "jacobian_indices", 
04568             "vmr_field", "t_field", "pnd_field", "sensor_los", "sensor_time",
04569             "y" ),
04570         GIN(),
04571         GIN_TYPE(),
04572         GIN_DEFAULT(),
04573         GIN_DESC()
04574       ));
04575 
04576   md_data_raw.push_back
04577     ( MdRecord
04578       ( NAME("jacobianCalcPolyfit"),
04579         DESCRIPTION
04580         (
04581         "Calculates jacobians for polynomial baseline fit.\n"
04582         "\n"
04583         "This function is added to *jacobian_agenda* by jacobianAddPolyfit\n"
04584         "and should normally not be called by the user.\n"
04585         ),
04586         AUTHORS( "Patrick Eriksson" ),
04587         OUT( "jacobian" ),
04588         GOUT(),
04589         GOUT_TYPE(),
04590         GOUT_DESC(),
04591         IN( "jacobian_quantities", "jacobian_indices", 
04592             "sensor_response_pol_grid", "sensor_response_f_grid", 
04593             "sensor_response_za_grid", "sensor_pos" ),
04594         GIN( "poly_coeff" ),
04595         GIN_TYPE( "Index" ),
04596         GIN_DEFAULT( NODEF ),
04597         GIN_DESC( "FIXME DOC" ),
04598         SETMETHOD( true )
04599       ));
04600 
04601   md_data_raw.push_back
04602     ( MdRecord
04603       ( NAME("jacobianCalcTemperature"),
04604         DESCRIPTION
04605         (
04606         "Calculates atmospheric temperature jacobians by perturbations.\n"
04607         "\n"
04608         "This function is added to *jacobian_agenda* by jacobianAddTemperature\n"
04609         "and should normally not be called by the user.\n"
04610         ),
04611         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
04612         OUT( "jacobian" ),
04613         GOUT(),
04614         GOUT_TYPE(),
04615         GOUT_DESC(),
04616         IN( "jacobian_y_agenda", "jacobian_quantities", "jacobian_indices", 
04617             "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", 
04618             "vmr_field", "t_field", "pnd_field", "sensor_los", "y" ),
04619         GIN(),
04620         GIN_TYPE(),
04621         GIN_DEFAULT(),
04622         GIN_DESC()
04623       ));
04624 
04625   /*        
04626   md_data_raw.push_back
04627     ( MdRecord
04628       ( NAME("jacobianCalcParticle"),
04629         DESCRIPTION
04630         (
04631         "Calculates particle number densities jacobians by perturbations\n"
04632         "\n"
04633         "This function is added to *jacobian_agenda* by jacobianAddParticle\n"
04634         "and should normally not be called by the user.\n"
04635         ),
04636         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
04637         OUT( "jacobian" ),
04638         GOUT(),
04639         GOUT_TYPE(),
04640         GOUT_DESC(),
04641         IN( "y", "jacobian_quantities", "jacobian_indices", "pnd_field_perturb",
04642                "jacobian_particle_update_agenda",
04643                "ppath_step_agenda", "rte_agenda", "iy_space_agenda", 
04644                "surface_prop_agenda", "iy_cloudbox_agenda", "atmosphere_dim", 
04645                "p_grid", "lat_grid", "lon_grid", "z_field", "t_field", "vmr_field",
04646                "r_geoid", "z_surface", 
04647                "cloudbox_on", "cloudbox_limits", "pnd_field",
04648                "sensor_response", "sensor_pos", "sensor_los", "f_grid", 
04649                "stokes_dim", "antenna_dim", "mblock_za_grid", "mblock_aa_grid" ),
04650         GIN(),
04651         GIN_TYPE(),
04652         GIN_DEFAULT(),
04653         GIN_DESC()
04654       ));
04655         
04656   */
04657 
04658   md_data_raw.push_back
04659     ( MdRecord
04660       ( NAME("jacobianClose"),
04661         DESCRIPTION
04662         (
04663          "Close the array of retrieval quantities and prepare for calculation\n"
04664          "of the Jacobian matrix.\n"
04665          "\n"
04666          "This function closes the *jacobian_quantities* array and sets the\n"
04667          "correct size of *jacobian*. Retrieval quantities should not be\n"
04668          "added after a call to this WSM.\n"
04669          "\n"
04670          "To define the final *jacobian* the number of spectra is needed.\n"
04671          "Therefor the number of measurement blocks, taken from *sensor_pos*\n"
04672          "and the size of *sensor_response* has to be defined.\n"
04673         ),
04674         AUTHORS( "Mattias Ekstrom" ),
04675         OUT( "jacobian", "jacobian_indices" ),
04676         GOUT(),
04677         GOUT_TYPE(),
04678         GOUT_DESC(),
04679         IN( "jacobian_quantities", "sensor_pos", "sensor_response" ),
04680         GIN(),
04681         GIN_TYPE(),
04682         GIN_DEFAULT(),
04683         GIN_DESC()
04684       ));
04685 
04686   md_data_raw.push_back
04687     ( MdRecord
04688       ( NAME("jacobianInit"),
04689         DESCRIPTION
04690         (
04691          "Initialises the variables connected to the Jacobian matrix.\n"
04692          "\n"
04693          "This function initialises the *jacobian_quantities* array so\n"
04694          "that retrieval quantities can be added to it, therefor it has\n"
04695          "to be called before any subsequent calls to jacobianAddGas\n"
04696          "jacobianAddTemperature, jacobianAddPointing or similar methods.\n"
04697          "\n"
04698          "The Jacobian quantities are initialised to be empty.\n"
04699         ),
04700         AUTHORS( "Mattias Ekstrom" ),
04701         OUT( "jacobian", "jacobian_quantities", "jacobian_indices", 
04702              "jacobian_agenda" ),
04703         GOUT(),
04704         GOUT_TYPE(),
04705         GOUT_DESC(),
04706         IN(),
04707         GIN(),
04708         GIN_TYPE(),
04709         GIN_DEFAULT(),
04710         GIN_DESC()
04711       ));
04712 
04713   md_data_raw.push_back
04714     ( MdRecord
04715       ( NAME("jacobianOff"),
04716         DESCRIPTION
04717         (
04718          "Makes mandatory initialisation of some jacobian variables.\n"
04719          "\n"
04720          "Some jacobian WSVs must be initilised even if no such calculations\n"
04721          "will be performed and this is handled with this method. That is,\n"
04722          "this method must be called when no jacobians will be calculated.\n"
04723         ),
04724         AUTHORS( "Patrick Eriksson" ),
04725         OUT( "jacobian", "jacobian_quantities", "jacobian_indices", 
04726              "jacobian_unit" ),
04727         GOUT(),
04728         GOUT_TYPE(),
04729         GOUT_DESC(),
04730         IN(),
04731         GIN(),
04732         GIN_TYPE(),
04733         GIN_DEFAULT(),
04734         GIN_DESC()
04735       ));
04736 
04737   md_data_raw.push_back
04738     ( MdRecord
04739       ( NAME( "jacobianUnit" ),
04740         DESCRIPTION
04741         (
04742          "Conversion of *jacobian* to other spectral units.\n"
04743          "\n"
04744          "Works as *yUnit* but operates on *jacobian* and conversion\n "
04745          "determined by *jacobian_unit*.\n"
04746         ),
04747         AUTHORS( "Patrick Eriksson" ),
04748         OUT( "jacobian" ),
04749         GOUT(),
04750         GOUT_TYPE(),
04751         GOUT_DESC(),
04752         IN( "jacobian", "jacobian_unit", "y_unit", "y_f" ),
04753         GIN(),
04754         GIN_TYPE(),
04755         GIN_DEFAULT(),
04756         GIN_DESC()
04757         ));
04758 
04759   md_data_raw.push_back     
04760     ( MdRecord
04761       ( NAME("MatrixCBR"),
04762         DESCRIPTION
04763         (
04764          "Sets a matrix to hold cosmic background radiation (CBR).\n"
04765          "\n"
04766          "The CBR is assumed to be un-polarized and Stokes components 2-4\n"
04767          "are zero. Number of Stokes components, that equals the number \n"
04768          "of columns in the created matrix, is determined by *stokes_dim. \n"
04769          "The number of rows in the created matrix equals the length of the \n"
04770          "given frequency vector. \n"
04771          "\n"
04772          "The cosmic radiation is modelled as blackbody radiation for the \n"
04773          "temperature given by the global constant COSMIC_BG_TEMP, set in \n"
04774          "the file constants.cc. The frequencies are taken from the generic \n"
04775          "input vector:\n"
04776          "   MatrixCBR(iy_space,f_grid){} \n"
04777          "\n"
04778          "Generic output: \n"
04779          "   Matrix : Matrix with cosmic background radiation. \n"
04780          "\n"
04781          "Generic input: \n"
04782          "   Vector : A set of frequencies.\n"
04783         ),
04784         AUTHORS( "Patrick Eriksson" ),
04785         OUT(),
04786         GOUT(      "gout1"       ),
04787         GOUT_TYPE( "Matrix" ),
04788         GOUT_DESC("FIXME DOC"),
04789         IN( "stokes_dim" ),
04790         GIN(      "gin1"       ),
04791         GIN_TYPE(    "Vector" ),
04792         GIN_DEFAULT( NODEF    ),
04793         GIN_DESC("FIXME DOC")
04794       ));
04795 
04796   md_data_raw.push_back
04797     ( MdRecord
04798       ( NAME( "MatrixCreate" ),
04799         DESCRIPTION
04800         (
04801          "Creates an empty Matrix.\n"
04802          "\n"
04803          "If the variable already exists, it'll be reset.\n"
04804          "\n"
04805          "Generic output: \n"
04806          "   Matrix: New empty Matrix.\n"
04807         ),
04808         AUTHORS( "Oliver Lemke" ),
04809         OUT(),
04810         GOUT(      "gout1"       ),
04811         GOUT_TYPE( "Matrix" ),
04812         GOUT_DESC("FIXME DOC"),
04813         IN(),
04814         GIN(),
04815         GIN_TYPE(),
04816         GIN_DEFAULT(),
04817         GIN_DESC()
04818       ));
04819 
04820   md_data_raw.push_back
04821     ( MdRecord
04822       ( NAME("MatrixMatrixMultiply"),
04823         DESCRIPTION
04824         (
04825          "Multiply a Matrix with another Matrix and store the result in the result\n"
04826          "Matrix.\n"
04827          "\n"
04828          "This just computes the normal Matrix-Matrix product, Y=M*X. It is ok\n"
04829          "if Y and X are the same Matrix. This function is handy for\n"
04830          "multiplying the H Matrix to batch spectra.\n"
04831          "\n"
04832          "Generic output:\n"
04833          "   Matrix : The result of the multiplication (dimension mxc).\n"
04834          "\n"
04835          "Generic input:\n"
04836          "   Matrix : The Matrix to multiply (dimension mxn).\n"
04837          "   Matrix : The original Matrix (dimension nxc).\n"
04838         ),
04839         AUTHORS( "Stefan Buehler" ),
04840         OUT(),
04841         GOUT(      "gout1"       ),
04842         GOUT_TYPE( "Matrix" ),
04843         GOUT_DESC("FIXME DOC"),
04844         IN(),
04845         GIN(      "gin1"      , "gin2"       ),
04846         GIN_TYPE(    "Matrix", "Matrix" ),
04847         GIN_DEFAULT( NODEF   , NODEF    ),
04848         GIN_DESC("FIXME DOC",
04849                  "FIXME DOC")
04850       ));
04851 
04852   md_data_raw.push_back
04853     ( MdRecord
04854       ( NAME("Matrix1ColFromVector"),
04855         DESCRIPTION
04856         (
04857          "Forms a matrix containing 1 column from a vector.\n"
04858          "\n"
04859          "Generic output: \n"
04860          "   Matrix : The matrix to be created. \n"
04861          "\n"
04862          "Generic input: \n"
04863          "   Vector : The vector to be copied.\n"
04864         ),
04865         AUTHORS( "Mattias Ekstrom" ),
04866         OUT(),
04867         GOUT(      "gout1"       ),
04868         GOUT_TYPE( "Matrix" ),
04869         GOUT_DESC("FIXME DOC"),
04870         IN(),
04871         GIN(      "gin1"       ),
04872         GIN_TYPE(    "Vector" ),
04873         GIN_DEFAULT( NODEF    ),
04874         GIN_DESC("FIXME DOC")
04875       ));
04876 
04877   md_data_raw.push_back
04878     ( MdRecord
04879       ( NAME("Matrix2ColFromVectors"),
04880         DESCRIPTION
04881         (
04882          "Forms a matrix containing 2 columns from two vectors.\n"
04883          "\n"
04884          "The vectors are put as columns in the matrix in the same order\n"
04885          "as they are given.\n"
04886          "\n"
04887          "Generic output: \n"
04888          "   Matrix : The matrix to be created. \n"
04889          "\n"
04890          "Generic input: \n"
04891          "   Vector : The vector to be copied into the first column. \n"
04892          "   Vector : The vector to be copied into the second column.\n"
04893         ),
04894         AUTHORS( "Mattias Ekstrom" ),
04895         OUT(),
04896         GOUT(      "gout1"       ),
04897         GOUT_TYPE( "Matrix" ),
04898         GOUT_DESC("FIXME DOC"),
04899         IN(),
04900         GIN(      "gin1"      , "gin2"       ),
04901         GIN_TYPE(    "Vector", "Vector" ),
04902         GIN_DEFAULT( NODEF   , NODEF    ),
04903         GIN_DESC("FIXME DOC",
04904                  "FIXME DOC")
04905       ));
04906 
04907   md_data_raw.push_back
04908     ( MdRecord
04909       ( NAME("Matrix3ColFromVectors"),
04910         DESCRIPTION
04911         (
04912          "Forms a matrix containing 3 columns from three vectors.\n"
04913          "\n"
04914          "The vectors are put as columns in the matrix in the same order\n"
04915          "as they are given.\n"
04916          "\n"
04917          "Generic output: \n"
04918          "   Matrix : The matrix to be created. \n"
04919          "\n"
04920          "Generic input: \n"
04921          "   Vector : The vector to be copied into the first column. \n"
04922          "   Vector : The vector to be copied into the second column. \n"
04923          "   Vector : The vector to be copied into the third column.\n"
04924         ),
04925         AUTHORS( "Mattias Ekstrom" ),
04926         OUT(),
04927         GOUT(      "gout1"       ),
04928         GOUT_TYPE( "Matrix" ),
04929         GOUT_DESC("FIXME DOC"),
04930         IN(),
04931         GIN(      "gin1"      , "gin2"      , "gin3"       ),
04932         GIN_TYPE(    "Vector", "Vector", "Vector" ),
04933         GIN_DEFAULT( NODEF   , NODEF   , NODEF    ),
04934         GIN_DESC("FIXME DOC",
04935                  "FIXME DOC",
04936                  "FIXME DOC")
04937       ));
04938 
04939   md_data_raw.push_back
04940     ( MdRecord
04941       ( NAME("Matrix1RowFromVector"),
04942         DESCRIPTION
04943         (
04944          "Forms a matrix containing 1 row from a vector.\n"
04945          "\n"
04946          "Generic output: \n"
04947          "   Matrix : The matrix to be created. \n"
04948          "\n"
04949          "Generic input: \n"
04950          "   Vector : The vector to be copied.\n"
04951         ),
04952         AUTHORS( "Mattias Ekstrom" ),
04953         OUT(),
04954         GOUT(      "gout1"       ),
04955         GOUT_TYPE( "Matrix" ),
04956         GOUT_DESC("FIXME DOC"),
04957         IN(),
04958         GIN(      "gin1"       ),
04959         GIN_TYPE(    "Vector" ),
04960         GIN_DEFAULT( NODEF    ),
04961         GIN_DESC("FIXME DOC")
04962       ));
04963 
04964   md_data_raw.push_back
04965     ( MdRecord
04966       ( NAME("Matrix2RowFromVectors"),
04967         DESCRIPTION
04968         (
04969          "Forms a matrix containing 2 rows from two vectors.\n"
04970          "\n"
04971          "The vectors are put as rows in the matrix in the same order\n"
04972          "as they are given.\n"
04973          "\n"
04974          "Generic output: \n"
04975          "   Matrix : The matrix to be created. \n"
04976          "\n"
04977          "Generic input: \n"
04978          "   Vector : The vector to be copied into the first row. \n"
04979          "   Vector : The vector to be copied into the second row.\n"
04980         ),
04981         AUTHORS( "Mattias Ekstrom" ),
04982         OUT(),
04983         GOUT(      "gout1"       ),
04984         GOUT_TYPE( "Matrix" ),
04985         GOUT_DESC("FIXME DOC"),
04986         IN(),
04987         GIN(      "gin1"      , "gin2"       ),
04988         GIN_TYPE(    "Vector", "Vector" ),
04989         GIN_DEFAULT( NODEF   , NODEF    ),
04990         GIN_DESC("FIXME DOC",
04991                  "FIXME DOC")
04992       ));
04993 
04994   md_data_raw.push_back
04995     ( MdRecord
04996       ( NAME("Matrix3RowFromVectors"),
04997         DESCRIPTION
04998         (
04999          "Forms a matrix containing 3 rows from three vectors.\n"
05000          "\n"
05001          "The vectors are put as rows in the matrix in the same order\n"
05002          "as they are given.\n"
05003          "\n"
05004          "Generic output: \n"
05005          "   Matrix : The matrix to be created. \n"
05006          "\n"
05007          "Generic input: \n"
05008          "   Vector : The vector to be copied into the first row. \n"
05009          "   Vector : The vector to be copied into the second row. \n"
05010          "   Vector : The vector to be copied into the third row.\n"
05011         ),
05012         AUTHORS( "Mattias Ekstrom" ),
05013         OUT(),
05014         GOUT(      "gout1"       ),
05015         GOUT_TYPE( "Matrix" ),
05016         GOUT_DESC("FIXME DOC"),
05017         IN(),
05018         GIN(      "gin1"      , "gin2"      , "gin3"       ),
05019         GIN_TYPE(    "Vector", "Vector", "Vector" ),
05020         GIN_DEFAULT( NODEF   , NODEF   , NODEF    ),
05021         GIN_DESC("FIXME DOC",
05022                  "FIXME DOC",
05023                  "FIXME DOC")
05024       ));
05025 
05026   md_data_raw.push_back
05027     ( MdRecord
05028       ( NAME("MatrixPlanck"),
05029         DESCRIPTION
05030         (
05031          "Sets a matrix to hold blackbody radiation.\n"
05032          "\n"
05033          "Generic output: \n"
05034          "   Matrix : Matrix with blackbody radiation. \n"
05035          "\n"
05036          "Generic input: \n"
05037          "   Vector  : A set of frequencies. \n"
05038          "   Numeric : Blackbody temperature. \n"
05039         ),
05040         AUTHORS( "Patrick Eriksson" ),
05041         OUT(),
05042         GOUT(      "gout1"       ),
05043         GOUT_TYPE( "Matrix" ),
05044         GOUT_DESC("FIXME DOC"),
05045         IN( "stokes_dim" ),
05046         GIN(      "gin1"      , "gin2"        ),
05047         GIN_TYPE(    "Vector", "Numeric" ),
05048         GIN_DEFAULT( NODEF   , NODEF     ),
05049         GIN_DESC("FIXME DOC",
05050                  "FIXME DOC")
05051       ));
05052 
05053   md_data_raw.push_back
05054     ( MdRecord
05055       ( NAME("MatrixScale"),
05056         DESCRIPTION
05057         (
05058          "Scales all elements of a matrix with the same value. \n"
05059          "\n"
05060          "The result can either be stored in the same or another matrix. \n"
05061          "\n"
05062          "Generic output: \n"
05063          "   Matrix : Return matrix. \n"
05064          "\n"
05065          "Generic input: \n"
05066          "   Matrix : Original matrix. \n"
05067          "\n"
05068          "Keywords: \n"
05069          "   value : The value to be multiplied with the matrix.\n"
05070         ),
05071         AUTHORS( "Patrick Eriksson" ),
05072         OUT(),
05073         GOUT(      "gout1"       ),
05074         GOUT_TYPE( "Matrix" ),
05075         GOUT_DESC("FIXME DOC"),
05076         IN(),
05077         GIN(      "gin1"      ,
05078                   "value" ),
05079         GIN_TYPE(    "Matrix",
05080                      "Numeric"   ),
05081         GIN_DEFAULT( NODEF   ,
05082                   NODEF ),
05083         GIN_DESC("FIXME DOC",
05084                  "FIXME DOC")
05085       ));
05086 
05087    md_data_raw.push_back
05088     ( MdRecord
05089       ( NAME("MatrixSetConstant"),
05090         DESCRIPTION
05091         (
05092          "Creates a matrix and sets all elements to the specified value.\n"
05093          "The size is determined by the variables *ncols* and *nrows*.\n"
05094          "\n"
05095          "Generic output: \n"
05096          "   Matrix : The matrix to be created. \n"
05097          "\n"
05098          "Keywords:\n"
05099          "   value : The value of the matrix elements.\n" 
05100         ),
05101         AUTHORS( "Patrick Eriksson" ),
05102         OUT(),
05103         GOUT(      "gout1"       ),
05104         GOUT_TYPE( "Matrix" ),
05105         GOUT_DESC("FIXME DOC"),
05106         IN( "nrows", "ncols" ),
05107         GIN( "value"   ),
05108         GIN_TYPE(    "Numeric" ),
05109         GIN_DEFAULT( NODEF ),
05110         GIN_DESC("FIXME DOC")
05111       ));
05112 
05113   md_data_raw.push_back
05114     ( MdRecord
05115       ( NAME("MatrixUnitIntensity"),
05116         DESCRIPTION
05117         (
05118          "Sets a matrix to hold unpolarised radiation with unit intensity.\n"
05119          "\n"
05120          "Generic output: \n"
05121          "   Matrix : Matrix with unit radiation. \n"
05122          "\n"
05123          "Generic input: \n"
05124          "   Vector  : A set of frequencies.\n"
05125         ),
05126         AUTHORS( "Patrick Eriksson" ),
05127         OUT(),
05128         GOUT(      "gout1"       ),
05129         GOUT_TYPE( "Matrix" ),
05130         GOUT_DESC("FIXME DOC"),
05131         IN( "stokes_dim" ),
05132         GIN(      "gin1"       ),
05133         GIN_TYPE(    "Vector" ),
05134         GIN_DEFAULT( NODEF    ),
05135         GIN_DESC("FIXME DOC")
05136       ));
05137 
05138   md_data_raw.push_back
05139     ( MdRecord
05140       ( NAME("mc_antennaSetGaussian"),
05141         DESCRIPTION
05142         (
05143          "Makes mc_antenna (used by MCGeneral) a 2D Gaussian pattern.\n"
05144          "\n"
05145          "The gaussian antenna pattern is determined by the keyword parameters\n"
05146          "za_sigma, and aa_sigma, which represent the standard deviations in the\n"
05147          "uncorrelated bivariate normal distribution\n"
05148         ),
05149         AUTHORS( "Cory Davis" ),
05150         OUT( "mc_antenna" ),
05151         GOUT(),
05152         GOUT_TYPE(),
05153         GOUT_DESC(),
05154         IN(),
05155         GIN( "za_sigma", "aa_sigma" ),
05156         GIN_TYPE(    "Numeric",  "Numeric"),
05157         GIN_DEFAULT( NODEF,      NODEF ),
05158         GIN_DESC("FIXME DOC",
05159                  "FIXME DOC")
05160       ));
05161 
05162   md_data_raw.push_back
05163     ( MdRecord
05164       ( NAME("mc_antennaSetGaussianByFWHM"),
05165         DESCRIPTION
05166         (
05167          "Makes mc_antenna (used by MCGeneral) a 2D Gaussian pattern.\n"
05168          "\n"
05169          "The gaussian antenna pattern is determined by the keyword parameters\n"
05170          "za_fwhm, and aa_fwhm, which represent the full width half maximum (FWHM)\n"
05171          "of the antenna response, in the zenith and azimuthal planes.\n"
05172         ),
05173         AUTHORS( "Cory Davis" ),
05174         OUT( "mc_antenna" ),
05175         GOUT(),
05176         GOUT_TYPE(),
05177         GOUT_DESC(),
05178         IN(),
05179         GIN( "za_fwhm", "aa_fwhm" ),
05180         GIN_TYPE(    "Numeric", "Numeric"),
05181         GIN_DEFAULT( NODEF,     NODEF ),
05182         GIN_DESC("FIXME DOC",
05183                  "FIXME DOC")
05184       ));
05185 
05186   md_data_raw.push_back
05187     ( MdRecord
05188       ( NAME("mc_antennaSetPencilBeam"),
05189         DESCRIPTION
05190         (
05191          "Makes mc_antenna (used by MCGeneral) a pencil beam.\n"
05192          "\n"
05193          "This WSM makes the subsequent MCGeneral WSM perform pencil beam\n"
05194          "RT calculations.\n" 
05195         ),
05196         AUTHORS( "Cory Davis" ),
05197         OUT( "mc_antenna" ),
05198         GOUT(),
05199         GOUT_TYPE(),
05200         GOUT_DESC(),
05201         IN(),
05202         GIN(),
05203         GIN_TYPE(),
05204         GIN_DEFAULT(),
05205         GIN_DESC()
05206       ));
05207 
05208   md_data_raw.push_back
05209     ( MdRecord
05210       ( NAME("mc_IWP_cloud_opt_pathCalc"),
05211         DESCRIPTION
05212         (
05213          "Calculates the FOV averaged ice water path and cloud optical path\n"
05214          "for a given viewing direction\n"
05215         ),
05216         AUTHORS( "Cory Davis" ),
05217         OUT( "mc_IWP", "mc_cloud_opt_path", "mc_IWP_error", "mc_cloud_opt_path_error", 
05218                 "mc_iteration_count"),
05219         GOUT(),
05220         GOUT_TYPE(),
05221         GOUT_DESC(),
05222         IN( "mc_antenna", "sensor_pos", "sensor_los", "ppath_step_agenda", "p_grid", 
05223                "lat_grid", "lon_grid", "r_geoid", "z_surface", "z_field", "t_field", "vmr_field", 
05224                "cloudbox_limits", "pnd_field", "scat_data_mono", "particle_masses", "mc_seed"),
05225         GIN( "max_iter" ),
05226         GIN_TYPE(    "Index" ),
05227         GIN_DEFAULT( NODEF ),
05228         GIN_DESC("FIXME DOC")
05229       ));
05230   
05231   md_data_raw.push_back     
05232     ( MdRecord
05233       ( NAME("MCGeneral"),
05234         DESCRIPTION
05235         ("A generalised 3D reversed Monte Carlo radiative algorithm, that \n"
05236          "allows for 2D antenna patterns, surface reflection and arbitrary\n"
05237          "sensor positions.\n"
05238          "\n"
05239          "The main output variables *y* and *mc_error* represent the \n"
05240          "Stokes vector integrated over the antenna function, and the \n"
05241          "estimated error in this vector respectively.\n"
05242          "\n"
05243          "The WSV *mc_max_iter* describes the number of `photons\'\n"
05244          "used in the simulation (more photons means smaller *mc_error*).\n"
05245          "*mc_std_err* is the desired value of mc_error, and *mc_max_time* is\n"
05246          "the maximum allowed number of seconds for MCGeneral. MCGeneral will\n"
05247          "terminate once any of the max_iter, std_err, max_time criteria are\n"
05248          "met. If negative values are given for these parameters then it is\n"
05249          "ignored.\n"
05250          "\n"
05251          "Negative values of mc_seed seed the random number generator \n"
05252          "according to system time, positive rng_seed values are taken\n"
05253          "literally.\n"),
05254         AUTHORS( "Cory Davis" ),
05255         OUT( "y", "mc_iteration_count", "mc_error", "mc_points" ),
05256         GOUT(),
05257         GOUT_TYPE(),
05258         GOUT_DESC(),
05259         IN( "mc_antenna", "f_grid", "f_index", "sensor_pos", "sensor_los", 
05260                "stokes_dim", "iy_space_agenda", "surface_prop_agenda", 
05261                "opt_prop_gas_agenda", "abs_scalar_gas_agenda", "p_grid", "lat_grid", 
05262                "lon_grid", "z_field", "r_geoid", "z_surface", "t_field", "vmr_field", 
05263                "cloudbox_limits", "pnd_field", "scat_data_mono", 
05264                "mc_seed", "y_unit", 
05265                "mc_std_err", "mc_max_time", "mc_max_iter", "mc_z_field_is_1D" ),
05266         GIN(),
05267         GIN_TYPE(),
05268         GIN_DEFAULT(),
05269         GIN_DESC()
05270       ));
05271 
05272   md_data_raw.push_back     
05273     ( MdRecord
05274       ( NAME("MCIPA"),
05275         DESCRIPTION
05276         ("A specialised 3D reversed Monte Carlo radiative algorithm, that \n"
05277          "mimics independent pixel appoximation simulations.\n"
05278          "Probably temporary.\n"),
05279         AUTHORS( "Cory Davis" ),
05280         OUT( "y", "mc_iteration_count", "mc_error", "mc_points"),
05281         GOUT(),
05282         GOUT_TYPE(),
05283         GOUT_DESC(),
05284         IN( "mc_antenna", "f_grid", "f_index", "sensor_pos", "sensor_los", 
05285                "stokes_dim", "iy_space_agenda", "surface_prop_agenda", 
05286                "opt_prop_gas_agenda", "abs_scalar_gas_agenda", "ppath_step_agenda",
05287                "p_grid", "lat_grid", "lon_grid", "z_field", "r_geoid", "z_surface", 
05288                "t_field", "vmr_field", "cloudbox_limits", "pnd_field", 
05289                "scat_data_mono", "mc_seed", "y_unit",
05290                "mc_std_err", "mc_max_time", "mc_max_iter", "mc_z_field_is_1D" ),
05291         GIN(),
05292         GIN_TYPE(),
05293         GIN_DEFAULT(),
05294         GIN_DESC()
05295       ));
05296 
05297   /* Removed as ScatteringMonteCarlo is not working
05298   md_data_raw.push_back     
05299     ( MdRecord
05300       ( NAME("MCSetIncomingEmpty"),
05301         DESCRIPTION
05302         ("Sets mc_incoming to be empty.  \n"
05303          "This is needed when using ScatteringMonteCarlo with incoming_lookup=0\n"
05304         ),
05305         AUTHORS( "Cory Davis" ),
05306         OUT( "mc_incoming" ),
05307         GOUT(),
05308         GOUT_TYPE(),
05309         GOUT_DESC(),
05310         IN(),
05311         GIN(),
05312         GIN_TYPE(),
05313         GIN_DEFAULT(),
05314         GIN_DESC()
05315         ));
05316   */
05317 
05318   md_data_raw.push_back     
05319     ( MdRecord
05320       ( NAME("MCSetSeedFromTime"),
05321         DESCRIPTION
05322         ("Sets the value of mc_seed from system time\n"),
05323         AUTHORS( "Cory Davis" ),
05324         OUT( "mc_seed" ),
05325         GOUT(),
05326         GOUT_TYPE(),
05327         GOUT_DESC(),
05328         IN(),
05329         GIN(),
05330         GIN_TYPE(),
05331         GIN_DEFAULT(),
05332         GIN_DESC()
05333       ));
05334 
05335   md_data_raw.push_back
05336     ( MdRecord
05337       ( NAME( "NumericCreate" ),
05338         DESCRIPTION
05339         (
05340          "Creates a Numeric variable.\n"
05341          "\n"
05342          "If the variable already exists, it'll be reset.\n"
05343          "\n"
05344          "Generic output: \n"
05345          "   Numeric: New Numeric variable.\n"
05346         ),
05347         AUTHORS( "Oliver Lemke" ),
05348         OUT(),
05349         GOUT(      "gout1"        ),
05350         GOUT_TYPE( "Numeric" ),
05351         GOUT_DESC("FIXME DOC"),
05352         IN(),
05353         GIN(),
05354         GIN_TYPE(),
05355         GIN_DEFAULT(),
05356         GIN_DESC()
05357       ));
05358 
05359   md_data_raw.push_back
05360     ( MdRecord
05361       ( NAME("NumericSet"),
05362         DESCRIPTION
05363         (
05364          "Sets a numeric workspace variable to the given value. \n"
05365          "\n"
05366          "Generic output: \n"
05367          "   Numeric : The numeric variable to be set. \n"
05368          "\n"
05369          "Keywords:\n"
05370          "   value : The value.\n" 
05371         ),
05372         AUTHORS( "Patrick Eriksson" ),
05373         OUT(),
05374         GOUT(      "gout1"        ),
05375         GOUT_TYPE( "Numeric" ),
05376         GOUT_DESC("FIXME DOC"),
05377         IN(),
05378         GIN( "value"   ),
05379         GIN_TYPE(    "Numeric" ),
05380         GIN_DEFAULT( NODEF ),
05381         GIN_DESC("FIXME DOC"),
05382         SETMETHOD( true )
05383       ));
05384 
05385   md_data_raw.push_back     
05386     ( MdRecord
05387       ( NAME("nelemGet"),
05388         DESCRIPTION
05389         (
05390          "Retrieve nelem from given variable and store the value in the \n"
05391          "workspace variable *nelem*\n"
05392         ),
05393         AUTHORS( "Oliver Lemke" ),
05394         OUT( "nelem" ),
05395         GOUT(),
05396         GOUT_TYPE(),
05397         GOUT_DESC(),
05398         IN(),
05399         GIN(      "gin1"    ),
05400         GIN_TYPE(    ARRAY_GROUPS + ", Vector" ),
05401         GIN_DEFAULT( NODEF ),
05402         GIN_DESC("FIXME DOC"),
05403         SETMETHOD(      false ),
05404         AGENDAMETHOD(   false ),
05405         SUPPRESSHEADER( true  )
05406       ));
05407 
05408   md_data_raw.push_back     
05409     ( MdRecord
05410       ( NAME("ncolsGet"),
05411         DESCRIPTION
05412         (
05413          "Retrieve ncols from given variable and store the value in the \n"
05414          "workspace variable *ncols*\n"
05415         ),
05416         AUTHORS( "Oliver Lemke" ),
05417         OUT( "ncols" ),
05418         GOUT(),
05419         GOUT_TYPE(),
05420         GOUT_DESC(),
05421         IN(),
05422         GIN(      "gin1"    ),
05423         GIN_TYPE( "Matrix, Tensor3, Tensor4, Tensor5, Tensor6, Tensor7" ),
05424         GIN_DEFAULT( NODEF ),
05425         GIN_DESC("FIXME DOC"),
05426         SETMETHOD(      false ),
05427         AGENDAMETHOD(   false ),
05428         SUPPRESSHEADER( true  )
05429       ));
05430 
05431   md_data_raw.push_back     
05432     ( MdRecord
05433       ( NAME("nrowsGet"),
05434         DESCRIPTION
05435         (
05436          "Retrieve nrows from given variable and store the value in the \n"
05437          "workspace variable *nrows*\n"
05438         ),
05439         AUTHORS( "Oliver Lemke" ),
05440         OUT( "nrows" ),
05441         GOUT(),
05442         GOUT_TYPE(),
05443         GOUT_DESC(),
05444         IN(),
05445         GIN(      "gin1"    ),
05446         GIN_TYPE( "Matrix, Tensor3, Tensor4, Tensor5, Tensor6, Tensor7" ),
05447         GIN_DEFAULT( NODEF ),
05448         GIN_DESC("FIXME DOC"),
05449         SETMETHOD(      false ),
05450         AGENDAMETHOD(   false ),
05451         SUPPRESSHEADER( true  )
05452       ));
05453 
05454   md_data_raw.push_back     
05455     ( MdRecord
05456       ( NAME("npagesGet"),
05457         DESCRIPTION
05458         (
05459          "Retrieve npages from given variable and store the value in the \n"
05460          "workspace variable *npages*\n"
05461         ),
05462         AUTHORS( "Oliver Lemke" ),
05463         OUT( "npages" ),
05464         GOUT(),
05465         GOUT_TYPE(),
05466         GOUT_DESC(),
05467         IN(),
05468         GIN(      "gin1"    ),
05469         GIN_TYPE( "Tensor3, Tensor4, Tensor5, Tensor6, Tensor7" ),
05470         GIN_DEFAULT( NODEF ),
05471         GIN_DESC("FIXME DOC"),
05472         SETMETHOD(      false ),
05473         AGENDAMETHOD(   false ),
05474         SUPPRESSHEADER( true  )
05475       ));
05476 
05477   md_data_raw.push_back     
05478     ( MdRecord
05479       ( NAME("nbooksGet"),
05480         DESCRIPTION
05481         (
05482          "Retrieve nbooks from given variable and store the value in the \n"
05483          "workspace variable *nbooks*\n"
05484         ),
05485         AUTHORS( "Oliver Lemke" ),
05486         OUT( "nbooks" ),
05487         GOUT(),
05488         GOUT_TYPE(),
05489         GOUT_DESC(),
05490         IN(),
05491         GIN(      "gin1"    ),
05492         GIN_TYPE( "Tensor4, Tensor5, Tensor6, Tensor7" ),
05493         GIN_DEFAULT( NODEF ),
05494         GIN_DESC("FIXME DOC"),
05495         SETMETHOD(      false ),
05496         AGENDAMETHOD(   false ),
05497         SUPPRESSHEADER( true  )
05498       ));
05499 
05500   md_data_raw.push_back     
05501     ( MdRecord
05502       ( NAME("nshelvesGet"),
05503         DESCRIPTION
05504         (
05505          "Retrieve nshelves from given variable and store the value in the \n"
05506          "workspace variable *nshelves*\n"
05507         ),
05508         AUTHORS( "Oliver Lemke" ),
05509         OUT( "nshelves" ),
05510         GOUT(),
05511         GOUT_TYPE(),
05512         GOUT_DESC(),
05513         IN(),
05514         GIN(      "gin1"    ),
05515         GIN_TYPE( "Tensor5, Tensor6, Tensor7" ),
05516         GIN_DEFAULT( NODEF ),
05517         GIN_DESC("FIXME DOC"),
05518         SETMETHOD(      false ),
05519         AGENDAMETHOD(   false ),
05520         SUPPRESSHEADER( true  )
05521       ));
05522 
05523   md_data_raw.push_back     
05524     ( MdRecord
05525       ( NAME("nvitrinesGet"),
05526         DESCRIPTION
05527         (
05528          "Retrieve nvitrines from given variable and store the value in the \n"
05529          "workspace variable *nvitrines*\n"
05530         ),
05531         AUTHORS( "Oliver Lemke" ),
05532         OUT( "nvitrines" ),
05533         GOUT(),
05534         GOUT_TYPE(),
05535         GOUT_DESC(),
05536         IN(),
05537         GIN(      "gin1"    ),
05538         GIN_TYPE( "Tensor6, Tensor7" ),
05539         GIN_DEFAULT( NODEF ),
05540         GIN_DESC("FIXME DOC"),
05541         SETMETHOD(      false ),
05542         AGENDAMETHOD(   false ),
05543         SUPPRESSHEADER( true  )
05544       ));
05545 
05546   md_data_raw.push_back     
05547     ( MdRecord
05548       ( NAME("nlibrariesGet"),
05549         DESCRIPTION
05550         (
05551          "Retrieve nlibraries from given variable and store the value in the \n"
05552          "workspace variable *nlibraries*\n"
05553         ),
05554         AUTHORS( "Oliver Lemke" ),
05555         OUT( "nlibraries" ),
05556         GOUT(),
05557         GOUT_TYPE(),
05558         GOUT_DESC(),
05559         IN(),
05560         GIN(      "gin1"    ),
05561         GIN_TYPE( "Tensor7" ),
05562         GIN_DEFAULT( NODEF ),
05563         GIN_DESC("FIXME DOC"),
05564         SETMETHOD(      false ),
05565         AGENDAMETHOD(   false ),
05566         SUPPRESSHEADER( true  )
05567       ));
05568 
05569   md_data_raw.push_back
05570     ( MdRecord
05571       ( NAME("opt_prop_sptFromData"),
05572         DESCRIPTION
05573         (
05574          "Calculates opticle properties for the single particle types.\n"
05575          "\n"
05576          "In this function extinction matrix and absorption vector are \n"
05577          "calculated in the laboratory frame. These properties are required\n"
05578          "for the RT calculation, inside the the i_fieldUpdateXXX \n"
05579          "functions.\n" 
05580          "\n"
05581          "The interpolation of the data on the actual frequency is the \n"
05582          "first step in this function. \n"
05583          "\n"
05584          "Then the transformation from the database coordinate system to to \n"
05585          "laboratory coordinate system is done.\n"
05586          "\n"
05587          "Output of the function are *ext_mat_spt*, and *abs_vec_spt* which\n"
05588          "hold the optical properties for a specified propagation direction\n"
05589          "for each particle type. \n"
05590         ),
05591         AUTHORS( "Claudia Emde" ),
05592         OUT( "ext_mat_spt", "abs_vec_spt" ),
05593         GOUT(),
05594         GOUT_TYPE(),
05595         GOUT_DESC(),
05596         IN(  "ext_mat_spt", "abs_vec_spt", "scat_data_raw",
05597                 "scat_za_grid", 
05598                 "scat_aa_grid", "scat_za_index", "scat_aa_index", 
05599                 "f_index", "f_grid", "rte_temperature",
05600                 "pnd_field", "scat_p_index", "scat_lat_index", "scat_lon_index" ),
05601         GIN(),
05602         GIN_TYPE(),
05603         GIN_DEFAULT(),
05604         GIN_DESC()
05605       ));
05606 
05607   md_data_raw.push_back
05608     ( MdRecord
05609       ( NAME("opt_prop_sptFromMonoData"),
05610         DESCRIPTION
05611         (
05612          "Calculates optical properties for the single particle types.\n"
05613          "\n"
05614          "In this function extinction matrix and absorption vector are \n"
05615          "calculated in the laboratory frame. "
05616          "\n"
05617          "The single scattering data is obtained from scat_data_mono, so\n"
05618          "frequency interpolation is not required\n"
05619          "\n"
05620          "Output of the function are *ext_mat_spt*, and *abs_vec_spt* which\n"
05621          "hold the optical properties for a specified propagation direction\n"
05622          "for each particle type. \n"
05623         ),
05624         AUTHORS( "Cory Davis" ),
05625         OUT( "ext_mat_spt", "abs_vec_spt" ),
05626         GOUT(),
05627         GOUT_TYPE(),
05628         GOUT_DESC(),
05629         IN(  "ext_mat_spt", "abs_vec_spt", "scat_data_mono",
05630                 "scat_za_grid", 
05631                 "scat_aa_grid", "scat_za_index", "scat_aa_index", "rte_temperature",
05632                 "pnd_field", "scat_p_index", "scat_lat_index", "scat_lon_index" ),
05633         GIN(),
05634         GIN_TYPE(),
05635         GIN_DEFAULT(),
05636         GIN_DESC()
05637       ));
05638  
05639   md_data_raw.push_back
05640     ( MdRecord
05641       ( NAME("output_file_formatSetAscii"),
05642         DESCRIPTION
05643         (
05644          "Sets the output file format to ASCII.\n"
05645         ),
05646         AUTHORS( "Oliver Lemke" ),
05647         OUT( "output_file_format" ),
05648         GOUT(),
05649         GOUT_TYPE(),
05650         GOUT_DESC(),
05651         IN(),
05652         GIN(),
05653         GIN_TYPE(),
05654         GIN_DEFAULT(),
05655         GIN_DESC()
05656       ));
05657 
05658   md_data_raw.push_back
05659     ( MdRecord
05660       ( NAME("output_file_formatSetBinary"),
05661         DESCRIPTION
05662         (
05663          "Sets the output file format to binary.\n"
05664         ),
05665         AUTHORS( "Oliver Lemke" ),
05666         OUT( "output_file_format" ),
05667         GOUT(),
05668         GOUT_TYPE(),
05669         GOUT_DESC(),
05670         IN(),
05671         GIN(),
05672         GIN_TYPE(),
05673         GIN_DEFAULT(),
05674         GIN_DESC()
05675       ));
05676 
05677   md_data_raw.push_back
05678     ( MdRecord
05679       ( NAME("output_file_formatSetZippedAscii"),
05680         DESCRIPTION
05681         (
05682          "Sets the output file format to zipped ASCII.\n"
05683         ),
05684         AUTHORS( "Oliver Lemke" ),
05685         OUT( "output_file_format" ),
05686         GOUT(),
05687         GOUT_TYPE(),
05688         GOUT_DESC(),
05689         IN(),
05690         GIN(),
05691         GIN_TYPE(),
05692         GIN_DEFAULT(),
05693         GIN_DESC()
05694       ));
05695 
05696   md_data_raw.push_back
05697     ( MdRecord
05698       ( NAME( "ParticleTypeAddAll" ),
05699         DESCRIPTION
05700         (
05701          "Read single scattering data and particle number densities.\n"
05702          "\n"
05703          "The WSV *pnd_field_raw* containing particle number densities for all \n"
05704          "hydrometeor species can be generated outside ARTS, for example by using\n"
05705          "PyARTS. This method needs as input a file containing filenames of \n"
05706          "single scattering data and a file containing the corresponding \n"
05707          "*pnd_field_raw*.\n"
05708          "\n"
05709          "Very important note: \n"
05710          "The order of the filenames for the scattering data files has to\n"
05711          "correspond to the order of the particle types in the file \n"
05712          "including the variable *pnd_field_raw*!\n" 
05713          "\n"
05714          "Keywords:\n"
05715          "   filename_scat_data : File containing an \n" 
05716          "                        ArrayOfString of filenames of single scattering data files \n"
05717          "                        corresponding the the particle number densities in \n"
05718          "                        *pnd_field_raw*.\n"
05719          "   filename_pnd_field : File including  the WSV *pnd_field_raw*.\n"
05720          ),
05721         AUTHORS( "Claudia Emde" ),
05722         OUT( "scat_data_raw", "pnd_field_raw" ),
05723         GOUT(),
05724         GOUT_TYPE(),
05725         GOUT_DESC(),
05726         IN( "atmosphere_dim", "f_grid", "p_grid", "lat_grid", "lon_grid", 
05727                "cloudbox_limits" ),
05728         GIN( "filename_scat_data", "filename_pnd_field" ),
05729         GIN_TYPE(    "String",             "String" ),
05730         GIN_DEFAULT( NODEF,                NODEF ),
05731         GIN_DESC("FIXME DOC",
05732                  "FIXME DOC")
05733       ));
05734  
05735   md_data_raw.push_back
05736     ( MdRecord
05737       ( NAME( "ParticleTypeAdd" ),
05738         DESCRIPTION
05739         (
05740          "This method reads single scattering data and the corresonding\n"
05741          "particle number density fields. \n"
05742          "\n"
05743          "The methods reads the  specified files \n"
05744          "and appends the variables *scat_data_raw* and *pnd_field_raw*. \n"
05745          "\n"
05746          "Keywords:\n"
05747          "   filename_scat_data : Filename of single scattering data. \n"
05748          "   filename_pnd_field : Filename of the corresponding pnd_field\n"
05749          "                        (format here is GField3).\n"
05750          ),
05751         AUTHORS( "Claudia Emde" ),
05752         OUT( "scat_data_raw", "pnd_field_raw" ),
05753         GOUT(),
05754         GOUT_TYPE(),
05755         GOUT_DESC(),
05756         IN( "atmosphere_dim", "f_grid", "p_grid", "lat_grid", "lon_grid", 
05757                "cloudbox_limits" ),
05758         GIN( "filename_scat_data", "filename_pnd_field" ),
05759         GIN_TYPE(    "String",             "String" ),
05760         GIN_DEFAULT( NODEF,                NODEF ),
05761         GIN_DESC("FIXME DOC",
05762                  "FIXME DOC")
05763       ));
05764 
05765   md_data_raw.push_back
05766     ( MdRecord
05767       ( NAME( "ParticleTypeInit" ),
05768         DESCRIPTION
05769         (
05770          "This method initializes variables containing data about the \n"
05771          "optical properties of particles (*scat_data_raw*) and about the \n"
05772          "particle number distribution (*pnd_field_raw*)\n"
05773          "\n"
05774          "*ParticleTypeInit* has to be executed before executing \n"
05775          "*ParticleTypeAdd(All)*.\n"
05776         ),
05777         AUTHORS( "Claudia Emde" ),
05778         OUT( "scat_data_raw", "pnd_field_raw" ),
05779         GOUT(),
05780         GOUT_TYPE(),
05781         GOUT_DESC(),
05782         IN(),
05783         GIN(), 
05784         GIN_TYPE(), 
05785         GIN_DEFAULT(),
05786         GIN_DESC()
05787       ));
05788 
05789    md_data_raw.push_back
05790     ( MdRecord
05791       ( NAME( "pha_matCalc" ),
05792         DESCRIPTION
05793         (
05794          "This function sums up the phase matrices for all particle\n"
05795          "types weighted with particle number density.\n"
05796          "\n"
05797          "The output of this method is *pha_mat* (Nza, Naa, stokes_dim,\n"
05798          "stokes_dim). The inputs are the phase matrix for the single particle\n"
05799          "type *pha_mat_spt* (part_types, Nza, Naa, stokes_dim, stokes_dim)\n"
05800          "and the local particle  number densities for all particle types namely \n"
05801          "the *pnd_field* (part_types, p_grid, lat_grid, lon_grid ) for given\n"
05802          "*p_grid*, *lat_grid*, and *lon_grid*. The particle types required \n"
05803          "are specified in the control file.\n"
05804          ),
05805         AUTHORS( "Sreerekha T.R." ),
05806         OUT( "pha_mat" ),
05807         GOUT(),
05808         GOUT_TYPE(),
05809         GOUT_DESC(),
05810         IN( "pha_mat_spt", "pnd_field", "atmosphere_dim", "scat_p_index",
05811                "scat_lat_index", "scat_lon_index" ),
05812         GIN(),
05813         GIN_TYPE(), 
05814         GIN_DEFAULT(),
05815         GIN_DESC()
05816       ));
05817 
05818   md_data_raw.push_back
05819     ( MdRecord
05820       ( NAME( "pha_mat_sptFromData" ),
05821         DESCRIPTION
05822         (
05823          "Calculation of the phase matrix for the single particle types.\n"
05824          "\n"
05825          "This function can be used in *pha_mat_spt_agenda* as part of \n"
05826          "the calculation\n"
05827          "of the scattering integral.\n"
05828          "\n"
05829          "The interpolation of the data on the actual frequency is the first\n"
05830          "step in this function. \n"
05831          "\n"
05832          "Then the transformation from the database coordinate system to to \n"
05833          "laboratory coordinate system is done.\n"
05834          ),
05835         AUTHORS( "Claudia Emde" ),
05836         OUT( "pha_mat_spt" ),
05837         GOUT(),
05838         GOUT_TYPE(),
05839         GOUT_DESC(),
05840         IN( "pha_mat_spt", "scat_data_raw", "scat_za_grid", "scat_aa_grid", 
05841                "scat_za_index", "scat_aa_index", "f_index", "f_grid",
05842                "rte_temperature", "pnd_field", "scat_p_index", "scat_lat_index",
05843                "scat_lon_index" ),
05844         GIN(),
05845         GIN_TYPE(), 
05846         GIN_DEFAULT(),
05847         GIN_DESC()
05848       ));
05849 
05850    md_data_raw.push_back
05851     ( MdRecord
05852       ( NAME( "pha_mat_sptFromMonoData" ),
05853         DESCRIPTION
05854         (
05855          "Calculation of the phase matrix for the single particle types.\n"
05856          "\n"
05857          "This function is the monchromatic version of *pha_mat_sptFromData*.\n"
05858          ),
05859         AUTHORS( "Claudia Emde" ),
05860         OUT( "pha_mat_spt" ),
05861         GOUT(),
05862         GOUT_TYPE(),
05863         GOUT_DESC(),
05864         IN( "pha_mat_spt", "scat_data_mono", "doit_za_grid_size",
05865                "scat_aa_grid", "scat_za_index", "scat_aa_index", "rte_temperature",
05866                "pnd_field", "scat_p_index", "scat_lat_index", "scat_lon_index" ),
05867         GIN(),
05868         GIN_TYPE(), 
05869         GIN_DEFAULT(),
05870         GIN_DESC()
05871       ));
05872 
05873    md_data_raw.push_back
05874     ( MdRecord
05875       ( NAME( "pha_mat_sptFromDataDOITOpt" ),
05876         DESCRIPTION
05877         (
05878          "Calculation of the phase matrix for the single particle types.\n"
05879          "\n"
05880          "In this function the phase matrix is extracted from \n"
05881          "*pha_mat_sptDOITOpt*. It can be used in the agenda\n"
05882          "*pha_mat_spt_agenda*. This method must be used in \n "
05883          "conbination with *ScatteringDataPrepareDOITOpt*. \n"
05884          ),
05885         AUTHORS( "Claudia Emde" ),
05886         OUT( "pha_mat_spt" ),
05887         GOUT(),
05888         GOUT_TYPE(),
05889         GOUT_DESC(),
05890         IN( "pha_mat_spt", "pha_mat_sptDOITOpt", "scat_data_mono", 
05891                "doit_za_grid_size",
05892                "scat_aa_grid", 
05893                "scat_za_index", "scat_aa_index", "rte_temperature",
05894                "pnd_field", "scat_p_index", "scat_lat_index", "scat_lon_index" ),
05895         GIN(),
05896         GIN_TYPE(), 
05897         GIN_DEFAULT(),
05898         GIN_DESC()
05899       ));
05900 
05901   md_data_raw.push_back
05902     ( MdRecord
05903       ( NAME( "pnd_fieldCalc" ),
05904         DESCRIPTION
05905         ("Interpolate the particle number density fields.\n"
05906          "\n"
05907          "This methods interpolates the particle number density field\n"
05908          "from the raw data *pnd_field_raw* to pnd_field* which is definded \n"
05909          "on sub-grids of *p_grid*, *lat_grid*, *lon_grid*, exactly on the \n"
05910          "part of the atmosphere where the cloudbox is defined. \n"
05911          "\n"
05912          "The method takes as input the *pnd_field_raw* \n"
05913          "which contains the particle number density for each\n"
05914          "particle type. \n"
05915          ),
05916         AUTHORS( "Sreerekha T.R.", "Claudia Emde" ),
05917         OUT( "pnd_field" ),
05918         GOUT(),
05919         GOUT_TYPE(),
05920         GOUT_DESC(),
05921         IN( "p_grid", "lat_grid", "lon_grid", "pnd_field_raw", "atmosphere_dim",
05922                "cloudbox_limits" ),
05923         GIN(),
05924         GIN_TYPE(), 
05925         GIN_DEFAULT(),
05926         GIN_DESC()
05927       ));
05928 
05929   md_data_raw.push_back
05930     ( MdRecord
05931       ( NAME( "ppathCalc" ),
05932         DESCRIPTION
05933         (
05934          "Main function for calculation of propagation paths.\n"
05935          "\n"
05936          "There exists only one function to calculate total propagation\n"
05937          "paths and this is that function. The function is normally not\n"
05938          "visible in the control file, it is called from inside *RteCalc*.\n"
05939          "A reason to call this function directly would be to plot a\n"
05940          "propgation path.\n"
05941          "\n"
05942          "The definition of a propgation path cannot be accomodated here.\n"
05943          "For more information read the chapter on propagation paths in the\n"
05944          "ARTS user guide and read the  on-line information for\n"
05945          "*ppath_step_agenda* (type \"arts -d ppath_step_agenda\").\n"
05946         ),
05947         AUTHORS( "Patrick Eriksson" ),
05948         OUT( "ppath" ),
05949         GOUT(),
05950         GOUT_TYPE(),
05951         GOUT_DESC(),
05952         IN( "ppath_step_agenda", "atmosphere_dim", "p_grid", "lat_grid", 
05953                "lon_grid", "z_field", "r_geoid", "z_surface", 
05954                "cloudbox_on", "cloudbox_limits", "rte_pos", "rte_los" ),
05955         GIN(),
05956         GIN_TYPE(),
05957         GIN_DEFAULT(),
05958         GIN_DESC()
05959       ));
05960 
05961 
05962   md_data_raw.push_back
05963     ( MdRecord
05964       ( NAME( "ppath_stepGeometric" ),
05965         DESCRIPTION
05966         (
05967          "Calculates a geometrical propagation path step.\n"
05968          "\n"
05969          "This function determines a propagation path step by pure\n"
05970          "geometrical calculations. That is, refraction is neglected. Path\n"
05971          "points are always included for crossings with the grids, tangent\n"
05972          "points and points of surface intersections. The WSV *ppath_lmax* \n"
05973          "gives the option to include additional points to ensure that the\n"
05974          "distance along the path between the points does not exceed the \n"
05975          "selected maximum length. No additional points are included if\n"
05976          "*ppath_lmax* is set to <= 0.\n"
05977          "\n"
05978          "As functions of this kind should very seldom be called directly,\n"
05979          "and that the functions can be called a high number of times, these\n"
05980          "functions do not perform any checks of the input that give\n" 
05981          "detailed error messages, but asserts are performed (if turned on).\n"
05982          "\n"
05983          "For further information, type see the on-line information for\n"
05984          "*ppath_step_agenda* (type \"arts -d ppath_step_agenda\").\n"
05985         ),
05986         AUTHORS( "Patrick Eriksson" ),
05987         OUT( "ppath_step" ),
05988         GOUT(),
05989         GOUT_TYPE(),
05990         GOUT_DESC(),
05991         IN( "ppath_step", "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", 
05992                "z_field", "r_geoid", "z_surface", "ppath_lmax" ),
05993         GIN(),
05994         GIN_TYPE(),
05995         GIN_DEFAULT(),
05996         GIN_DESC()
05997       ));
05998 
05999   md_data_raw.push_back
06000     ( MdRecord
06001       ( NAME( "ppath_stepRefractionEuler" ),
06002         DESCRIPTION
06003         (
06004          "Calculates a propagation path step, considering refraction by a\n"
06005          "straightforward Euler approach.\n"
06006          "\n"
06007          "Refraction is taken into account by probably the simplest approach\n"
06008          "possible. The path is treated to consist of piece-wise geometric \n"
06009          "steps. A geometric path step is calculated from each point by \n"
06010          "using the local line-of-sight. Except for 1D zenith angles, the\n"
06011          "path quantities are propagated by solving the differential \n"
06012          "equations by the Euler method. Snell's law for spherical symmetry\n"
06013          "is used for 1D to update the zenith angles. \n"
06014          "\n"
06015          "See further the on-line information for *ppath_stepGeometric*\n"
06016          "(type \"arts -d ppath_stepGeometric\") and the user guide for more\n"
06017          "details on the algorithms used.\n"
06018          "\n"
06019          "The maximum length of each ray tracing step is given by the WSV\n"
06020          "*ppath_lraytrace*. The length will never exceed the \n" 
06021          "given maximum value, but can be smaller. The ray tracing steps are\n"
06022          "only used to determine the path. Points to describe the path for \n" 
06023          "*RteCalc* are included as for *ppath_stepGeometric*, this\n"
06024          "including the functionality of *ppath_lmax*.\n"
06025         ),
06026         AUTHORS( "Patrick Eriksson" ),
06027         OUT( "ppath_step", "rte_pressure", "rte_temperature", "rte_vmr_list", 
06028                 "refr_index" ),
06029         GOUT(),
06030         GOUT_TYPE(),
06031         GOUT_DESC(),
06032         IN( "refr_index_agenda", "ppath_step", "atmosphere_dim", "p_grid", 
06033                "lat_grid", "lon_grid", "z_field", "t_field", "vmr_field", "r_geoid",
06034                "z_surface", "ppath_lmax", "ppath_lraytrace" ),
06035         GIN(),
06036         GIN_TYPE(),
06037         GIN_DEFAULT(),
06038         GIN_DESC()
06039       ));
06040 
06041   md_data_raw.push_back     
06042     ( MdRecord
06043       ( NAME("Print"),
06044         DESCRIPTION
06045         (
06046          "Prints a variable on the screen.\n"
06047          "\n"
06048          "Keywords:\n"
06049          "   level : Output level to use. \n"
06050         ),
06051         AUTHORS( "Oliver Lemke" ),
06052         OUT(),
06053         GOUT(),
06054         GOUT_TYPE(),
06055         GOUT_DESC(),
06056         IN(),
06057         GIN(      "gin1"   ,
06058                   "level" ),
06059         GIN_TYPE(    "Any",
06060                      "Index" ),
06061         GIN_DEFAULT( NODEF,
06062                   "1" ),
06063         GIN_DESC("FIXME DOC",
06064                  "FIXME DOC"),
06065         SETMETHOD(      false ),
06066         AGENDAMETHOD(   false ),
06067         SUPPRESSHEADER( true  )
06068       ));
06069 
06070   md_data_raw.push_back     
06071     ( MdRecord
06072       ( NAME("PrintWorkspace"),
06073         DESCRIPTION
06074         (
06075          "Prints a list of initialized workspace variables.\n"
06076          "\n"
06077          "Keywords:\n"
06078          "   level : Output level to use. \n"
06079         ),
06080         AUTHORS( "Oliver Lemke" ),
06081         OUT(),
06082         GOUT(),
06083         GOUT_TYPE(),
06084         GOUT_DESC(),
06085         IN(),
06086         GIN( "only_allocated", "level" ),
06087         GIN_TYPE(    "Index",          "Index" ),
06088         GIN_DEFAULT( "1",              "1" ),
06089         GIN_DESC("FIXME DOC",
06090                  "FIXME DOC"),
06091         SETMETHOD(      false ),
06092         AGENDAMETHOD(   false ),
06093         SUPPRESSHEADER( true  ),
06094         PASSWORKSPACE( true  )
06095       ));
06096 
06097   md_data_raw.push_back     
06098     ( MdRecord
06099       ( NAME("p_gridFromGasAbsLookup"),
06100         DESCRIPTION
06101         (
06102          "Sets *p_grid* to the frequency grid of *abs_lookup*.\n"
06103         ),
06104         AUTHORS( "Patrick Eriksson" ),
06105         OUT( "p_grid"  ),
06106         GOUT(),
06107         GOUT_TYPE(),
06108         GOUT_DESC(),
06109         IN(  "abs_lookup" ),
06110         GIN(),
06111         GIN_TYPE(),
06112         GIN_DEFAULT(),
06113         GIN_DESC()
06114       ));
06115 
06116   md_data_raw.push_back
06117     ( MdRecord
06118       ( NAME("ReadNetCDF"),
06119         DESCRIPTION
06120         (
06121          "Reads a workspace variable from a NetCDF file.\n"
06122          "\n"
06123          "This is a supergeneric method. It can read variables of any group.\n"
06124          "\n"
06125          "If the filename is omitted, the variable is read\n"
06126          "from <basename>.<variable_name>.nc.\n"
06127          ),
06128         AUTHORS( "Oliver Lemke" ),
06129         OUT(),
06130         GOUT(      "gout1"    ),
06131         GOUT_TYPE( "Vector, Matrix, Tensor3, Tensor4, ArrayOfVector, ArrayOfMatrix" ),
06132         GOUT_DESC("Variable to read."),
06133         IN(),
06134         GIN( "filename" ),
06135         GIN_TYPE(    "String"   ),
06136         GIN_DEFAULT( NODEF ),
06137         GIN_DESC("Name of the NetCDF file."),
06138         SETMETHOD(      false ),
06139         AGENDAMETHOD(   false ),
06140         SUPPRESSHEADER( true  ),
06141         PASSWORKSPACE(  false ),
06142         PASSWSVNAMES(   true  )
06143       ));
06144 
06145   md_data_raw.push_back
06146     ( MdRecord
06147       ( NAME("ReadXML"),
06148         DESCRIPTION
06149         (
06150          "Reads a workspace variable from an XML file.\n"
06151          "\n"
06152          "This is a supergeneric method. It can read variables of any group.\n"
06153          "\n"
06154          "If the filename is omitted, the variable is read\n"
06155          "from <basename>.<variable_name>.xml.\n"
06156          ),
06157         AUTHORS( "Oliver Lemke" ),
06158         OUT(),
06159         GOUT(      "gout1"    ),
06160         GOUT_TYPE( "Any" ),
06161         GOUT_DESC("Variable to read."),
06162         IN(),
06163         GIN( "filename" ),
06164         GIN_TYPE(    "String"   ),
06165         GIN_DEFAULT( NODEF ),
06166         GIN_DESC("Name of the XML file."),
06167         SETMETHOD(      false ),
06168         AGENDAMETHOD(   false ),
06169         SUPPRESSHEADER( true  ),
06170         PASSWORKSPACE(  false ),
06171         PASSWSVNAMES(   true  )
06172       ));
06173 
06174   md_data_raw.push_back     
06175     ( MdRecord
06176       ( NAME("refr_indexFieldAndGradients"),
06177         DESCRIPTION
06178         (
06179          "Calculates the field and gradients of the refractive index.\n"
06180          "\n"
06181          "This function calculates the refractive index and its gradients\n"
06182          "for a rectangular grid. \n"
06183          "\n"
06184          "Calculations are performed for all combinations of the given \n"
06185          "vectors, where the first vector shall contain pressure values, the\n"
06186          "second latitude values, and the last longitude values. For \n"
06187          "dimensions not used, the corresponding position vector is ignored.\n"
06188          "\n"
06189          "The calculated values form a Tensor4, with size:\n"
06190          "   [atmosphere_dim+1, np, nlat, nlon] \n"
06191          "where np is the number of pressures given etc. The book of the\n"
06192          "tensor with the following index holds:\n"
06193          "   0: the refractive index \n"
06194          "   1: radial gradient of the refractive index \n"
06195          "   2: latitude gradient of the refractive index \n"
06196          "   3: longitude gradient of the refractive index \n"
06197          "\n"
06198          "To calculate these quantities for the atmsopheric mesh, execute:\n"
06199          "   RefrIndexFieldAndGradients(tensor4_1,p_grid,lat_grid,lon_grid)\n"
06200         ),
06201         AUTHORS( "Patrick Eriksson" ),
06202         OUT( "refr_index", "rte_pressure", "rte_temperature", "rte_vmr_list" ),
06203         GOUT(      "gout1"        ),
06204         GOUT_TYPE( "Tensor4" ),
06205         GOUT_DESC("FIXME DOC"),
06206         IN( "refr_index_agenda", "atmosphere_dim", "p_grid", "lat_grid", 
06207                "lon_grid", "r_geoid", "z_field", "t_field", "vmr_field" ),
06208         GIN(      "gin1"      , "gin2"      , "gin3"        ),
06209         GIN_TYPE(    "Vector", "Vector", "Vector"  ),
06210         GIN_DEFAULT( NODEF   , NODEF   , NODEF     ),
06211         GIN_DESC("FIXME DOC",
06212                  "FIXME DOC",
06213                  "FIXME DOC")
06214       ));
06215 
06216   md_data_raw.push_back
06217     ( MdRecord
06218       ( NAME("refr_indexIR"),
06219         DESCRIPTION
06220         (
06221          "Calculates the IR refractive index due to gases in the\n"
06222          "Earth's atmosphere. \n"
06223          "\n"
06224          "Only refractivity of dry air is considered. The formula used is\n"
06225          "contributed by Michael Hoefner,bForschungszentrum Karlsruhe.\n"
06226         ),
06227         AUTHORS( "Mattias Ekstrom" ),
06228         OUT( "refr_index" ),
06229         GOUT(),
06230         GOUT_TYPE(),
06231         GOUT_DESC(),
06232         IN( "rte_pressure", "rte_temperature", "rte_vmr_list" ),
06233         GIN(),
06234         GIN_TYPE(),
06235         GIN_DEFAULT(),
06236         GIN_DESC()
06237       ));
06238 
06239   md_data_raw.push_back
06240     ( MdRecord
06241       ( NAME("refr_indexThayer"),
06242         DESCRIPTION
06243         (
06244          "Calculates the microwave refractive index due to gases in the\n"
06245          "Earth's atmosphere. \n"
06246          "\n"
06247          "The refractivity of dry air and water vapour is summed. All\n"
06248          "other gases are assumed ti have a negligible contribution.  \n"
06249          "\n"
06250          "The parameterisation of Thayer (Radio Science, 9, 803-807, 1974)\n"
06251          "is used. See also Eq. 3 and 5 of Solheim et al. (JGR, 104, \n"
06252          "pp. 9664). \n"
06253         ),
06254         AUTHORS( "Patrick Eriksson" ),
06255         OUT( "refr_index" ),
06256         GOUT(),
06257         GOUT_TYPE(),
06258         GOUT_DESC(),
06259         IN( "rte_pressure", "rte_temperature", "rte_vmr_list", "abs_species" ),
06260         GIN(),
06261         GIN_TYPE(),
06262         GIN_DEFAULT(),
06263         GIN_DESC()
06264       ));
06265 
06266   md_data_raw.push_back
06267     ( MdRecord
06268       ( NAME("refr_indexUnit"),
06269         DESCRIPTION
06270         (
06271          "Sets the refractive index to 1.\n"
06272          "\n"
06273          "If this method is used, the obtained path should be identical to\n"
06274          "the geomtrical path.\n"
06275          "\n"
06276          "As this function does not need any input, you have to include call\n"
06277          "of *Ignore* for all variables expected to be used by\n"
06278          "*refr_index_agenda*.\n"
06279         ),
06280         AUTHORS( "Patrick Eriksson" ),
06281         OUT( "refr_index" ),
06282         GOUT(),
06283         GOUT_TYPE(),
06284         GOUT_DESC(),
06285         IN(),
06286         GIN(),
06287         GIN_TYPE(),
06288         GIN_DEFAULT(),
06289         GIN_DESC()
06290       ));
06291 
06292   md_data_raw.push_back
06293     ( MdRecord
06294       ( NAME( "RteCalc" ),
06295         DESCRIPTION
06296         (
06297          "Main function for calculation of spectra.\n"
06298          "\n"
06299          "The overall scheme to solve the radiative transfer equation (RTE)\n"
06300          "is fixed and found in this method. In short, the method calculates\n"
06301          "monochromatic spectra for all pencil beam directions and applies\n"
06302          "the sensor response on obtained radiances.\n"
06303          "\n"
06304          "The first step is to calculate the propagation path through the\n"
06305          "atmosphere for the considered viewing direction. The next step is\n"
06306          "to determine the spectrum at the starting point of the propagation\n"
06307          "path. The start point of the propagation path can be found at the\n"
06308          "top of the atmosphere, the surface, or at the boundary or inside\n"
06309          "the cloud box. To determine the start spectrum can involve a\n"
06310          "recursive call of RteCalc (for example to calculate the radiation\n"
06311          "reflected by the surface). After this, the vector radiative\n"
06312          "transfer equation is solved to the end point of the propagation\n"
06313          "path. Finally, the response of the sensor is applied.\n"
06314          "\n"
06315          "Analytical jacobians for gas species and temperature can be \n"
06316          "calcultaed along with the spectrum.\n"
06317          "\n"        
06318          "See further the user guide.\n"
06319         ),
06320         AUTHORS( "Patrick Eriksson" ),
06321         OUT( "y", "y_f", "y_pol", "y_pos", "y_los", "jacobian" ),
06322         GOUT(),
06323         GOUT_TYPE(),
06324         GOUT_DESC(),
06325         IN( "ppath_step_agenda", "rte_agenda", "iy_space_agenda",
06326                "surface_prop_agenda", "iy_cloudbox_agenda",
06327                "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", "z_field", 
06328                "t_field", "vmr_field", "abs_species", "r_geoid", "z_surface", 
06329                "cloudbox_on", "cloudbox_limits", "sensor_response", 
06330                "sensor_response_f", "sensor_response_pol", 
06331                "sensor_response_za", "sensor_response_aa", 
06332                "sensor_pos", "sensor_los", "f_grid", "stokes_dim", 
06333                "antenna_dim", "mblock_za_grid", "mblock_aa_grid", 
06334                "jacobian", "jacobian_quantities", "jacobian_indices",
06335                "y_unit", "jacobian_unit" ),
06336         GIN(),
06337         GIN_TYPE(),
06338         GIN_DEFAULT(),
06339         GIN_DESC()
06340       ));
06341 
06342   md_data_raw.push_back
06343     ( MdRecord
06344       ( NAME( "RteCalcMC" ),
06345         DESCRIPTION
06346         (
06347          "As *RteCalc* but using *MCGeneral* for doing monochromatic pencil\n"
06348          "beam calculations.\n"
06349          "\n"
06350          "This functions allows Monte Carlo (MC) calculations for sets of \n"
06351          "frequencies and sensor pos/los in a single run. Sensor responses\n"
06352          "can be included in the standard manner (as in *RteCalc*).\n"
06353          "\n"
06354          "MC unit is set as for *MCGeneral*.No antenna pattern is included.\n"
06355          "\n"
06356          "This function does not apply the MC approach when it comes\n"
06357          "to sensor properties. These properties are not considered when\n"
06358          "tracking photons, which is done in *MCGeneral* (but only for the\n"
06359          "antenna pattern).\n"
06360          "\n"
06361          "The MC calculation errors are all assumed be uncorrelated and each\n"
06362          "have a normal distribution. These properties are of relevance when\n"
06363          "weighting the errors with the sensor repsonse matrix. The seed is\n"
06364          "reset for each call of *MCGeneral* to obtain uncorrelated errors.\n"
06365          "\n"
06366          "MC control arguments (mc_std_err, mc_max_time, mc_max_iter and\n"
06367          "mc_z_field_is_1D) as for *MCGeneral*. The arguments are applied\n"
06368          "for each monochromatic pencil beam calculation individually.\n"
06369         ),
06370         AUTHORS( "Patrick Eriksson" ),
06371         OUT( "y", "y_f", "y_pol", "y_pos", "y_los", "mc_error" ),
06372         GOUT(),
06373         GOUT_TYPE(),
06374         GOUT_DESC(),
06375         IN( "iy_space_agenda", "surface_prop_agenda", "opt_prop_gas_agenda",
06376                "abs_scalar_gas_agenda", "atmosphere_dim",
06377                "p_grid", "lat_grid", "lon_grid", "z_field", 
06378                "t_field", "vmr_field", "r_geoid", "z_surface", 
06379                "cloudbox_on", "cloudbox_limits", "pnd_field", "scat_data_raw",
06380                "sensor_response", "sensor_response_f", "sensor_response_pol", 
06381                "sensor_response_za", "sensor_response_aa", 
06382                "sensor_pos", "sensor_los", "f_grid", "stokes_dim", 
06383                "antenna_dim", "mblock_za_grid", "mblock_aa_grid", "y_unit", 
06384                "mc_std_err", "mc_max_time", "mc_max_iter", "mc_z_field_is_1D" ),
06385         GIN(),
06386         GIN_TYPE(),
06387         GIN_DEFAULT(),
06388         GIN_DESC()
06389       ));
06390 
06391   md_data_raw.push_back
06392     ( MdRecord
06393       ( NAME( "RteCalcNoJacobian" ),
06394         DESCRIPTION
06395         (
06396          "As *RteCalc* but throughout ignores jacobians.\n"
06397         ),
06398         AUTHORS( "Patrick Eriksson" ),
06399         OUT( "y", "y_f", "y_pol", "y_pos", "y_los" ),
06400         GOUT(),
06401         GOUT_TYPE(),
06402         GOUT_DESC(),
06403         IN( "ppath_step_agenda", "rte_agenda", "iy_space_agenda",
06404                "surface_prop_agenda", "iy_cloudbox_agenda",
06405                "atmosphere_dim", "p_grid", "lat_grid", "lon_grid", "z_field", 
06406                "t_field", "vmr_field", "r_geoid", "z_surface", 
06407                "cloudbox_on", "cloudbox_limits", "sensor_response", 
06408                "sensor_response_f", "sensor_response_pol", 
06409                "sensor_response_za", "sensor_response_aa", 
06410                "sensor_pos", "sensor_los", "f_grid", "stokes_dim", 
06411                "antenna_dim", "mblock_za_grid", "mblock_aa_grid", "y_unit" ),
06412         GIN(),
06413         GIN_TYPE(),
06414         GIN_DEFAULT(),
06415         GIN_DESC()
06416       ));
06417 
06418   md_data_raw.push_back
06419     ( MdRecord
06420       ( NAME( "RteStd" ),
06421         DESCRIPTION
06422         (
06423          "Standard RTE function.\n"
06424          "\n"
06425          "This function does a clearsky radiative transfer calculation for\n"
06426          "a given propagation path. Designed to be part of *rte_agenda*.\n"
06427          "\n"
06428          "The overall strategy is to average basic atmospheric quantities\n"
06429          "(such as temperature) between the end points of each step of \n"
06430          "the propagation path, and to calculate source term and absorption\n"
06431          "for these averaged values.\n" 
06432          "\n"
06433          "See further the user guide.\n"
06434         ),
06435         AUTHORS( "Claudia Emde", "Patrick Eriksson" ),
06436         OUT( "iy", "diy_dvmr", "diy_dt" ),
06437         GOUT(),
06438         GOUT_TYPE(),
06439         GOUT_DESC(),
06440         IN( "iy", "diy_dvmr", "diy_dt", "ppath", "ppath_array",
06441                "ppath_array_index", "f_grid", "stokes_dim", "emission_agenda",
06442                "abs_scalar_gas_agenda", "rte_do_vmr_jacs",
06443                "rte_do_t_jacs" ),
06444         GIN(),
06445         GIN_TYPE(),
06446         GIN_DEFAULT(),
06447         GIN_DESC()
06448       ));
06449 
06450   md_data_raw.push_back
06451     ( MdRecord
06452       ( NAME( "RteStdWithTransmissions" ),
06453         DESCRIPTION
06454         (
06455          "As *RteStd*, but also returns path transmissions.\n"
06456          "\n"
06457          "The transmission to each point of the propagation path is returned\n"
06458          "in *ppath_transmissions*.\n"
06459         ),
06460         AUTHORS( "Patrick Eriksson" ),
06461         OUT( "iy", "ppath_transmissions", "diy_dvmr", "diy_dt" ),
06462         GOUT(),
06463         GOUT_TYPE(),
06464         GOUT_DESC(),
06465         IN( "iy", "diy_dvmr", "diy_dt", "ppath", "ppath_array",
06466                "ppath_array_index", "f_grid", "stokes_dim",
06467                "emission_agenda", "abs_scalar_gas_agenda",
06468                "rte_do_vmr_jacs", "rte_do_t_jacs" ),
06469         GIN(),
06470         GIN_TYPE(),
06471         GIN_DEFAULT(),
06472         GIN_DESC()
06473       ));
06474 
06475   md_data_raw.push_back
06476     ( MdRecord
06477       ( NAME( "rte_losSet" ),
06478         DESCRIPTION
06479         (
06480          "Sets *rte_los* to the given angles.\n"
06481          "\n"
06482          "The keyword argument *za* is put in as first element of *rte_los*\n"
06483          "and *aa* as the second element. However, when *atmosphere_dim* is\n"
06484          "set to 1D or 2D, the length of *rte_los* is set to 1 and only the\n"
06485          "given zenith angle is considered.\n"
06486          "\n"
06487          "Keywords: \n"
06488          "   za : Zenith angle of sensor line-of-sight.\n"
06489          "   aa : Azimuth angle of sensor line-of-sight.\n"
06490         ),
06491         AUTHORS( "Patrick Eriksson" ),
06492         OUT( "rte_los" ),
06493         GOUT(),
06494         GOUT_TYPE(),
06495         GOUT_DESC(),
06496         IN( "atmosphere_dim" ),
06497         GIN( "za",      "aa"      ),
06498         GIN_TYPE(    "Numeric", "Numeric" ),
06499         GIN_DEFAULT( NODEF,     NODEF ),
06500         GIN_DESC("FIXME DOC",
06501                  "FIXME DOC")
06502       ));
06503 
06504   md_data_raw.push_back
06505     ( MdRecord
06506       ( NAME( "rte_posAddGeoidWGS84" ),
06507         DESCRIPTION
06508         (
06509          "Adds a geoid radius according to WGS-84 to a geometric altitude.\n"
06510          "\n"
06511          "This function assumes that the first element of *rte_pos* is set\n"
06512          "to the geometric altitude for the position of the sensor. \n"
06513          "The variable *rte_pos* shall contain the radius instead of the\n"
06514          "altitude and that can be achieved by this function. The function\n"
06515          "adds a geoid radius to the given altitude. The geoid radius is\n"
06516          "taken from the WGS-84 reference ellipsoid.\n"
06517          "\n"
06518          "For 1D, the geoid radius is set to the radius of curvature of the\n"
06519          "WGS-84 ellipsoid for the position and observation direction \n"
06520          "described with *lat_1d* and *meridian_angle_1d*.\n"
06521          "For 2D and 3D, the geoid radius is set to the radius of the WGS-84\n"
06522          "ellipsoid for the latitude value in *rte_pos*.\n"
06523         ),
06524         AUTHORS( "Patrick Eriksson" ),
06525         OUT( "rte_pos" ),
06526         GOUT(),
06527         GOUT_TYPE(),
06528         GOUT_DESC(),
06529         IN( "rte_pos", "atmosphere_dim", "lat_1d", "meridian_angle_1d" ),
06530         GIN(),
06531         GIN_TYPE(),
06532         GIN_DEFAULT(),
06533         GIN_DESC()
06534       ));
06535 
06536   md_data_raw.push_back
06537     ( MdRecord
06538       ( NAME( "rte_posAddRgeoid" ),
06539         DESCRIPTION
06540         (
06541          "Adds a geoid radius by interpolating *r_geoid*.\n"
06542          "\n"
06543          "This function assumes that the first element of *rte_pos* is set\n"
06544          "to the geometric altitude for the position of the sensor. \n"
06545          "The variable *rte_pos* shall contain the radius instead of the\n"
06546          "altitude and that can be achieved by this function. The function\n"
06547          "adds a geoid radius to the given altitude. The geoid radius is\n"
06548          "obtained by interpolation of *r_geoid*. There is an error if the\n"
06549          "given position is outside the latitude and longitude grids.\n"
06550         ),
06551         AUTHORS( "Patrick Eriksson" ),
06552         OUT( "rte_pos" ),
06553         GOUT(),
06554         GOUT_TYPE(),
06555         GOUT_DESC(),
06556         IN( "rte_pos", "atmosphere_dim", "lat_grid", "lon_grid", "r_geoid" ),
06557         GIN(),
06558         GIN_TYPE(),
06559         GIN_DEFAULT(),
06560         GIN_DESC()
06561       ));
06562 
06563   md_data_raw.push_back
06564     ( MdRecord
06565       ( NAME( "rte_posSet" ),
06566         DESCRIPTION
06567         (
06568          "Sets *rte_pos* to the given co-ordinates.\n"
06569          "\n"
06570          "The keyword argument *r_or_z* is put in as first element of\n"
06571          "*rte_pos*, *lat* as the second element and *lon* as third element.\n"
06572          "However, the length of *rte_pos* is set to *atmosphere_dim* and\n"
06573          "keyword arguments for dimensions not used are ignored.\n"
06574          "\n"
06575          "The first keyword argument can either be a radius, or an altitude\n"
06576          "above the geoid. In the latter case, a function such as\n"
06577          "*rte_posAddGeoidWGS84* could be called to obtain a radius as\n"
06578          "first element of *rte_pos*.\n"
06579          "\n"
06580          "Keywords: \n"
06581          "   r_or_z : Radius or geometrical altitude of sensor position.\n"
06582          "   lat : Latitude of sensor position.\n"
06583          "   lon : Longitude of sensor position.\n"
06584         ),
06585         AUTHORS( "Patrick Eriksson" ),
06586         OUT( "rte_pos" ),
06587         GOUT(),
06588         GOUT_TYPE(),
06589         GOUT_DESC(),
06590         IN( "atmosphere_dim" ),
06591         GIN( "r_or_z",  "lat",     "lon"     ),
06592         GIN_TYPE(    "Numeric", "Numeric", "Numeric" ),
06593         GIN_DEFAULT( NODEF,     NODEF,     NODEF ),
06594         GIN_DESC("FIXME DOC",
06595                  "FIXME DOC",
06596                  "FIXME DOC")
06597       ));
06598 
06599   md_data_raw.push_back
06600     ( MdRecord
06601       ( NAME( "rte_posShift" ),
06602         DESCRIPTION
06603         (
06604          "Shifts rte_pos and rte_los, and rte_gp_XXX to the end of ppath.\n"
06605         ),
06606         AUTHORS( "Cory Davis" ),
06607         OUT( "rte_pos", "rte_los", "rte_gp_p", "rte_gp_lat", "rte_gp_lon" ),
06608         GOUT(),
06609         GOUT_TYPE(),
06610         GOUT_DESC(),
06611         IN( "ppath", "atmosphere_dim" ),
06612         GIN(),
06613         GIN_TYPE(),
06614         GIN_DEFAULT(),
06615         GIN_DESC()
06616       ));
06617 
06618   md_data_raw.push_back
06619     ( MdRecord
06620       ( NAME( "rte_pos_and_losFromTangentPressure" ),
06621         DESCRIPTION
06622         (
06623          "If you are doing limb calculations it can be useful to specify\n"
06624          "viewing direction and sensor position by the tangent pressure.\n"
06625          "This function takes tan_p as a keyword argument and sets rte_los\n"
06626          "and rte_pos to the apropriate position on the edge of the modelled\n"
06627          "atmosphere\n\n"
06628          "This function is a work in progress. Only 1D is currently supported\n"
06629         ),
06630         AUTHORS( "Cory Davis" ),
06631         OUT( "rte_pos", "rte_los", "ppath" ),
06632         GOUT(),
06633         GOUT_TYPE(),
06634         GOUT_DESC(),
06635         IN( "atmosphere_dim", "p_grid", "z_field", "lat_grid", "lon_grid",
06636                "ppath_step_agenda", "r_geoid", "z_surface" ),
06637         GIN( "tan_p" ),
06638         GIN_TYPE(    "Numeric" ),
06639         GIN_DEFAULT( NODEF ),
06640         GIN_DESC("FIXME DOC")
06641       ));
06642 
06643   md_data_raw.push_back
06644     ( MdRecord
06645       ( NAME( "r_geoidSpherical" ),
06646         DESCRIPTION
06647         (
06648          "Sets the geoid to be a perfect sphere.\n"
06649          "\n"
06650          "The radius of the sphere is selected by the keyword argument *r*.\n"
06651          "If the keyword is set to be negative, the radius is set to the\n"
06652          "global internal variable *EARTH_RADIUS*, defined in constants.cc.\n"
06653          "\n"
06654          "Keywords:\n"
06655          "   r : Radius of geoid sphere. See further above.\n"
06656         ),
06657         AUTHORS( "Patrick Eriksson" ),
06658         OUT( "r_geoid" ),
06659         GOUT(),
06660         GOUT_TYPE(),
06661         GOUT_DESC(),
06662         IN( "atmosphere_dim", "lat_grid", "lon_grid" ),
06663         GIN( "r" ),
06664         GIN_TYPE(    "Numeric" ),
06665         GIN_DEFAULT( NODEF ),
06666         GIN_DESC("FIXME DOC")
06667       ));
06668 
06669   md_data_raw.push_back
06670     ( MdRecord
06671       ( NAME( "r_geoidWGS84" ),
06672         DESCRIPTION
06673         (
06674          "Sets the geoid radius to match the WGS-84 reference ellipsoid.\n"
06675          "\n"
06676          "For 1D, the geoid radius is set to the radius of curvature of the\n"
06677          "WGS-84 ellipsoid for the position and observation direction \n"
06678          "described with *lat_1d* and *meridian_angle_1d*.\n"
06679          "For 2D and 3D, *r_geoid* is set to the radius of the WGS-84\n"
06680          "ellipsoid for the crossing points of the latitude and longitude\n"
06681          "grids.\n"
06682          "\n"
06683          "Please note that the latitude grid must contain true latitudes\n"
06684          "if the function shall give correct result, and not just arbitrary\n"
06685          "orbit angles which is allowed for 2D cases.\n"
06686         ),
06687         AUTHORS( "Patrick Eriksson" ),
06688         OUT( "r_geoid" ),
06689         GOUT(),
06690         GOUT_TYPE(),
06691         GOUT_DESC(),
06692         IN( "atmosphere_dim", "lat_grid", "lon_grid", "lat_1d",
06693                "meridian_angle_1d" ),
06694         GIN(),
06695         GIN_TYPE(),
06696         GIN_DEFAULT(),
06697         GIN_DESC()
06698       ));
06699 
06700   md_data_raw.push_back
06701     ( MdRecord
06702       ( NAME( "ScatteringDoit" ),
06703         DESCRIPTION
06704         (
06705          "This method executes *doit_mono_agenda* for each frequency \n"
06706          "in *f_grid*. The output is the radiation field inside the cloudbox\n"
06707          "(*doit_i_field*) and on the cloudbox boundary (*scat_i_p* (1D), \n"
06708          "*scat_i_lat* and *scat_i_lon* (3D)).\n"
06709          ),
06710         AUTHORS( "Claudia Emde" ),
06711         OUT( "doit_i_field", "scat_i_p", "scat_i_lat", "scat_i_lon",
06712                 "doit_i_field1D_spectrum" ),
06713         GOUT(),
06714         GOUT_TYPE(),
06715         GOUT_DESC(),
06716         IN( "f_grid", "scat_i_p", "scat_i_lat", "scat_i_lon",
06717                "doit_mono_agenda", "doit_is_initialized" ),
06718         GIN(),
06719         GIN_TYPE(),
06720         GIN_DEFAULT(),
06721         GIN_DESC()
06722       ));
06723  
06724   /* Has been found to not work. Probably caused by changes in agenda 
06725      functionality.
06726   md_data_raw.push_back
06727     ( MdRecord
06728       ( NAME( "ScatteringMonteCarlo" ),
06729         DESCRIPTION
06730         (
06731          "This method performs a single pencil beam monochromatic scattering\n"
06732          "calculation using a Monte Carlo algorithm \n"
06733          "\n"
06734          "The main output variables *iy* and *mc_error* represent the \n"
06735          "Stokes vector leaving the cloudbox, and the estimated error in the \n"
06736          "Stokes vector (at the sensor!- not the cloudbox exit) respectively.\n"
06737          "The keyword parameter `maxiter\' describes the number of `photons\'\n"
06738          "used in the simulation (more photons means smaller *mc_error*).\n"
06739          "std_err is the desired value of mc_error, and max_time is the maximum\n"
06740          "allowed number of seconds for ScatteringMonteCarlo.  ScatteringMonteCarlo\n"
06741          "will terminate once any of the max_iter, std_err, max_time criteria are\n"
06742          "met.  If negative values are given for these parameters then it is ignored.\n"
06743          " Negative values of rng_seed seed the random number generator \n "
06744          "according to system time, positive rng_seed values are taken literally.\n"
06745          "The incoming_lookup keyword determines if incoming radiance is obtained from\n"
06746          "a precalculated grid (mc_incoming) or calculated on the fly\n"
06747           ),
06748         AUTHORS( "Cory Davis" ),
06749         OUT( "ppath", "ppath_step", 
06750                 "mc_error", "mc_iteration_count", "rte_pos", "rte_los", "iy", 
06751                 "rte_pressure", "rte_temperature", 
06752                 "rte_vmr_list", "ext_mat", "abs_vec" ),
06753         GOUT(),
06754         GOUT_TYPE(),
06755         GOUT_DESC(),
06756         IN( "ppath", "rte_pos", "rte_los", "ppath_step_agenda", "atmosphere_dim",
06757                "p_grid", "lat_grid", "lon_grid", "z_field", "r_geoid", "z_surface",
06758                "cloudbox_limits", "stokes_dim", "rte_agenda", "iy_space_agenda",
06759                "surface_prop_agenda", "t_field", "f_grid", "opt_prop_gas_agenda",
06760                "abs_scalar_gas_agenda", "vmr_field",
06761                "scat_data_mono", "pnd_field", "mc_seed", "f_index" , "mc_incoming"),
06762         GIN( "std_err", "max_time", "max_iter", "incoming_lookup",
06763                   "z_field_is_1D"),
06764         GIN_TYPE(    "Numeric", "Index",    "Index",    "Index",
06765                   "Index" ),
06766         GIN_DEFAULT( NODEF,     NODEF,      NODEF,      NODEF,
06767                   NODEF ),
06768         GIN_DESC("FIXME DOC",
06769                  "FIXME DOC",
06770                  "FIXME DOC",
06771                  "FIXME DOC",
06772                  "FIXME DOC")
06773                   ));
06774   */
06775 
06776   md_data_raw.push_back
06777     ( MdRecord
06778       ( NAME( "scat_data_monoCalc" ),
06779         DESCRIPTION
06780         (
06781          "Interpolates scat_data_raw by frequency to give scat_data_mono\n"
06782          ),
06783         AUTHORS( "Cory Davis" ),
06784         OUT( "scat_data_mono" ),
06785         GOUT(),
06786         GOUT_TYPE(),
06787         GOUT_DESC(),
06788         IN( "scat_data_raw", "f_grid", "f_index" ),
06789         GIN(),
06790         GIN_TYPE(),
06791         GIN_DEFAULT(),
06792         GIN_DESC()
06793       ));
06794 
06795   md_data_raw.push_back
06796     ( MdRecord
06797       ( NAME( "scat_data_rawCheck" ),
06798         DESCRIPTION
06799         (
06800          "Method for checking the consistency of the optical properties\n"
06801          "in the database. \n"
06802          "\n"
06803          "This function can be used to check datafiles containing data for \n"
06804          "randomly oriented scattering media.\n"
06805          "It is checked whether the data is consistent. The integral over \n"
06806          "the phase matrix should result the scattering cross section \n"
06807          "<C_sca>.\n"
06808          "\n"
06809          "The check is if:\n"
06810          "<C_ext> - <C_sca> = <C_abs>\n"
06811          "\n"
06812          "The result is printed on the screen.\n"
06813          ),
06814         AUTHORS( "Claudia Emde" ),
06815         OUT(),
06816         GOUT(),
06817         GOUT_TYPE(),
06818         GOUT_DESC(),
06819         IN( "scat_data_raw" ),
06820         GIN(),
06821         GIN_TYPE(),
06822         GIN_DEFAULT(),
06823         GIN_DESC()
06824       ));
06825 
06826    md_data_raw.push_back
06827     ( MdRecord
06828       ( NAME( "Select" ),
06829         DESCRIPTION
06830         (
06831          "Method to select some elements from one array and copy them to\n"
06832          "a new array. (Works also for vectors.)\n"
06833          "\n"
06834          "This works also for higher dimensional objects, where the selection is\n"
06835          "always performed in the first dimension.\n"
06836          "\n"
06837          "For example:\n"
06838          "\n"
06839          "Select(y,x,[0,3])\n"
06840          "\n"
06841          "will select the first and fourth row of matrix x and copy them to the\n"
06842          "output matrix y.\n"
06843          "\n"
06844          "Note that it is even save to use this method if needles and haystack\n"
06845          "are the same variable.\n"
06846          ),
06847         AUTHORS( "Oliver Lemke" ),
06848         OUT(),
06849         GOUT( "needles" ),
06850         GOUT_TYPE( ARRAY_GROUPS + ", Vector, Matrix"),
06851         GOUT_DESC("Same object type as haystack, but only selected elements in first dimension."),
06852         IN(),
06853         GIN( "haystack", "needleindexes"),
06854         GIN_TYPE(  ARRAY_GROUPS + ", Vector, Matrix",
06855                   "ArrayOfIndex" ),
06856         GIN_DEFAULT( NODEF, NODEF ),
06857         GIN_DESC("The object to select from. May be the same variable as needles.",
06858                  "The elements to select (zero based indexing, as always.)"),
06859         SETMETHOD(      false ),
06860         AGENDAMETHOD(   false ),
06861         SUPPRESSHEADER( true  )
06862       ));
06863  
06864   md_data_raw.push_back
06865     ( MdRecord
06866       ( NAME( "sensorOff" ),
06867         DESCRIPTION
06868         (
06869          "Sets sensor WSVs to obtain monochromatic pencil beam values.\n"
06870          "\n"
06871          "The variables are set as follows:\n"
06872          "   antenna_dim             : 1.\n"
06873          "   mblock_za_grid          : Length 1, value 0.\n"
06874          "   mblock_aa_grid          : Empty.\n"
06875          "   sensor_response         : As returned by *sensor_responseInit*.\n"
06876          "   sensor_response_f       : As returned by *sensor_responseInit*.\n"
06877          "   sensor_response_pol     : As returned by *sensor_responseInit*.\n"
06878          "   sensor_response_za      : As returned by *sensor_responseInit*.\n"
06879          "   sensor_response_aa      : As returned by *sensor_responseInit*.\n"
06880         ),
06881         AUTHORS( "Patrick Eriksson" ),
06882         OUT( "sensor_response", "sensor_response_f", 
06883              "sensor_response_pol", "sensor_response_za",
06884              "sensor_response_aa", 
06885              "sensor_response_f_grid", "sensor_response_pol_grid",
06886              "sensor_response_za_grid", "sensor_response_aa_grid",
06887              "antenna_dim", "mblock_za_grid", "mblock_aa_grid" ),
06888         GOUT(),
06889         GOUT_TYPE(),
06890         GOUT_DESC(),
06891         IN( "atmosphere_dim", "stokes_dim", "f_grid" ),
06892         GIN(),
06893         GIN_TYPE(),
06894         GIN_DEFAULT(),
06895         GIN_DESC()
06896       ));
06897 
06898   md_data_raw.push_back
06899     ( MdRecord
06900       ( NAME( "sensor_posAddGeoidWGS84" ),
06901         DESCRIPTION
06902         (
06903          "Adds a geoid radius according to WGS-84 to a geometric altitude.\n"
06904          "\n"
06905          "This function assumes that the first element of *sensor_pos* is\n"
06906          "set to the geometric altitude for the positions of the sensor. \n"
06907          "The variable *sensor_pos* shall contain the radius instead of the\n"
06908          "altitude and that can be achieved by this function. The function\n"
06909          "adds a geoid radius to the given altitude. The geoid radius is\n"
06910          "taken from the WGS-84 reference ellipsoid.\n"
06911          "\n"
06912          "For 1D, the geoid radius is set to the radius of curvature of the\n"
06913          "WGS-84 ellipsoid for the position and observation direction \n"
06914          "described with *lat_1d* and *meridian_angle_1d*.\n"
06915          "For 2D and 3D, the geoid radius is set to the radius of the WGS-84\n"
06916          "ellipsoid for the latitude values in *sensor_pos*.\n"
06917         ),
06918         AUTHORS( "Patrick Eriksson" ),
06919         OUT( "sensor_pos" ),
06920         GOUT(),
06921         GOUT_TYPE(),
06922         GOUT_DESC(),
06923         IN( "sensor_pos", "atmosphere_dim", "lat_1d", "meridian_angle_1d" ),
06924         GIN(),
06925         GIN_TYPE(),
06926         GIN_DEFAULT(),
06927         GIN_DESC()
06928       ));
06929 
06930   md_data_raw.push_back
06931     ( MdRecord
06932       ( NAME( "sensor_posAddRgeoid" ),
06933         DESCRIPTION
06934         (
06935          "Adds a geoid radius by interpolating *r_geoid*.\n"
06936          "\n"
06937          "This function assumes that the first element of *rte_pos* is set\n"
06938          "to the geometric altitude for the position of the sensor. \n"
06939          "The variable *rte_pos* shall contain the radius instead of the\n"
06940          "altitude and that can be achieved by this function. The function\n"
06941          "adds a geoid radius to the given altitude. The geoid radius is\n"
06942          "obtained by interpolation of *r_geoid*. There is an error if the\n"
06943          "given position is outside the latitude and longitude grids.\n"
06944         ),
06945         AUTHORS( "Patrick Eriksson" ),
06946         OUT( "sensor_pos" ),
06947         GOUT(),
06948         GOUT_TYPE(),
06949         GOUT_DESC(),
06950         IN( "sensor_pos", "atmosphere_dim", "lat_grid", "lon_grid", "r_geoid" ),
06951         GIN(),
06952         GIN_TYPE(),
06953         GIN_DEFAULT(),
06954         GIN_DESC()
06955       ));
06956 
06957   md_data_raw.push_back
06958     ( MdRecord
06959       ( NAME("sensor_responseAntenna"),
06960         DESCRIPTION
06961         (
06962          "Adds response of the antenna.\n"
06963          "\n"
06964          "The function returns the sensor response matrix after the antenna\n" 
06965          "characteristics have been included.\n"
06966          "\n"
06967          "The function handles \"multi-beam\" cases where the polarisation\n"
06968          "coordinate system is the same for all beams.\n"
06969          "\n"         
06970          "See *antenna_dim*, *antenna_los* and *antenna_response* for\n"
06971          "details on how to specify the antenna response.\n"
06972         ),
06973         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
06974         OUT( "sensor_response", "sensor_response_f", "sensor_response_pol",
06975                 "sensor_response_za", "sensor_response_aa", 
06976                 "sensor_response_za_grid", "sensor_response_aa_grid" ),
06977         GOUT(),
06978         GOUT_TYPE(),
06979         GOUT_DESC(),
06980         IN( "sensor_response", "sensor_response_f", "sensor_response_pol",
06981             "sensor_response_za", "sensor_response_aa", "sensor_response_f_grid",
06982             "sensor_response_pol_grid", "sensor_response_za_grid",
06983             "sensor_response_aa_grid", "atmosphere_dim", "antenna_dim", 
06984             "antenna_los", "antenna_response", "sensor_norm" ),
06985         GIN(),
06986         GIN_TYPE(),
06987         GIN_DEFAULT(),
06988         GIN_DESC()
06989       ));
06990 
06991   md_data_raw.push_back
06992     ( MdRecord
06993       ( NAME("sensor_responseBackend"),
06994         DESCRIPTION
06995         (
06996          "Adds response of the backend (spectrometer).\n"
06997          "\n"
06998          "The function returns the sensor response matrix after the backend\n" 
06999          "characteristics have been included.\n"
07000          "\n"
07001          "See *f_backend*, *backend_channel_response* and *sensor_norm* for\n"
07002          "details on how to specify the backend response.\n"
07003         ),
07004         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
07005         OUT( "sensor_response", "sensor_response_f", "sensor_response_pol",
07006                 "sensor_response_za", "sensor_response_aa", 
07007                 "sensor_response_f_grid" ),
07008         GOUT(),
07009         GOUT_TYPE(),
07010         GOUT_DESC(),
07011         IN( "sensor_response", "sensor_response_f", "sensor_response_pol",
07012                "sensor_response_za", "sensor_response_aa", 
07013                "sensor_response_f_grid", "sensor_response_pol_grid", 
07014                "sensor_response_za_grid", "sensor_response_aa_grid",
07015                "f_backend", "backend_channel_response", "sensor_norm" ),
07016         GIN(),
07017         GIN_TYPE(),
07018         GIN_DEFAULT(),
07019         GIN_DESC()
07020       ));
07021 
07022   md_data_raw.push_back
07023     ( MdRecord
07024       ( NAME( "sensor_responseBeamSwitching" ),
07025         DESCRIPTION
07026         (
07027          "Calculates the difference spectrum: Beam switching\n"
07028          "\n"
07029          "The method allows to mimic beam switching. The measurement procedure\n"
07030          "is basedon taking the difference of two spectra and the calculation\n"
07031          "set-up must treat exactly two observation directions.\n"
07032          "\n"
07033          "The returned spectrum is y = w1*y + w2*y2, where y1 and w1 are the\n"
07034          "spectrum and weight for the first direction, respectively (y2 and\n"
07035          "(w2 defined corresponingly for second direction).\n"
07036         ),
07037         AUTHORS( "Patrick Eriksson" ),
07038         OUT( "sensor_response", "sensor_response_f", "sensor_response_pol",
07039              "sensor_response_za", "sensor_response_aa", 
07040              "sensor_response_za_grid", "sensor_response_aa_grid" ),
07041         GOUT(),
07042         GOUT_TYPE(),
07043         GOUT_DESC(),
07044         IN( "sensor_response", "sensor_response_f", "sensor_response_pol",
07045             "sensor_response_za", "sensor_response_aa", "sensor_response_f_grid",
07046             "sensor_response_pol_grid", "sensor_response_za_grid",
07047             "sensor_response_aa_grid" ),
07048         GIN( "w1", "w2" ),
07049         GIN_TYPE( "Numeric", "Numeric" ),
07050         GIN_DEFAULT( "-1", "1" ),
07051         GIN_DESC( "Weight for values from first viewing direction.", 
07052                   "Weight for values from second viewing direction." )
07053       ));
07054 
07055   md_data_raw.push_back
07056     ( MdRecord
07057       ( NAME("sensor_responseIF2RF"),
07058         DESCRIPTION
07059         (
07060          "Converts sensor response variables from IF to RF.\n"
07061          "\n"
07062          "The function converts intermediate frequencies (IF) in\n"
07063          "*sensor_response_f* and *sensor_response_f_grid* to radio\n"
07064          "frequencies (RF). This conversion is needed if the frequency\n"
07065          "translation of a mixer is included and the position of backend\n"
07066          "channels are specified in RF.\n"
07067          "\n"
07068          "A direct frequency conversion is performed. Values are not\n"
07069          "sorted in any way.\n"
07070          ),
07071         AUTHORS( "Patrick Eriksson" ),
07072         OUT( "sensor_response_f", "sensor_response_f_grid" ),
07073         GOUT(),
07074         GOUT_TYPE(),
07075         GOUT_DESC(),
07076         IN( "sensor_response_f", "sensor_response_f_grid", 
07077                "lo", "sideband_mode" ),
07078         GIN(),
07079         GIN_TYPE(),
07080         GIN_DEFAULT(),
07081         GIN_DESC()
07082       ));
07083 
07084   md_data_raw.push_back
07085     ( MdRecord
07086       ( NAME("sensor_responseInit"),
07087         DESCRIPTION
07088         (
07089          "Initialises the variables summarising the sensor response.\n"
07090          "\n"
07091          "This method sets the variables to match monochromatic pencil beam\n"
07092          "calculations, to be further modified by inclusion of sensor\n"
07093          "characteristics. If pure monochromatic pencil beam calculations\n"
07094          "shall be performed use *sensorOff*.\n"
07095          "\n"
07096          "The variables are set as follows:\n"
07097          "   sensor_response : Identity matrix, with size matching *f_grid*,\n"
07098          "                     *stokes_dim* *mblock_za_grid* and\n"
07099          "                     *mblock_aa_grid*.\n"
07100          "   sensor_response_f       : Repeated values of *f_grid*.\n"
07101          "   sensor_response_pol     : Data matching *stokes_dim*.\n"
07102          "   sensor_response_za      : Repeated values of *mblock_za_grid*.\n"
07103          "   sensor_response_aa      : Repeated values of *mblock_aa_grid*.\n"
07104          "   sensor_response_f_grid  : Equal to *f_grid*.\n"
07105          "   sensor_response_pol_grid: Set to 1:*stokes_dim*.\n"
07106          "   sensor_response_za_grid : Equal to *mblock_za_grid*.\n"
07107          "   sensor_response_aa_grid : Equal to *mblock_aa_grid*.\n"
07108          "\n"
07109          "The standard order of WSM calls for creating *sensor_response* is:\n"
07110          "   sensor_responseInit\n"
07111          "   sensor_responseAntenna1D\n"
07112          "   sensor_responseRotation\n"
07113          "   sensor_responsePolarisation\n"
07114          "   sensor_responseMixer\n"
07115          "   sensor_responseBackend\n"
07116          "It is not necessary to include a method for all sensor responses.\n"
07117          "There exist several method versions for some responses.\n"
07118         ),
07119         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
07120         OUT( "sensor_response", "sensor_response_f", "sensor_response_pol", 
07121                 "sensor_response_za", "sensor_response_aa", 
07122                 "sensor_response_f_grid", "sensor_response_pol_grid",
07123                 "sensor_response_za_grid", "sensor_response_aa_grid" ),
07124         GOUT(),
07125         GOUT_TYPE(),
07126         GOUT_DESC(),
07127         IN( "f_grid", "mblock_za_grid", "mblock_aa_grid", "antenna_dim",
07128                "atmosphere_dim", "stokes_dim", "sensor_norm" ),
07129         GIN(),
07130         GIN_TYPE(),
07131         GIN_DEFAULT(),
07132         GIN_DESC()
07133       ));
07134 
07135   md_data_raw.push_back
07136     ( MdRecord
07137       ( NAME("sensor_responseMixer"),
07138         DESCRIPTION
07139         (
07140          "Adds response of the mixer of a heterodyne system.\n"
07141          "\n"
07142          "The function returns the sensor response matrix after the mixer\n" 
07143          "characteristics have been included. Frequency variables are\n"
07144          "converted from radio frequency (RF) to intermediate frequency (IF).\n"
07145          "\n"
07146          "See *lo* and *sideband_response* for details on how to specify the\n"
07147          "mixer response\n"
07148         ),
07149         AUTHORS( "Mattias Ekstrom", "Patrick Eriksson" ),
07150         OUT( "sensor_response", "sensor_response_f", "sensor_response_pol",
07151                 "sensor_response_za", "sensor_response_aa", 
07152                 "sensor_response_f_grid" ),
07153         GOUT(),
07154         GOUT_TYPE(),
07155         GOUT_DESC(),
07156         IN( "sensor_response", "sensor_response_f", "sensor_response_pol",
07157                "sensor_response_za", "sensor_response_aa", "sensor_response_f_grid",
07158                "sensor_response_pol_grid", "sensor_response_za_grid",
07159                "sensor_response_aa_grid", "lo", "sideband_response", "sensor_norm" ),
07160         GIN(),
07161         GIN_TYPE(),
07162         GIN_DEFAULT(),
07163         GIN_DESC()
07164       ));
07165 
07166   md_data_raw.push_back
07167     ( MdRecord
07168       ( NAME("sensor_responseMultiMixerBackend"),
07169         DESCRIPTION
07170         (
07171          "Handles mixer and backend parts for an instrument having multiple\n"
07172          "mixer chains.\n"
07173          "\n"
07174          "The WSMs *sensor_responseMixer*, *sensor_responseIF2RF* and\n"
07175          "*sensor_responseBackend* are called for each mixer chain, and a\n"
07176          "complete *sensor_response* is assembled. The instrument responses\n"
07177          "are described by *lo_multi*, *sideband_response_multi*,\n"
07178          "*sideband_mode_multi*, *f_backend_multi* and\n"
07179          "*backend_channel_response_multi*. All these WSVs must have same\n"
07180          "(vector or array) length. As *sensor_responseIF2RF* is called,\n"
07181          "*f_backend_multi* must hold RF (not IF) and output frequencies\n"
07182          "will be in absolute frequency (RF).\n"
07183         ),
07184         AUTHORS( "Patrick Eriksson" ),
07185         OUT( "sensor_response", "sensor_response_f", "sensor_response_pol",
07186                 "sensor_response_za", "sensor_response_aa", 
07187                 "sensor_response_f_grid" ),
07188         GOUT(),
07189         GOUT_TYPE(),
07190         GOUT_DESC(),
07191         IN( "sensor_response", "sensor_response_f", "sensor_response_pol",
07192                "sensor_response_za", "sensor_response_aa", 
07193                "sensor_response_f_grid", "sensor_response_pol_grid", 
07194                "sensor_response_za_grid", "sensor_response_aa_grid",
07195                "lo_multi", "sideband_response_multi", 
07196                "sideband_mode_multi", "f_backend_multi",
07197                "backend_channel_response_multi", "sensor_norm" ),
07198         GIN(),
07199         GIN_TYPE(),
07200         GIN_DEFAULT(),
07201         GIN_DESC()
07202       ));
07203   
07204   /* Not yet updated
07205   md_data_raw.push_back
07206     ( MdRecord
07207       ( NAME("sensor_responsePolarisation"),
07208         DESCRIPTION
07209         (
07210          "Adds polarisation to the response matrix.\n"
07211          "\n"
07212          "The output polarisations are given by matrix *sensor_pol*.\n"
07213         ),
07214         AUTHORS( "Mattias Ekstrom" ),
07215         OUT( "sensor_response", "sensor_response_pol" ),
07216         GOUT(),
07217         GOUT_TYPE(),
07218         GOUT_DESC(),
07219         IN( "sensor_pol", "sensor_response_za", "sensor_response_aa",
07220                "sensor_response_f", "stokes_dim"),
07221         GIN(),
07222         GIN_TYPE(),
07223         GIN_DEFAULT(),
07224         GIN_DESC()
07225         ));
07226   */
07227 
07228   /* Not yet updated
07229   md_data_raw.push_back
07230     ( MdRecord
07231       ( NAME("sensor_responseRotation"),
07232         DESCRIPTION
07233         (
07234          "Adds rotation to the response matrix.\n"
07235          "\n"
07236          "The rotations are given by *sensor_rot* combined with *antenna_los*.\n"
07237          "The rotations are performed within each measurement block for the\n"
07238          "individual antennae.\n"
07239          "\n"
07240          "If used this method has to be run after the antenna response\n"
07241          "function and prior to sensor_responsePolarisation.\n"
07242         ),
07243         AUTHORS( "Mattias Ekstrom" ),
07244         OUT( "sensor_response" ),
07245         GOUT(),
07246         GOUT_TYPE(),
07247         GOUT_DESC(),
07248         IN( "sensor_rot", "antenna_los", "antenna_dim", "stokes_dim",
07249                "sensor_response_f", "sensor_response_za"),
07250         GIN(),
07251         GIN_TYPE(),
07252         GIN_DEFAULT(),
07253         GIN_DESC()
07254         ));
07255   */
07256 
07257   md_data_raw.push_back
07258     ( MdRecord
07259       ( NAME( "SparseCreate" ),
07260         DESCRIPTION
07261         (
07262          "Creates an empty Sparse matrix.\n"
07263          "\n"
07264          "If the variable already exists, it'll be reset.\n"
07265          "\n"
07266          "Generic output: \n"
07267          "   Sparse: New empty Sparse matrix.\n"
07268         ),
07269         AUTHORS( "Oliver Lemke" ),
07270         OUT(),
07271         GOUT(      "gout1"       ),
07272         GOUT_TYPE( "Sparse" ),
07273         GOUT_DESC("FIXME DOC"),
07274         IN(),
07275         GIN(),
07276         GIN_TYPE(),
07277         GIN_DEFAULT(),
07278         GIN_DESC()
07279       ));
07280 
07281   md_data_raw.push_back
07282     ( MdRecord
07283       ( NAME( "StringCreate" ),
07284         DESCRIPTION
07285         (
07286          "Creates an empty String.\n"
07287          "\n"
07288          "If the variable already exists, it'll be reset.\n"
07289          "\n"
07290          "Generic output: \n"
07291          "   String: New empty String.\n"
07292         ),
07293         AUTHORS( "Oliver Lemke" ),
07294         OUT(),
07295         GOUT(      "gout1"       ),
07296         GOUT_TYPE( "String" ),
07297         GOUT_DESC("FIXME DOC"),
07298         IN(),
07299         GIN(),
07300         GIN_TYPE(),
07301         GIN_DEFAULT(),
07302         GIN_DESC()
07303       ));
07304 
07305   md_data_raw.push_back
07306     ( MdRecord
07307       ( NAME("StringSet"),
07308         DESCRIPTION
07309         (
07310          "Sets a String to the given text string.\n"
07311         ),
07312         AUTHORS( "Patrick Eriksson" ),
07313         OUT(),
07314         GOUT(      "gout1"       ),
07315         GOUT_TYPE( "String" ),
07316         GOUT_DESC("FIXME DOC"),
07317         IN(),
07318         GIN( "text"   ),
07319         GIN_TYPE(    "String" ),
07320         GIN_DEFAULT( NODEF ),
07321         GIN_DESC("FIXME DOC"),
07322         SETMETHOD( true )
07323       ));
07324 
07325   md_data_raw.push_back
07326     ( MdRecord
07327       ( NAME( "surfaceBlackbody" ),
07328         DESCRIPTION
07329         (
07330          "Creates variables to mimic a blackbody surface.\n"
07331          "\n"
07332          "This method sets up *surface_los*, *surface_rmatrix* and\n"
07333          "*surface_emission* for *surfaceCalc*. In this case, *surface_los*\n"
07334          "and *surface_rmatrix* are set to be empty, and *surface_emission*\n"
07335          "to hold blackbody radiation for a temperature of *surface_skin_t*.\n"
07336         ),
07337         AUTHORS( "Patrick Eriksson" ),
07338         OUT( "surface_los", "surface_rmatrix", "surface_emission" ),
07339         GOUT(),
07340         GOUT_TYPE(),
07341         GOUT_DESC(),
07342         IN( "f_grid", "stokes_dim", "surface_skin_t" ),
07343         GIN(),
07344         GIN_TYPE(),
07345         GIN_DEFAULT(),
07346         GIN_DESC()
07347       ));
07348 
07349   md_data_raw.push_back
07350     ( MdRecord
07351       ( NAME( "surfaceFlatRefractiveIndex" ),
07352         DESCRIPTION
07353         (
07354          "Creates variables to mimic specular reflection by a (flat) surface\n"
07355          "where the refracive index is specified.\n"
07356          "\n"
07357          "The dielectric properties of the surface are described by\n"
07358          "*complex_n*. The Fresnel eqiuations are used to calculate \n"
07359          "amplitude reflection coefficients. The method can thus result\n"
07360          "in that the reflection properties differ between frequencies\n"
07361          "and polarizations.\n"
07362          "\n"
07363          "Local thermodynamic equilibrium is assumed, which corresponds to\n"
07364          "that the reflection and emission coefficients add up to 1.\n"
07365         ),
07366         AUTHORS( "Patrick Eriksson" ),
07367         OUT( "surface_los", "surface_rmatrix", "surface_emission" ),
07368         GOUT(),
07369         GOUT_TYPE(),
07370         GOUT_DESC(),
07371         IN( "f_grid", "stokes_dim", "atmosphere_dim", "rte_los", 
07372             "surface_skin_t", "complex_n" ),
07373         GIN(),
07374         GIN_TYPE(),
07375         GIN_DEFAULT(),
07376         GIN_DESC()
07377       ));
07378 
07379   md_data_raw.push_back
07380     ( MdRecord
07381       ( NAME( "surfaceFlatSingleEmissivity" ),
07382         DESCRIPTION
07383         (
07384          "Creates variables to mimic specular reflection by a (flat) surface\n"
07385          "where the emissivity is specified.\n"
07386          "\n"
07387          "As *surfaceFlatVaryingEmissivity*, but assumes that the emissivity\n"
07388          "does not vary with frequency.\n"
07389          "\n"
07390          "Generic output and input:\n"
07391          "  surface_emissivity : The emissivity, a value between 0 and 1.\n"
07392         ),
07393         AUTHORS( "Patrick Eriksson" ),
07394         OUT( "surface_los", "surface_rmatrix", "surface_emission" ),
07395         GOUT(),
07396         GOUT_TYPE(),
07397         GOUT_DESC(),
07398         IN( "f_grid", "stokes_dim", "atmosphere_dim", "rte_los", 
07399             "surface_skin_t" ),
07400         GIN( "surface_emissivity" ),
07401         GIN_TYPE( "Numeric" ),
07402         GIN_DEFAULT( NODEF ),
07403         GIN_DESC("FIXME DOC")
07404       ));
07405 
07406   md_data_raw.push_back
07407     ( MdRecord
07408       ( NAME( "surfaceFlatVaryingEmissivity" ),
07409         DESCRIPTION
07410         (
07411          "Creates variables to mimic specular reflection by a (flat) surface\n"
07412          "where the emissivity is specified.\n"
07413          "\n"
07414          "The usage of emissivity does not provide any polarisation\n"
07415          "information and it is only formally correct to use this method\n"
07416          "for *stokes_dim* = 1 (but there is no hard-coded restriction).\n"
07417          "\n"
07418          "Local thermodynamic equilibrium is assumed, which corresponds to\n"
07419          "that the reflection and emission coefficients add up to 1.\n"
07420          "\n"
07421          "Generic output and input:\n"
07422          "  surface_emissivity : The emissivity, for each frequency in\n"
07423          "                       *f_grid*. Values between 0 and 1.\n"
07424         ),
07425         AUTHORS( "Patrick Eriksson" ),
07426         OUT( "surface_los", "surface_rmatrix", "surface_emission" ),
07427         GOUT(),
07428         GOUT_TYPE(),
07429         GOUT_DESC(),
07430         IN( "f_grid", "stokes_dim", "atmosphere_dim", "rte_los", 
07431             "surface_skin_t" ),
07432         GIN( "surface_emissivity" ),
07433         GIN_TYPE( "Vector" ),
07434         GIN_DEFAULT( NODEF ),
07435         GIN_DESC("FIXME DOC")
07436       ));
07437 
07438   md_data_raw.push_back
07439     ( MdRecord
07440       ( NAME( "Tensor3Create" ),
07441         DESCRIPTION
07442         (
07443          "Creates an empty Tensor3.\n"
07444          "\n"
07445          "If the variable already exists, it'll be reset.\n"
07446          "\n"
07447          "Generic output: \n"
07448          "   Tensor3: New empty Tensor3.\n"
07449         ),
07450         AUTHORS( "Oliver Lemke" ),
07451         OUT(),
07452         GOUT(      "gout1"        ),
07453         GOUT_TYPE( "Tensor3" ),
07454         GOUT_DESC("FIXME DOC"),
07455         IN(),
07456         GIN(),
07457         GIN_TYPE(),
07458         GIN_DEFAULT(),
07459         GIN_DESC()
07460       ));
07461 
07462   md_data_raw.push_back
07463     ( MdRecord
07464       ( NAME("Tensor3FillWithVector"),
07465         DESCRIPTION
07466         (
07467          "Forms a tensor of order 3 by repeating a vector.\n"
07468          "\n"
07469          "The direction of the vector inside the tensor is selected by\n"
07470          "setting the size determined by the vector length to 0. For \n"
07471          "example, if the keyword *ncols* is set to 0, the vector will be\n"
07472          "put in as rows on every page. The remaining sizes are taken from \n"
07473          "the keyword arguments. \n"
07474          "\n"
07475          "One, but only one, keyword argument must be 0.\n"
07476          "\n"
07477          "Generic output: \n"
07478          "   Tensor3 : The tensor to be created. \n"
07479          "\n"
07480          "Generic input: \n"
07481          "   Vector : The vector to be copied. \n"
07482          "Keyword: \n"
07483          "   npages : Number of pages in the tensor.\n"
07484          "   nrows  : Number of rows in the tensor.\n"
07485          "   ncols  : Number of columns in the tensor.\n"
07486         ),
07487         AUTHORS( "Patrick Eriksson" ),
07488         OUT(),
07489         GOUT(      "gout1"        ),
07490         GOUT_TYPE( "Tensor3" ),
07491         GOUT_DESC("FIXME DOC"),
07492         IN(),
07493         GIN(      "gin1"      ,
07494                   "npages", "nrows", "ncols"   ),
07495         GIN_TYPE(    "Vector",
07496                      "Index",  "Index", "Index" ),
07497         GIN_DEFAULT( NODEF   ,
07498                   NODEF,    NODEF,   NODEF ),
07499         GIN_DESC("FIXME DOC",
07500                  "FIXME DOC",
07501                  "FIXME DOC",
07502                  "FIXME DOC")
07503       ));
07504 
07505   md_data_raw.push_back
07506     ( MdRecord
07507       ( NAME("Tensor3Scale"),
07508         DESCRIPTION
07509         (
07510          "Scales a workspace tensor3 with the specified value. \n"
07511          "\n"
07512          "The result can either be stored in the input tensor3 or\n"
07513          "in a new tensor3.\n"
07514          "\n"
07515          "Generic output: \n"
07516          "   Tensor3 : The scaled tensor3. \n"
07517          "\n"
07518          "Generic input: \n"
07519          "   Tensor3 : The tensor3 to be scaled.\n"
07520          "\n"
07521          "Keywords:\n"
07522          "   value  : The scale factor.\n"
07523         ),
07524         AUTHORS( "Mattias Ekstrom" ),
07525         OUT(),
07526         GOUT(      "gout1"        ),
07527         GOUT_TYPE( "Tensor3" ),
07528         GOUT_DESC("FIXME DOC"),
07529         IN(),
07530         GIN(      "gin1"       ,
07531                   "value"   ),
07532         GIN_TYPE(    "Tensor3",
07533                   "Numeric" ),
07534         GIN_DEFAULT( NODEF    ,
07535                   NODEF ),
07536         GIN_DESC("FIXME DOC",
07537                  "FIXME DOC")
07538       ));
07539 
07540   md_data_raw.push_back
07541     ( MdRecord
07542       ( NAME("Tensor3SetConstant"),
07543         DESCRIPTION
07544         (
07545          "Creates a workspace tensor3 and sets all elements of the \n"
07546          "tensor3 to the specified value. The size is determined by \n"
07547          "the variables *ncols*, *nrows*, and *npages* \n"
07548          "\n"
07549          "Generic output: \n"
07550          "   Tensor3 : The tensor3 to be created. \n"
07551          "\n"
07552          "Keywords:\n"
07553          "   value  : The value of the tensor3 elements.\n"
07554         ),
07555         AUTHORS( "Claudia Emde" ),
07556         OUT(),
07557         GOUT(      "gout1"        ),
07558         GOUT_TYPE( "Tensor3" ),
07559         GOUT_DESC("FIXME DOC"),
07560         IN( "npages", "nrows", "ncols" ),
07561         GIN( "value"   ),
07562         GIN_TYPE(    "Numeric" ),
07563         GIN_DEFAULT( NODEF ),
07564         GIN_DESC("FIXME DOC")
07565       ));
07566 
07567   md_data_raw.push_back
07568     ( MdRecord
07569       ( NAME( "Tensor4Create" ),
07570         DESCRIPTION
07571         (
07572          "Creates an empty Tensor4.\n"
07573          "\n"
07574          "If the variable already exists, it'll be reset.\n"
07575          "\n"
07576          "Generic output: \n"
07577          "   Tensor4: New empty Tensor4.\n"
07578         ),
07579         AUTHORS( "Oliver Lemke" ),
07580         OUT(),
07581         GOUT(      "gout1"        ),
07582         GOUT_TYPE( "Tensor4" ),
07583         GOUT_DESC("FIXME DOC"),
07584         IN(),
07585         GIN(),
07586         GIN_TYPE(),
07587         GIN_DEFAULT(),
07588         GIN_DESC()
07589       ));
07590 
07591   md_data_raw.push_back
07592     ( MdRecord
07593       ( NAME("Tensor4Scale"),
07594         DESCRIPTION
07595         (
07596          "Scales a workspace tensor4 with the specified value. \n"
07597          "\n"
07598          "The result can either be stored in the input tensor4 or\n"
07599          "in a new tensor4.\n"
07600          "\n"
07601          "Generic output: \n"
07602          "   Tensor4 : The scaled tensor4. \n"
07603          "\n"
07604          "Generic input: \n"
07605          "   Tensor4 : The tensor4 to be scaled.\n"
07606          "\n"
07607          "Keywords:\n"
07608          "   value  : The scale factor.\n"
07609         ),
07610         AUTHORS( "Mattias Ekstrom" ),
07611         OUT(),
07612         GOUT(      "gout1"        ),
07613         GOUT_TYPE( "Tensor4" ),
07614         GOUT_DESC("FIXME DOC"),
07615         IN(),
07616         GIN(      "gin1"       ,
07617                   "value"   ),
07618         GIN_TYPE(    "Tensor4",
07619                   "Numeric" ),
07620         GIN_DEFAULT( NODEF    ,
07621                   NODEF ),
07622         GIN_DESC("FIXME DOC",
07623                  "FIXME DOC")
07624       ));
07625 
07626   md_data_raw.push_back
07627     ( MdRecord
07628       ( NAME("Tensor4SetConstant"),
07629         DESCRIPTION
07630         (
07631          "Creates a workspace tensor4 and sets all elements of the \n"
07632          "tensor4 to the specified value. The size is determined by \n"
07633          "the variables *ncols*, *nrows*, *npages*, and *nbooks*. \n"
07634          "\n"
07635          "Generic output: \n"
07636          "   Tensor4 : The tensor4 to be created. \n"
07637          "\n"
07638          "Keywords:\n"
07639          "   value  : The value of the tensor4 elements.\n"
07640         ),
07641         AUTHORS( "Claudia Emde" ),
07642         OUT(),
07643         GOUT(      "gout1"        ),
07644         GOUT_TYPE( "Tensor4" ),
07645         GOUT_DESC("FIXME DOC"),
07646         IN( "nbooks", "npages", "nrows", "ncols" ),
07647         GIN( "value"   ),
07648         GIN_TYPE(    "Numeric" ),
07649         GIN_DEFAULT( NODEF ),
07650         GIN_DESC("FIXME DOC")
07651       ));
07652 
07653   md_data_raw.push_back
07654     ( MdRecord
07655       ( NAME( "Tensor5Create" ),
07656         DESCRIPTION
07657         (
07658          "Creates an empty Tensor5.\n"
07659          "\n"
07660          "If the variable already exists, it'll be reset.\n"
07661          "\n"
07662          "Generic output: \n"
07663          "   Tensor5: New empty Tensor5.\n"
07664         ),
07665         AUTHORS( "Oliver Lemke" ),
07666         OUT(),
07667         GOUT(      "gout1"        ),
07668         GOUT_TYPE( "Tensor5" ),
07669         GOUT_DESC("FIXME DOC"),
07670         IN(),
07671         GIN(),
07672         GIN_TYPE(),
07673         GIN_DEFAULT(),
07674         GIN_DESC()
07675       ));
07676 
07677   md_data_raw.push_back
07678     ( MdRecord
07679       ( NAME("Tensor5Scale"),
07680         DESCRIPTION
07681         (
07682          "Scales a workspace tensor5 with the specified value. \n"
07683          "\n"
07684          "The result can either be stored in the input tensor5 or\n"
07685          "in a new tensor5.\n"
07686          "\n"
07687          "Generic output: \n"
07688          "   Tensor5 : The scaled tensor5. \n"
07689          "\n"
07690          "Generic input: \n"
07691          "   Tensor5 : The tensor5 to be scaled.\n"
07692          "\n"
07693          "Keywords:\n"
07694          "   value  : The scale factor.\n"
07695         ),
07696         AUTHORS( "Mattias Ekstrom" ),
07697         OUT(),
07698         GOUT(      "gout1"        ),
07699         GOUT_TYPE( "Tensor5" ),
07700         GOUT_DESC("FIXME DOC"),
07701         IN(),
07702         GIN(      "gin1"       ,
07703                   "value"   ),
07704         GIN_TYPE(    "Tensor5",
07705                      "Numeric" ),
07706         GIN_DEFAULT( NODEF    ,
07707                   NODEF ),
07708         GIN_DESC("FIXME DOC",
07709                  "FIXME DOC")
07710       ));
07711 
07712   md_data_raw.push_back
07713     ( MdRecord
07714       ( NAME("Tensor5SetConstant"),
07715         DESCRIPTION
07716         (
07717          "Creates a workspace tensor5 and sets all elements of the \n"
07718          "tensor5 to the specified value. The size is determined by the \n"
07719          "variables *ncols*, *nrows*, *npages*, *nbooks*, and *nshelves*. \n"
07720          "\n"
07721          "Generic output: \n"
07722          "   Tensor5 : The tensor5 to be created. \n"
07723          "\n"
07724          "Keywords:\n"
07725          "   value   : The value of the tensor5 elements.\n"
07726         ),
07727         AUTHORS( "Claudia Emde" ),
07728         OUT(),
07729         GOUT(      "gout1"        ),
07730         GOUT_TYPE( "Tensor5" ),
07731         GOUT_DESC("FIXME DOC"),
07732         IN( "nshelves", "nbooks", "npages", "nrows", "ncols" ),
07733         GIN( "value" ),
07734         GIN_TYPE(    "Numeric" ),
07735         GIN_DEFAULT( NODEF ),
07736         GIN_DESC("FIXME DOC")
07737       ));
07738 
07739   md_data_raw.push_back
07740     ( MdRecord
07741       ( NAME( "Tensor6Create" ),
07742         DESCRIPTION
07743         (
07744          "Creates an empty Tensor6.\n"
07745          "\n"
07746          "If the variable already exists, it'll be reset.\n"
07747          "\n"
07748          "Generic output: \n"
07749          "   Tensor6: New empty Tensor6.\n"
07750         ),
07751         AUTHORS( "Oliver Lemke" ),
07752         OUT(),
07753         GOUT(      "gout1"        ),
07754         GOUT_TYPE( "Tensor6" ),
07755         GOUT_DESC("FIXME DOC"),
07756         IN(),
07757         GIN(),
07758         GIN_TYPE(),
07759         GIN_DEFAULT(),
07760         GIN_DESC()
07761       ));
07762 
07763   md_data_raw.push_back
07764     ( MdRecord
07765       ( NAME("Tensor6Scale"),
07766         DESCRIPTION
07767         (
07768          "Scales a workspace tensor6 with the specified value. \n"
07769          "\n"
07770          "The result can either be stored in the input tensor6 or\n"
07771          "in a new tensor6.\n"
07772          "\n"
07773          "Generic output: \n"
07774          "   Tensor6 : The scaled tensor6. \n"
07775          "\n"
07776          "Generic input: \n"
07777          "   Tensor6 : The tensor6 to be scaled.\n"
07778          "\n"
07779          "Keywords:\n"
07780          "   value  : The scale factor.\n"
07781         ),
07782         AUTHORS( "Mattias Ekstrom" ),
07783         OUT(),
07784         GOUT(      "gout1"        ),
07785         GOUT_TYPE( "Tensor6" ),
07786         GOUT_DESC("FIXME DOC"),
07787         IN(),
07788         GIN(      "gin1"       ,
07789                   "value"   ),
07790         GIN_TYPE(    "Tensor6",
07791                      "Numeric" ),
07792         GIN_DEFAULT( NODEF    ,
07793                   NODEF ),
07794         GIN_DESC("FIXME DOC",
07795                  "FIXME DOC")
07796       ));
07797 
07798   md_data_raw.push_back
07799     ( MdRecord
07800       ( NAME("Tensor6SetConstant"),
07801         DESCRIPTION
07802         (
07803          "Creates a workspace tensor6 and sets all elements of the \n"
07804          "tensor6 to the specified value. The size is determined by the \n"
07805          "variables *ncols*, *nrows*, *npages*, *nbooks*, *nshelves*, \n"
07806          "and *nvitrines*. \n"
07807          "\n"
07808          "Generic output: \n"
07809          "   Tensor6 : The tensor6 to be created. \n"
07810          "\n"
07811          "Keywords:\n"
07812          "   value     : The value of the tensor6 elements.\n"
07813         ),
07814         AUTHORS( "Claudia Emde" ),
07815         OUT(),
07816         GOUT(      "gout1"        ),
07817         GOUT_TYPE( "Tensor6" ),
07818         GOUT_DESC("FIXME DOC"),
07819         IN( "nvitrines", "nshelves", "nbooks", "npages", "nrows", "ncols" ),
07820         GIN( "value" ),
07821         GIN_TYPE(    "Numeric" ),
07822         GIN_DEFAULT( NODEF ),
07823         GIN_DESC("FIXME DOC")
07824       ));
07825 
07826   md_data_raw.push_back
07827     ( MdRecord
07828       ( NAME( "Tensor6ToPlanckBT" ),
07829         DESCRIPTION
07830         (
07831          "Converts a Tensor6 of radiances to brightness temperatures by \n"
07832          "inverting the Planck function. \n"
07833          "\n"
07834          "Generic output: \n"
07835          "   Tensor6 : A Tensor6 with brightness temperature values. \n"
07836          "\n"
07837          "Generic input: \n"
07838          "   Tenosr6 : A Tensor6 with radiance values. \n"
07839          ),
07840         AUTHORS( "Claudia Emde" ),
07841         OUT(),
07842         GOUT(      "gout1"        ),
07843         GOUT_TYPE( "Tensor6" ),
07844         GOUT_DESC("FIXME DOC"),
07845         IN("f_index", "f_grid"),
07846         GIN(      "gin1"        ),
07847         GIN_TYPE(    "Tensor6" ),
07848         GIN_DEFAULT( NODEF     ),
07849         GIN_DESC("FIXME DOC")
07850       ));
07851 
07852   md_data_raw.push_back
07853     ( MdRecord
07854       ( NAME( "Tensor7Create" ),
07855         DESCRIPTION
07856         (
07857          "Creates an empty Tensor7.\n"
07858          "\n"
07859          "If the variable already exists, it'll be reset.\n"
07860          "\n"
07861          "Generic output: \n"
07862          "   Tensor7: New empty Tensor7.\n"
07863         ),
07864         AUTHORS( "Oliver Lemke" ),
07865         OUT(),
07866         GOUT(      "gout1"        ),
07867         GOUT_TYPE( "Tensor7" ),
07868         GOUT_DESC("FIXME DOC"),
07869         IN(),
07870         GIN(),
07871         GIN_TYPE(),
07872         GIN_DEFAULT(),
07873         GIN_DESC()
07874       ));
07875 
07876   md_data_raw.push_back
07877     ( MdRecord
07878       ( NAME("Tensor7Scale"),
07879         DESCRIPTION
07880         (
07881          "Scales a workspace tensor7 with the specified value. \n"
07882          "\n"
07883          "The result can either be stored in the input tensor7 or\n"
07884          "in a new tensor7.\n"
07885          "\n"
07886          "Generic output: \n"
07887          "   Tensor7 : The scaled tensor7. \n"
07888          "\n"
07889          "Generic input: \n"
07890          "   Tensor7 : The tensor7 to be scaled.\n"
07891          "\n"
07892          "Keywords:\n"
07893          "   value  : The scale factor.\n"
07894         ),
07895         AUTHORS( "Claudia Emde" ),
07896         OUT(),
07897         GOUT(      "gout1"        ),
07898         GOUT_TYPE( "Tensor7" ),
07899         GOUT_DESC("FIXME DOC"),
07900         IN(),
07901         GIN(      "gin1"       ,
07902                   "value" ),
07903         GIN_TYPE(    "Tensor7",
07904                   "Numeric" ),
07905         GIN_DEFAULT( NODEF    ,
07906                   NODEF ),
07907         GIN_DESC("FIXME DOC",
07908                  "FIXME DOC")
07909       ));
07910 
07911   md_data_raw.push_back
07912     ( MdRecord
07913       ( NAME("Tensor7SetConstant"),
07914         DESCRIPTION
07915         (
07916          "Creates a workspace tensor7 and sets all elements of the \n"
07917          "tensor7 to the specified value. The size is determined by the \n"
07918          "variables *ncols*, *nrows*, *npages*, *nbooks*, *nshelves*, \n"
07919          "*nvitrines*, and *nlibraries*. \n"
07920          "\n"
07921          "Generic output: \n"
07922          "   Tensor7 : The tensor7 to be created. \n"
07923          "\n"
07924          "Keywords:\n"
07925          "   value      : The value of the tensor7 elements.\n"
07926         ),
07927         AUTHORS( "Claudia Emde" ),
07928         OUT(),
07929         GOUT(      "gout1"        ),
07930         GOUT_TYPE( "Tensor7" ),
07931         GOUT_DESC("FIXME DOC"),
07932         IN( "nlibraries", "nvitrines", "nshelves", "nbooks", "npages", "nrows",
07933                "ncols" ),
07934         GIN( "value" ),
07935         GIN_TYPE(    "Numeric" ),
07936         GIN_DEFAULT( NODEF ),
07937         GIN_DESC("FIXME DOC")
07938       ));
07939 
07940   md_data_raw.push_back
07941     ( MdRecord
07942       ( NAME("Test"),
07943         DESCRIPTION
07944         (
07945          "A dummy method that can be used for test purposes.\n"
07946          "\n"
07947          "This method can be used by ARTS developers to quickly test stuff.\n"
07948          "The implementation is in file m_general.cc. This just saves you the \n"
07949          "trouble of adding a dummy method everytime you want to try \n"
07950          "something out quickly.\n"
07951         ),
07952         AUTHORS( "Patrick Eriksson" ),
07953         OUT(),
07954         GOUT(),
07955         GOUT_TYPE(),
07956         GOUT_DESC(),
07957         IN(),
07958         GIN(),
07959         GIN_TYPE(),
07960         GIN_DEFAULT(),
07961         GIN_DESC()
07962       ));
07963 
07964   md_data_raw.push_back
07965     ( MdRecord
07966       ( NAME("timerStart"),
07967         DESCRIPTION
07968         (
07969          "Initializes the CPU timer."
07970          "\n"
07971          "Use *timerStop* to output the consumed cpu time\n"
07972          "since *timerStart*.\n"
07973          "\n"
07974          "Usage example:\n"
07975          "\n"
07976          "timerStart()\n"
07977          "ReadXML(f_grid){\"frequencies.xml\"}\n"
07978          "timerStop()\n"
07979          "Prints the CPU time spent for reading the XML file\n"
07980          ),
07981         AUTHORS( "Oliver Lemke" ),
07982         OUT( "timer" ),
07983         GOUT(),
07984         GOUT_TYPE(),
07985         GOUT_DESC(),
07986         IN(),
07987         GIN(),
07988         GIN_TYPE(),
07989         GIN_DEFAULT(),
07990         GIN_DESC()
07991       ));
07992 
07993 
07994   md_data_raw.push_back
07995     ( MdRecord
07996       ( NAME("timerStop"),
07997         DESCRIPTION
07998         (
07999          "Stops the CPU timer."
08000          "\n"
08001          "Use *timerStop* to output the consumed cpu time\n"
08002          "since *timerStart*. See *timerStart* for example\n"
08003          ),
08004         AUTHORS( "Oliver Lemke" ),
08005         OUT(),
08006         GOUT(),
08007         GOUT_TYPE(),
08008         GOUT_DESC(),
08009         IN( "timer" ),
08010         GIN(),
08011         GIN_TYPE(),
08012         GIN_DEFAULT(),
08013         GIN_DESC()
08014       ));
08015 
08016   md_data_raw.push_back
08017     ( MdRecord
08018       ( NAME("VectorAddScalar"),
08019         DESCRIPTION
08020         (
08021          "Adds a scalar to all elements of a vector. \n"
08022          "\n"
08023          "The result can either be stored in the same or another vector. \n"
08024          "\n"
08025          "Generic output: \n"
08026          "   Vector : Return vector. \n"
08027          "\n"
08028          "Generic input: \n"
08029          "   Vector : Original vector. \n"
08030          "\n"
08031          "Keywords:\n"
08032          "   value : The value to be added to the vector.\n"
08033         ),
08034         AUTHORS( "Patrick Eriksson" ),
08035         OUT(),
08036         GOUT(      "gout1"       ),
08037         GOUT_TYPE( "Vector" ),
08038         GOUT_DESC("FIXME DOC"),
08039         IN(),
08040         GIN(      "gin1"      ,
08041                   "value" ),
08042         GIN_TYPE(    "Vector",
08043                      "Numeric" ),
08044         GIN_DEFAULT( NODEF   ,
08045                   NODEF ),
08046         GIN_DESC("FIXME DOC",
08047                  "FIXME DOC")
08048       ));
08049 
08050   md_data_raw.push_back
08051     ( MdRecord
08052       ( NAME( "VectorCreate" ),
08053         DESCRIPTION
08054         (
08055          "Creates an empty Vector.\n"
08056          "\n"
08057          "If the variable already exists, it'll be reset.\n"
08058          "\n"
08059          "Generic output: \n"
08060          "   Vector: New empty Vector.\n"
08061         ),
08062         AUTHORS( "Oliver Lemke" ),
08063         OUT(),
08064         GOUT(      "gout1"       ),
08065         GOUT_TYPE( "Vector" ),
08066         GOUT_DESC("FIXME DOC"),
08067         IN(),
08068         GIN(),
08069         GIN_TYPE(),
08070         GIN_DEFAULT(),
08071         GIN_DESC()
08072       ));
08073 
08074   md_data_raw.push_back
08075     ( MdRecord
08076       ( NAME("VectorExtractFromMatrix"),
08077         DESCRIPTION
08078         (
08079          "Extract a Vector from a Matrix.\n"
08080          "\n"
08081          "Copies row or column with given Index from input Matrix variable\n"
08082          "to create output Vector.\n"
08083          "\n"
08084          "Keywords:\n"
08085          "   direction : Must be either *row* or *column*.\n"
08086         ),
08087         AUTHORS( "Patrick Eriksson, Oliver Lemke, Stefan Buehler" ),
08088         OUT(),
08089         GOUT(      "gout1"       ),
08090         GOUT_TYPE( "Vector" ),
08091         GOUT_DESC("FIXME DOC"),
08092         IN(),
08093         GIN(       "gin1"      , "gin2"     ,
08094                   "direction" ),
08095         GIN_TYPE(     "Matrix", "Index",
08096                      "String" ),
08097         GIN_DEFAULT(  NODEF   , NODEF  ,
08098                   NODEF ),
08099         GIN_DESC("FIXME DOC",
08100                  "FIXME DOC",
08101                  "FIXME DOC")
08102       ));
08103 
08104   md_data_raw.push_back
08105     ( MdRecord
08106       ( NAME("VectorInsertGridPoints"),
08107         DESCRIPTION
08108         (
08109          "Insert some additional points into a grid.\n"
08110          "\n"
08111          "This method can for example be used to add line center frequencies to\n"
08112          "a regular frequency grid. If the original grid is [1,2,3], and the\n"
08113          "additional points are [2.2,2.4], the result will be [1,2,2.2,2.4,3].\n"
08114          "\n"
08115          "It is assumed that the original grid is sorted, otherwise a runtime\n"
08116          "error is thrown. The vector with the points to insert does not have to\n"
08117          "be sorted. If some of the input points are already in the grid, these\n"
08118          "points are not inserted again. New points outside the original grid are\n"
08119          "appended at the appropriate end. Input vector and output vector can be\n"
08120          "the same.\n"
08121          "\n"
08122          "Generic output:\n"
08123          "  Vector : The new grid vector.\n"
08124          "\n"
08125          "Generic input:\n"
08126          "  Vector : The original grid vector.\n"
08127          "  Vector : The points to insert.\n"
08128          ),
08129         AUTHORS( "Stefan Buehler" ),
08130         OUT(),
08131         GOUT(      "gout1"       ),
08132         GOUT_TYPE( "Vector" ),
08133         GOUT_DESC("FIXME DOC"),
08134         IN(),
08135         GIN(       "gin1"      , "gin2"       ),
08136         GIN_TYPE(     "Vector", "Vector" ),
08137         GIN_DEFAULT(  NODEF   , NODEF    ),
08138         GIN_DESC("FIXME DOC",
08139                  "FIXME DOC")
08140       ));
08141 
08142   md_data_raw.push_back
08143     ( MdRecord
08144       ( NAME("VectorLinSpace"),
08145         DESCRIPTION
08146         (
08147          "Creates a vector with linear spacing.\n"
08148          "\n"
08149          "The first element equals always the start value, and the spacing\n"
08150          "equals always the step value, but the last value can deviate from\n"
08151          "the stop value. The keyword step can be both positive and\n"
08152          "negative.\n"
08153          "\n"
08154          "The vector is [start, start+step, start+2*step, ...]\n "
08155          "\n"
08156          "Generic output: \n"
08157          "   Vector : The vector to be created. \n"
08158          "\n"
08159          "Keywords:\n"
08160          "   start : The start value. \n"
08161          "    stop : The maximum value of the end value. \n"
08162          "    step : The spacing of the vector.\n"
08163         ),
08164         AUTHORS( "Patrick Eriksson" ),
08165         OUT(),
08166         GOUT(      "gout1"       ),
08167         GOUT_TYPE( "Vector" ),
08168         GOUT_DESC("FIXME DOC"),
08169         IN(),
08170         GIN( "start",   "stop",    "step"    ),
08171         GIN_TYPE(    "Numeric", "Numeric", "Numeric" ),
08172         GIN_DEFAULT( NODEF,     NODEF,     NODEF ),
08173         GIN_DESC("FIXME DOC",
08174                  "FIXME DOC",
08175                  "FIXME DOC")
08176       ));
08177 
08178   md_data_raw.push_back
08179     ( MdRecord
08180       ( NAME("VectorLogSpace"),
08181         DESCRIPTION
08182         (
08183          "Creates a vector with logarithmic spacing.\n"
08184          "\n"
08185          "The first element equals always the start value, and the spacing\n"
08186          "equals always the step value, but note that the last value can  \n"
08187          "deviate from the stop value. The keyword step can be both positive\n"
08188          "and negative.\n"
08189          "\n"
08190          "Note, that although start has to be given in direct coordinates,\n"
08191          "step has to be given in log coordinates.\n"
08192          "\n"
08193          "Explicitly, the vector is:\n"
08194          " exp([ln(start), ln(start)+step, ln(start)+2*step, ...])\n "
08195          "\n"
08196          "Generic output: \n"
08197          "   Vector : The vector to be created. \n"
08198          "\n"
08199          "Keywords:\n"
08200          "   start : The start value. (Direct coordinates!)\n"
08201          "    stop : The maximum value of the end value. (Direct coordinates!)\n"
08202          "    step : The spacing of the vector. (Log coordinates!)\n"
08203         ),
08204         AUTHORS( "Stefan Buehler" ),
08205         OUT(),
08206         GOUT(      "gout1"       ),
08207         GOUT_TYPE( "Vector" ),
08208         GOUT_DESC("FIXME DOC"),
08209         IN(),
08210         GIN( "start",   "stop",    "step"    ),
08211         GIN_TYPE(    "Numeric", "Numeric", "Numeric" ),
08212         GIN_DEFAULT( NODEF,     NODEF,     NODEF ),
08213         GIN_DESC("FIXME DOC",
08214                  "FIXME DOC",
08215                  "FIXME DOC")
08216       ));
08217 
08218   md_data_raw.push_back
08219     ( MdRecord
08220       ( NAME("VectorMatrixMultiply"),
08221         DESCRIPTION
08222         (
08223          "Multiply a Vector with a Matrix and store the result in another\n"
08224          "Vector.\n"
08225          "\n"
08226          "This just computes the normal Matrix-Vector product, y=M*x. It is ok\n"
08227          "if input and output Vector are the same. This function is handy for\n"
08228          "multiplying the H Matrix to spectra.\n"
08229          "\n"
08230          "Generic output:\n"
08231          "   Vector : The result of the multiplication (dimension m).\n"
08232          "\n"
08233          "Generic input:\n"
08234          "   Matrix : The Matrix to multiply (dimension mxn).\n"
08235          "   Vector : The original Vector (dimension n).\n"
08236         ),
08237         AUTHORS( "Stefan Buehler" ),
08238         OUT(),
08239         GOUT(      "gout1"       ),
08240         GOUT_TYPE( "Vector" ),
08241         GOUT_DESC("FIXME DOC"),
08242         IN(),
08243         GIN(       "gin1"      , "gin2"       ),
08244         GIN_TYPE(     "Matrix", "Vector" ),
08245         GIN_DEFAULT(  NODEF   , NODEF    ),
08246         GIN_DESC("FIXME DOC",
08247                  "FIXME DOC")
08248       ));
08249 
08250   md_data_raw.push_back
08251     ( MdRecord
08252       ( NAME("VectorNLinSpace"),
08253         DESCRIPTION
08254         (
08255          "Creates a vector with length *nelem*, equally spaced between the \n"
08256          "given end values. \n"
08257          "\n"
08258          "The length must be larger than 1. \n"
08259          "\n"
08260          "Generic output: \n"
08261          "   Vector : The vector to be created. \n"
08262          "\n"
08263          "Keywords:\n"
08264          "   start : The start value. \n"
08265          "    stop : The end value. \n"  
08266         ),
08267         AUTHORS( "Patrick Eriksson" ),
08268         OUT(),
08269         GOUT(     "gout1"      ),
08270         GOUT_TYPE("Vector"),
08271         GOUT_DESC("FIXME DOC"),
08272         IN( "nelem" ),
08273         GIN( "start",   "stop"    ),
08274         GIN_TYPE(    "Numeric", "Numeric" ),
08275         GIN_DEFAULT( NODEF,     NODEF     ),
08276         GIN_DESC("FIXME DOC",
08277                  "FIXME DOC")
08278       ));
08279 
08280   md_data_raw.push_back
08281     ( MdRecord
08282       ( NAME("VectorNLogSpace"),
08283         DESCRIPTION
08284         (
08285          "Creates a vector with length *nelem*, equally logarithmically \n"
08286          "spaced between the given end values. \n"
08287          "\n"
08288          "The length must be larger than 1. \n"
08289          "\n"
08290          "Generic output: \n"
08291          "   Vector : The vector to be created. \n"
08292          "\n"
08293          "Keywords:\n"
08294          "   start : The start value. \n"
08295          "    stop : The end value. \n"  
08296          "       n : Number of elements of the vector.\n" 
08297         ),
08298         AUTHORS( "Patrick Eriksson" ),
08299         OUT(),
08300         GOUT(     "gout1"      ),
08301         GOUT_TYPE("Vector"),
08302         GOUT_DESC("FIXME DOC"),
08303         IN( "nelem" ),
08304         GIN( "start",   "stop"    ),
08305         GIN_TYPE(    "Numeric", "Numeric" ),
08306         GIN_DEFAULT( NODEF,     NODEF     ),
08307         GIN_DESC("FIXME DOC",
08308                  "FIXME DOC")
08309       ));
08310 
08311   md_data_raw.push_back
08312     ( MdRecord
08313       ( NAME("VectorScale"),
08314         DESCRIPTION
08315         (
08316          "Scales all elements of a vector with the same value. \n"
08317          "\n"
08318          "The result can either be stored in the same or another vector. \n"
08319          "\n"
08320          "Generic output: \n"
08321          "   Vector : Return vector. \n"
08322          "\n"
08323          "Generic input: \n"
08324          "   Vector : Original vector. \n"
08325          "\n"
08326          "Keywords:\n"
08327          "   value : The value to be multiplicated with the vector.\n"
08328         ),
08329         AUTHORS( "Patrick Eriksson" ),
08330         OUT(),
08331         GOUT(      "gout1"       ),
08332         GOUT_TYPE( "Vector" ),
08333         GOUT_DESC("FIXME DOC"),
08334         IN(),
08335         GIN(      "gin1"      ,
08336                   "value" ),
08337         GIN_TYPE(    "Vector",
08338                      "Numeric" ),
08339         GIN_DEFAULT( NODEF   ,
08340                   NODEF ),
08341         GIN_DESC("FIXME DOC",
08342                  "FIXME DOC")
08343       ));
08344 
08345   md_data_raw.push_back
08346     ( MdRecord
08347       ( NAME("VectorSetConstant"),
08348         DESCRIPTION
08349         (
08350          "Creates a workspace vector and sets all elements of the \n"
08351          "vector to the specified value. The length of the vector is \n"
08352          "determined by the variable *nelem*. \n"
08353          "\n"
08354          "Generic output: \n"
08355          "   Vector : The vector to be created. \n"
08356          "\n"
08357          "Keywords:\n"
08358          "   value  : The value of the vector elements.\n" 
08359         ),
08360         AUTHORS( "Patrick Eriksson" ),
08361         OUT(),
08362         GOUT(      "gout1"       ),
08363         GOUT_TYPE( "Vector" ),
08364         GOUT_DESC("FIXME DOC"),
08365         IN( "nelem" ),
08366         GIN( "value"   ),
08367         GIN_TYPE(    "Numeric" ),
08368         GIN_DEFAULT( NODEF ),
08369         GIN_DESC("FIXME DOC")
08370       ));
08371 
08372   md_data_raw.push_back
08373     ( MdRecord
08374       ( NAME("VectorSet"),
08375         DESCRIPTION
08376         (
08377          "Create a vector from the given list of numbers.\n"
08378          "\n"
08379          "Generic output:\n"
08380          "   Vector : The vector to be created.\n"
08381          "\n"
08382          "Keywords:\n"
08383          "   values  : The vector elements.\n"
08384          "\n"
08385          "Usage:\n"
08386          "   VectorSet(p_grid){[1000, 100, 10]}\n"
08387          "   Will create a p_grid vector with these three elements.\n"
08388         ),
08389         AUTHORS( "Stefan Buehler" ),
08390         OUT(),
08391         GOUT(      "gout1"       ),
08392         GOUT_TYPE( "Vector" ),
08393         GOUT_DESC("FIXME DOC"),
08394         IN(),
08395         GIN( "values"   ),
08396         GIN_TYPE(    "Vector" ),
08397         GIN_DEFAULT( NODEF ),
08398         GIN_DESC("FIXME DOC"),
08399         SETMETHOD( true )
08400       ));
08401 
08402   md_data_raw.push_back
08403     ( MdRecord
08404       ( NAME( "VectorZtanToZaRefr1D" ),
08405         DESCRIPTION
08406         (
08407          "Converts a set of true tangent altitudes to zenith angles.\n"
08408          "\n"
08409          "The tangent altitudes are given to the function as a vector, which\n"
08410          "are converted to a generic vector of zenith angles. The position of\n"
08411          "the sensor is given by the WSV *sensor_pos*. The function works\n"
08412          "only for 1D. The zenith angles are always set to be positive.\n"
08413          "The tangent altitudes are given as the altitude above the geoid.\n"
08414          "\n"
08415          "Generic output: \n"
08416          "   Vector : A vector with zenith angles. \n"
08417          "\n"
08418          "Generic input: \n"
08419          "   Vector : A vector with true tangent altitudes\n"
08420         ),
08421         AUTHORS( "Patrick Eriksson", "Mattias Ekstrom" ),
08422         OUT( "refr_index", "rte_pressure", "rte_temperature", "rte_vmr_list" ),
08423         GOUT(      "gout1"       ),
08424         GOUT_TYPE( "Vector" ),
08425         GOUT_DESC("FIXME DOC"),
08426         IN( "refr_index_agenda", "sensor_pos", "p_grid", "t_field", "z_field",
08427                            "vmr_field", "r_geoid", "atmosphere_dim" ),
08428         GIN(      "gin1"       ),
08429         GIN_TYPE(    "Vector" ),
08430         GIN_DEFAULT( NODEF    ),
08431         GIN_DESC("FIXME DOC")
08432       ));
08433 
08434   md_data_raw.push_back
08435     ( MdRecord
08436       ( NAME( "VectorZtanToZa1D" ),
08437         DESCRIPTION
08438         (
08439          "Converts a set of geometrical tangent altitudes to zenith angles.\n"
08440          "\n"
08441          "The tangent altitudes are given to the function as a vector, which\n"
08442          "are converted to a generic vector of zenith angles. The position of\n"
08443          "the sensor is given by the WSV *sensor_pos*. The function works\n"
08444          "only for 1D, where the geoid radius is taken from *r_geoid*. The\n"
08445          "zenith angles are always set to be positive. The tangent altitudes\n"
08446          "are given as the altitude above the geoid.\n"
08447          "\n"
08448          "Generic output: \n"
08449          "   Vector : A vector with zenith angles. \n"
08450          "\n"
08451          "Generic input: \n"
08452          "   Vector : A vector with geometric tangent altitudes\n"
08453         ),
08454         AUTHORS( "Patrick Eriksson", "Mattias Ekstrom" ),
08455         OUT(),
08456         GOUT(      "gout1"       ),
08457         GOUT_TYPE( "Vector" ),
08458         GOUT_DESC("FIXME DOC"),
08459         IN( "sensor_pos", "r_geoid", "atmosphere_dim" ),
08460         GIN(      "gin1"       ),
08461         GIN_TYPE(    "Vector" ),
08462         GIN_DEFAULT( NODEF    ),
08463         GIN_DESC("FIXME DOC")
08464       ));
08465 
08466   md_data_raw.push_back
08467     ( MdRecord
08468       ( NAME("WriteNetCDF"),
08469         DESCRIPTION
08470         (
08471          "Writes a workspace variable to a NetCDF file.\n"
08472          "\n"
08473          "This is a supergeneric method. It can write variables of any group.\n"
08474          "\n"
08475          "If the filename is omitted, the variable is written\n"
08476          "to <basename>.<variable_name>.nc.\n"
08477          ),
08478         AUTHORS( "Oliver Lemke" ),
08479         OUT(),
08480         GOUT(),
08481         GOUT_TYPE(),
08482         GOUT_DESC(),
08483         IN(),
08484         GIN(      "",
08485                   "filename" ),
08486         GIN_TYPE( "Vector, Matrix, Tensor3, Tensor4, ArrayOfVector, ArrayOfMatrix",
08487                   "String" ),
08488         GIN_DEFAULT(  NODEF, "" ),
08489         GIN_DESC("Variable to be saved.", "Name of the NetCDF file."),
08490         SETMETHOD(      false ),
08491         AGENDAMETHOD(   false ),
08492         SUPPRESSHEADER( true  ),
08493         PASSWORKSPACE(  false ),
08494         PASSWSVNAMES(   true  )
08495       ));
08496 
08497   md_data_raw.push_back
08498     ( MdRecord
08499       ( NAME("WriteXML"),
08500         DESCRIPTION
08501         (
08502          "Writes a workspace variable to an XML file.\n"
08503          "\n"
08504          "This is a supergeneric method. It can write variables of any group.\n"
08505          "\n"
08506          "If the filename is omitted, the variable is written\n"
08507          "to <basename>.<variable_name>.xml.\n"
08508          ),
08509         AUTHORS( "Oliver Lemke" ),
08510         OUT(),
08511         GOUT(),
08512         GOUT_TYPE(),
08513         GOUT_DESC(),
08514         IN( "output_file_format" ),
08515         GIN(       "gin1"   ,
08516                   "filename" ),
08517         GIN_TYPE(     "Any",
08518                      "String"   ),
08519         GIN_DEFAULT(  NODEF,
08520                   "" ),
08521         GIN_DESC("Variable to be saved.", "Name of the XML file."),
08522         SETMETHOD(      false ),
08523         AGENDAMETHOD(   false ),
08524         SUPPRESSHEADER( true  ),
08525         PASSWORKSPACE(  false ),
08526         PASSWSVNAMES(   true  )
08527       ));
08528 
08529   md_data_raw.push_back
08530     ( MdRecord
08531       ( NAME("WriteXMLIndexed"),
08532         DESCRIPTION
08533         (
08534          "As *WriteXML*, but creates indexed file names.\n"
08535          "\n"
08536          "The variable is written to a file with name:\n"
08537          "   <filename>.<file_index>.xml.\n"
08538          "where <file_index> is the value of *file_index*. This:\n"
08539          "  IndexSet(file_index){0} \n"
08540          "  IndexStep(file_index){} \n"
08541          "  WriteXML(ppath){\"ppath\"}\n"
08542          "will create the file ppath.1.xml.\n"
08543          "\n"
08544          "This means that *filename* shall here not include the .xml\n"
08545          "extension. Omitting filename works as for *WriteXML*.\n"
08546          ),
08547         AUTHORS( "Patrick Eriksson" ),
08548         OUT(),
08549         GOUT(),
08550         GOUT_TYPE(),
08551         GOUT_DESC(),
08552         IN( "output_file_format", "file_index" ),
08553         GIN(       "gin1"   ,
08554                   "filename" ),
08555         GIN_TYPE(     "Any",
08556                      "String"   ),
08557         GIN_DEFAULT(  NODEF,
08558                   "" ),
08559         GIN_DESC("FIXME DOC",
08560                  "FIXME DOC"),
08561         SETMETHOD(      false ),
08562         AGENDAMETHOD(   false ),
08563         SUPPRESSHEADER( true  ),
08564         PASSWORKSPACE(  false ),
08565         PASSWSVNAMES(   true  )
08566       ));
08567 
08568   md_data_raw.push_back
08569     ( MdRecord
08570       ( NAME( "ybatchCalc" ),
08571         DESCRIPTION
08572         (
08573          "Performs batch calculations.\n"
08574          "\n"
08575          "The method performs the following:\n"
08576          "   1. Sets *ybatch_index* = 0.\n"
08577          "   2. Performs a-d until *ybatch_index* = *ybatch_n*.\n"
08578          "    a. Executes *ybatch_calc_agenda*.\n"
08579          "    b. If *ybatch_index* = 0, resizes *ybatch* based\n"
08580          "       on *ybatch_n* and length of *y*.\n"
08581          "    c. Copies *y* to column *ybatch_index* of *ybatch*.\n"
08582          "    d. Adds 1 to *ybatch_index*.\n"
08583          "\n"
08584          "This means that, beside the *ybatch_calc_agenda*, the WSV\n"
08585          "*ybatch_n* must be set before calling this method. Further,\n"
08586          "*ybatch_calc_agenda* is expected to produce a spectrum and should\n"
08587          "accordingly include a call of *RteCalc* (or a similar method). \n"
08588          "\n"
08589          "An agenda that calculates spectra for different temperature profiles\n"
08590          "could look like this:\n"
08591          "\n"
08592          "   AgendaSet(ybatch_calc_agenda){\n"
08593          "      Extract(t_field,tensor4_1,ybatch_index){}\n"
08594          "      RteCalc{}\n"
08595          "   }\n"
08596          "\n"
08597          "See the user guide for further practical examples.\n"
08598          "\n"
08599          "Keywords:\n"
08600          "   robust : a flag with value 1 or 0. If set to one, the batch\n"
08601          "            calculation will continue, even if individual jobs\n"
08602          "            fail. In that case, a warning message is written to \n"
08603          "            screen and file (out1 output stream), and ybatch for the\n"
08604          "            failed job is set to -1. The robust behavior does only work\n"
08605          "            properly if you have compiled the program without OpenMP!\n"
08606          "            (Use the configure option \"--disable-vectorize\".)\n"
08607          ),
08608         AUTHORS( "Patrick Eriksson, Stefan Buehler" ),
08609         OUT( "ybatch" ),
08610         GOUT(),
08611         GOUT_TYPE(),
08612         GOUT_DESC(),
08613         IN( "ybatch_n", "ybatch_calc_agenda" ), 
08614         GIN( "robust" ),
08615         GIN_TYPE(    "Index" ),
08616         GIN_DEFAULT( "0" ),
08617         GIN_DESC("FIXME DOC")
08618       ));
08619 
08620   md_data_raw.push_back
08621     ( MdRecord
08622       ( NAME( "ybatchMetProfiles" ),
08623         DESCRIPTION
08624         (
08625          "This method is used for simulating ARTS for metoffice model fields"
08626          "\n"
08627          "This method reads in *met_amsu_data* which contains the\n"
08628          "lat-lon of the metoffice profile files as a Matrix. It then \n"
08629          "loops over the number of profiles and corresponding to each \n"
08630          "longitude create the appropriate profile basename. Then, \n"
08631          "Corresponding to each basename we have temperature field, altitude\n"
08632          "field, humidity field and particle number density field.  The\n"
08633          "temperature field and altitude field are stored in the same dimensions\n"
08634          "as *t_field_raw* and *z_field_raw*.  The oxygen and nitrogen VMRs are\n"
08635          "set to constant values of 0.209 and 0.782, respectively and are used\n"
08636          "along with humidity field to generate *vmr_field_raw*.  \n"
08637          "\n"
08638          "The three fields *t_field_raw*, *z_field_raw*, and *vmr_field_raw* are\n"
08639          "given as input to *met_profile_calc_agenda* which is called in this\n"
08640          "method.  See documentation of WSM *met_profile_calc_agenda* for more\n"
08641          "information on this agenda.  \n"
08642          "\n"
08643          "The method also converts satellite zenith angle to appropriate \n"
08644          "*sensor_los*.  It also sets the *p_grid* and *cloudbox_limits* \n"
08645          "from the profiles inside the function\n"
08646          ),
08647         AUTHORS( "Sreerekha T.R." ),
08648         OUT( "ybatch" ),
08649         GOUT(),
08650         GOUT_TYPE(),
08651         GOUT_DESC(),
08652         IN( "abs_species", "met_profile_calc_agenda", "f_grid", "met_amsu_data",
08653                "sensor_pos", "r_geoid", "lat_grid", "lon_grid", "atmosphere_dim",
08654                "scat_data_raw" ),
08655         GIN( "nelem_p_grid", "met_profile_path", "met_profile_pnd_path" ),
08656         GIN_TYPE(    "Index",        "String",           "String" ),
08657         GIN_DEFAULT( NODEF,          NODEF,              NODEF ),
08658         GIN_DESC("FIXME DOC",
08659                  "FIXME DOC",
08660                  "FIXME DOC")
08661       ));
08662 
08663   md_data_raw.push_back
08664     ( MdRecord
08665       ( NAME( "ybatchMetProfilesClear" ),
08666         DESCRIPTION
08667         (
08668          "This method is used for simulating ARTS for metoffice model fields\n"
08669          "for clear sky conditions.\n"
08670          "\n"
08671          "This method reads in *met_amsu_data* which contains the\n"
08672          "lat-lon of the metoffice profile files as a Matrix. It then \n"
08673          "loops over the number of profiles and corresponding to each \n"
08674          "longitude create the appropriate profile basename. Then, \n"
08675          "Corresponding to each basename we have temperature field, altitude\n"
08676          "field, humidity field and particle number density field.  The\n"
08677          "temperature field and altitude field are stored in the same dimensions\n"
08678          "as *t_field_raw* and *z_field_raw*.  The oxygen and nitrogen VMRs are\n"
08679          "set to constant values of 0.209 and 0.782, respectively and are used\n"
08680          "along with humidity field to generate *vmr_field_raw*.  \n"
08681          "\n"
08682          "The three fields *t_field_raw*, *z_field_raw*, and *vmr_field_raw* are\n"
08683          "given as input to *met_profile_calc_agenda* which is called in this\n"
08684          "method.  See documentation of WSM *met_profile_calc_agenda* for more\n"
08685          "information on this agenda.  \n"
08686          "\n"
08687          "The method also converts satellite zenith angle to appropriate \n"
08688          "*sensor_los*.  It also sets the *p_grid* and *cloudbox_limits* \n"
08689          "from the profiles inside the function\n"
08690          ),
08691         AUTHORS( "Seerekha T.R." ),
08692         OUT( "ybatch" ),
08693         GOUT(),
08694         GOUT_TYPE(),
08695         GOUT_DESC(),
08696         IN( "abs_species", "met_profile_calc_agenda", 
08697                "f_grid", "met_amsu_data", "sensor_pos", "r_geoid" ),
08698         GIN( "nelem_p_grid", "met_profile_path" ),
08699         GIN_TYPE(    "Index",        "String"),
08700         GIN_DEFAULT( NODEF,          NODEF ),
08701         GIN_DESC("FIXME DOC",
08702                  "FIXME DOC")
08703       ));
08704 
08705   md_data_raw.push_back
08706     ( MdRecord
08707       ( NAME( "ybatchUnit" ),
08708         DESCRIPTION
08709         (
08710          "Conversion of *ybatch* to other spectral units.\n"
08711          "\n"
08712          "As *yUnit* but operates on *ybatch*.\n"
08713         ),
08714         AUTHORS( "Patrick Eriksson" ),
08715         OUT( "ybatch" ),
08716         GOUT(),
08717         GOUT_TYPE(),
08718         GOUT_DESC(),
08719         IN( "ybatch", "y_unit", "y_f" ),
08720         GIN(),
08721         GIN_TYPE(),
08722         GIN_DEFAULT(),
08723         GIN_DESC()
08724       ));
08725 
08726   md_data_raw.push_back
08727     ( MdRecord
08728       ( NAME( "yUnit" ),
08729         DESCRIPTION
08730         (
08731          "Conversion of *y* to other spectral units.\n"
08732          "\n"
08733          "The conversion specified by *y_unit* is applied. This function can\n"
08734          "be used if the standard way of making the conversion inside the\n"
08735          "radiative transfer function does not work. The WSV *y_unit* should\n"
08736          "then be set to \"1\" when performing the radiative transfer\n" 
08737          "calculations, and be changed before calling this method.\n"
08738         ),
08739         AUTHORS( "Patrick Eriksson" ),
08740         OUT( "y" ),
08741         GOUT(),
08742         GOUT_TYPE(),
08743         GOUT_DESC(),
08744         IN( "y", "y_unit", "y_f" ),
08745         GIN(),
08746         GIN_TYPE(),
08747         GIN_DEFAULT(),
08748         GIN_DESC()
08749       ));
08750 
08751   md_data_raw.push_back
08752     ( MdRecord
08753       ( NAME( "ZaSatOccultation" ),
08754         DESCRIPTION
08755         (
08756          "Calculates zenith angles for satellite occultations.\n"
08757          "\n"
08758          "The zenith angles are calculated with an interval of *t_sample\n"
08759          "with the recieving satellite at height *z_recieve* above the geoid\n"
08760          "and the transmitting satellite at height *z_send*.\n"
08761          "The zenith angles are restricted by the two tangent altitudes\n"
08762          "*z_scan_low* and *z_scan_high*.\n"
08763         ),
08764         AUTHORS( "Mattias Ekstrom" ),
08765         OUT(),
08766         GOUT(      "gout1"       ),
08767         GOUT_TYPE( "Vector" ),
08768         GOUT_DESC("FIXME DOC"),
08769         IN( "ppath_step_agenda", "atmosphere_dim", "p_grid", "lat_grid",
08770                "lon_grid", "z_field", "r_geoid", "z_surface" ),
08771         GIN( "z_recieve", "z_send",  "t_sample", 
08772                   "z_scan_low", "z_scan_high" ),
08773         GIN_TYPE(    "Numeric",   "Numeric", "Numeric",
08774                   "Numeric",    "Numeric" ),
08775         GIN_DEFAULT( NODEF,       NODEF,     NODEF,
08776                   NODEF,        NODEF ),
08777         GIN_DESC("FIXME DOC",
08778                  "FIXME DOC",
08779                  "FIXME DOC",
08780                  "FIXME DOC",
08781                  "FIXME DOC")
08782       ));
08783 
08784 
08785 }
08786