ARTS 2.5.9 (git: 825fa5f2)
make_auto_md_h.cc
Go to the documentation of this file.
1/* Copyright (C) 2000-2012 Stefan Buehler <sbuehler@ltu.se>
2
3 This program is free software; you can redistribute it and/or modify it
4 under the terms of the GNU General Public License as published by the
5 Free Software Foundation; either version 2, or (at your option) any
6 later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12
13 You should have received a copy of the GNU General Public License
14 along with this program; if not, write to the Free Software
15 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
16 USA. */
17
68#include "agenda_record.h"
69#include "array.h"
70#include "arts.h"
71#include "debug.h"
72#include "file.h"
73#include "global_data.h"
74#include "methods.h"
75#include "workspace.h"
77#include "workspace_ng.h"
78#include <stdexcept>
79
80/* Adds commas and indentation to parameter lists. */
81void align(ofstream& ofs, bool& is_first_parameter, const String& indent) {
82 // Add comma and line break, if not first element:
83 if (is_first_parameter)
84 is_first_parameter = false;
85 else {
86 ofs << ",\n";
87 // Make proper indentation:
88 ofs << indent;
89 }
90}
91
93
97void write_method_header_documentation(ofstream& ofs, const MdRecord& mdd) {
99
100 const String& fullname = mdd.Name();
101
102 // This is needed to flag the first function parameter, which
103 // needs no line break before being written:
104 bool is_first_parameter = true;
105
106 // The String indent is needed to achieve the correct
107 // indentation of the functin parameters:
108 String indent(" ");
109
110 // Flag to pass the workspace to the WSM. Only true if the WSM has
111 // an Agenda as input.
112 bool pass_workspace = false;
113
114 // There are four lists of parameters that we have to
115 // write.
116 ArrayOfIndex vo = mdd.Out(); // Output
117 const ArrayOfIndex& vi = mdd.InOnly(); // Input
118 const ArrayOfIndex& vgo = mdd.GOutType(); // Generic Output
119 const ArrayOfIndex& vgi = mdd.GInType(); // Generic Input
120 // vo and vi contain handles of workspace variables,
121 // vgo and vgi handles of workspace variable groups.
122
123 // Find out if the WSM gets an agenda as input. If so, pass
124 // the current workspace to this method
125 for (Index j = 0; !pass_workspace && j < mdd.In().nelem(); j++) {
126 if (is_agenda_group_id(wsv_data[mdd.In()[j]].Group())) {
127 pass_workspace = true;
128 }
129 }
130
131 // Find out if the WSM gets an agenda as input. If so, pass
132 // the current workspace to this method
133 for (Index j = 0; !pass_workspace && j < mdd.GInType().nelem(); j++) {
134 if (is_agenda_group_id(mdd.GInType()[j])) {
135 pass_workspace = true;
136 }
137 }
138
139 // Start with the name of the one line description
140 ofs << "//! WORKSPACE METHOD: " << fullname << ".\n";
141
142 ofs << "/*!\n";
143
144 String DoxyDescription = mdd.Description();
145 size_t start_pos = 0;
146
147 while (start_pos != string::npos) {
148 start_pos = DoxyDescription.find("\n ", start_pos);
149 if (start_pos && start_pos != string::npos &&
150 DoxyDescription[start_pos] - 1 != '\n') {
151 DoxyDescription.insert(start_pos + 1, "<br>");
152 start_pos += 5;
153 }
154 }
155
156 // Some characters have to be masqueraded to appear properly in doxygen
157 // documentation
158 DoxyDescription.insert_substr("<", "\\");
159 DoxyDescription.insert_substr(">", "\\");
160
161 ofs << DoxyDescription << "\n";
162
163 // Write the authors:
164 for (Index j = 0; j < mdd.Authors().nelem(); ++j) {
165 ofs << indent << "\\author " << mdd.Authors()[j] << "\n";
166 }
167
168 ofs << "\n";
169
170 if (pass_workspace || mdd.PassWorkspace() || mdd.AgendaMethod()) {
171 ofs << indent << "\\param[in,out] "
172 << "ws Workspace\n";
173 }
174
175 // Write the Output workspace variables:
176 for (Index j = 0; j < vo.nelem(); ++j) {
177 bool inout =
178 (std::find(mdd.In().begin(), mdd.In().end(), vo[j]) != mdd.In().end());
179
180 if (inout) {
181 ofs << indent << "\\param[in,out] " << wsv_data[vo[j]].Name()
182 << " WS Input/Output\n";
183 } else {
184 ofs << indent << "\\param[out] " << wsv_data[vo[j]].Name()
185 << " WS Output\n";
186 }
187 }
188
189 // Write the Generic output workspace variables:
190 for (Index j = 0; j < vgo.nelem(); ++j) {
191 ofs << indent << "\\param[out] ";
192
193 if (mdd.GOut()[j].length())
194 ofs << mdd.GOut()[j];
195 else
196 ofs << "genericoutput" << j + 1;
197
198 if (mdd.Supergeneric())
199 ofs << " Supergeneric output\n";
200 else
201 ofs << " Generic output\n";
202 }
203
204 // Write the Generic output workspace variable names:
205 if (mdd.PassWsvNames()) {
206 for (Index j = 0; j < vgo.nelem(); ++j) {
207 ofs << indent << "\\param[in] ";
208 if (mdd.GOut()[j].length())
209 ofs << mdd.GOut()[j] << "_wsvname";
210 else
211 ofs << "genericoutput" << j + 1 << "_wsvname";
212
213 ofs << " Generic Output Name" << endl;
214 }
215 }
216
217 // Write the Input workspace variables:
218 for (Index j = 0; j < vi.nelem(); ++j) {
219 ofs << indent << "\\param[in] " << wsv_data[vi[j]].Name()
220 << " WS Input\n";
221 }
222
223 // Write the Generic input workspace variables:
224 for (Index j = 0; j < vgi.nelem(); ++j) {
225 ofs << indent << "\\param[in] ";
226 if (mdd.GIn()[j] != "")
227 ofs << mdd.GIn()[j];
228 else
229 ofs << "genericinput" << j + 1;
230
231 ofs << " Generic Input";
232
233 if (mdd.GInDefault()[j] != NODEF) {
234 ofs << " (Default: \"" << mdd.GInDefault()[j] << "\")";
235 }
236 ofs << endl;
237 }
238
239 // Write the Generic input workspace variable names:
240 if (mdd.PassWsvNames()) {
241 for (Index j = 0; j < vgi.nelem(); ++j) {
242 ofs << indent << "\\param[in] ";
243 if (mdd.GIn()[j].length())
244 ofs << mdd.GIn()[j] << "_wsvname";
245 else
246 ofs << "genericinput" << j + 1 << "_wsvname";
247
248 ofs << " Generic Input Name" << endl;
249 }
250 }
251
252 // Write agenda, if there is one:
253 if (mdd.AgendaMethod()) {
254 align(ofs, is_first_parameter, indent);
255 ofs << indent << "\\param[in] "
256 << "input_agenda Agenda from controlfile\n";
257 }
258
259 ofs << "*/\n";
260}
261
263
267void write_method_header(ofstream& ofs, const MdRecord& mdd) {
269 const Array<WsvRecord>& wsv_data = global_data::wsv_data;
270
271 // // Work out the full name to use:
272 // String fullname;
273 // {
274 // ostringstream os;
275 // os << mdd.Name() << add_to_name;
276 // fullname = os.str();
277 // }
278
279 const String& fullname = mdd.Name();
280
281 // This is needed to flag the first function parameter, which
282 // needs no line break before being written:
283 bool is_first_parameter = true;
284
285 // The String indent is needed to achieve the correct
286 // indentation of the functin parameters:
287 String indent(fullname.nelem() + 6, ' ');
288
289 // Flag to pass the workspace to the WSM. Only true if the WSM has
290 // an Agenda as input.
291 bool pass_workspace = false;
292
293 // There are four lists of parameters that we have to
294 // write.
295 ArrayOfIndex vo = mdd.Out(); // Output
296 const ArrayOfIndex& vi = mdd.InOnly(); // Input
297 const ArrayOfIndex& vgo = mdd.GOutType(); // Generic Output
298 const ArrayOfIndex& vgi = mdd.GInType(); // Generic Input
299 // vo and vi contain handles of workspace variables,
300 // vgo and vgi handles of workspace variable groups.
301
302 // Find out if the WSM gets an agenda as input. If so, pass
303 // the current workspace to this method
304 for (Index j = 0; !pass_workspace && j < mdd.In().nelem(); j++) {
305 if (is_agenda_group_id(wsv_data[mdd.In()[j]].Group())) {
306 pass_workspace = true;
307 }
308 }
309
310 // Find out if the WSM gets an agenda as input. If so, pass
311 // the current workspace to this method
312 for (Index j = 0; !pass_workspace && j < mdd.GInType().nelem(); j++) {
313 if (is_agenda_group_id(mdd.GInType()[j])) {
314 pass_workspace = true;
315 }
316 }
317
318 // There used to be a similar block here for the generic
319 // input/output variables. However, this was a mistake. For
320 // example, if a method has a vector as generic input and a
321 // vector as generic output, this does not mean that it is
322 // the same vector!
323
324 if (mdd.Supergeneric() && mdd.UsesTemplates()) {
325 ofs << "template <typename T>" << endl;
326 }
327
328 // Start with the name of the method:
329 ofs << "void " << fullname << "(";
330
331 if (pass_workspace || mdd.PassWorkspace() || mdd.AgendaMethod()) {
332 ofs << "// Workspace reference:\n";
333 ofs << indent << "Workspace& ws";
334 is_first_parameter = false;
335 }
336
337 // Write the Output workspace variables:
338 {
339 // Flag first parameter of this sort:
340 bool is_first_of_these = true;
341
342 for (Index j = 0; j < vo.nelem(); ++j) {
343 // Add comma and line break, if not first element:
344 align(ofs, is_first_parameter, indent);
345
346 // Add comment if this is the first of this sort
347 if (is_first_of_these) {
348 ofs << "// WS Output:\n";
349 ofs << indent;
350 is_first_of_these = false;
351 }
352
353 ofs << wsv_groups[global_data::wsv_data[vo[j]].Group()] << "& "
354 << global_data::wsv_data[vo[j]].Name();
355 }
356 }
357
358 // Write the Generic output workspace variables:
359 {
360 // Flag first parameter of this sort:
361 bool is_first_of_these = true;
362
363 for (Index j = 0; j < vgo.nelem(); ++j) {
364 // Add comma and line break, if not first element:
365 align(ofs, is_first_parameter, indent);
366
367 // Add comment if this is the first of this sort
368 if (is_first_of_these) {
369 ofs << "// WS Generic Output:\n";
370 ofs << indent;
371 is_first_of_these = false;
372 }
373
374 if (wsv_groups[mdd.GOutType()[j]] == "Any")
375 ofs << "T& ";
376 else
377 ofs << wsv_groups[mdd.GOutType()[j]] << "& ";
378
379 if (mdd.GOut()[j].length())
380 ofs << mdd.GOut()[j];
381 else
382 ofs << "genericoutput" << j + 1;
383 }
384 }
385
386 // Write the Generic output workspace variable names:
387 if (mdd.PassWsvNames()) {
388 // Flag first parameter of this sort:
389 bool is_first_of_these = true;
390
391 for (Index j = 0; j < vgo.nelem(); ++j) {
392 // Add comma and line break, if not first element:
393 align(ofs, is_first_parameter, indent);
394
395 // Add comment if this is the first of this sort
396 if (is_first_of_these) {
397 ofs << "// WS Generic Output Names:\n";
398 ofs << indent;
399 is_first_of_these = false;
400 }
401
402 ofs << "const String& ";
403 if (mdd.GOut()[j].length())
404 ofs << mdd.GOut()[j] << "_wsvname";
405 else
406 ofs << "genericoutput" << j + 1 << "_wsvname";
407 }
408 }
409
410 // Write the Input workspace variables:
411 {
412 // Flag first parameter of this sort.
413 bool is_first_of_these = true;
414
415 for (Index j = 0; j < vi.nelem(); ++j) {
416 // Add comma and line break, if not first element:
417 align(ofs, is_first_parameter, indent);
418
419 // Add type if this is the first of this sort.
420 if (is_first_of_these) {
421 ofs << "// WS Input:\n";
422 ofs << indent;
423 is_first_of_these = false;
424 }
425
426 ofs << "const " << wsv_groups[global_data::wsv_data[vi[j]].Group()]
427 << "& " << global_data::wsv_data[vi[j]].Name();
428 }
429 }
430
431 // Write the Generic input workspace variables:
432 {
433 // Flag first parameter of this sort.
434 bool is_first_of_these = true;
435
436 for (Index j = 0; j < vgi.nelem(); ++j) {
437 // Add comma and line break, if not first element:
438 align(ofs, is_first_parameter, indent);
439
440 // Add type if this is the first of this sort.
441 if (is_first_of_these) {
442 ofs << "// WS Generic Input:\n";
443 ofs << indent;
444 is_first_of_these = false;
445 }
446
447 if (wsv_groups[mdd.GInType()[j]] == "Any") {
448 ofs << "const T& ";
449 if (mdd.GIn()[j].length())
450 ofs << mdd.GIn()[j];
451 else
452 ofs << "genericinput" << j + 1;
453 } else {
454 ofs << "const " << wsv_groups[mdd.GInType()[j]] << "& ";
455 if (mdd.GIn()[j].length())
456 ofs << mdd.GIn()[j];
457 else
458 ofs << "genericinput" << j + 1;
459 }
460 }
461 }
462
463 // Write the Generic input workspace variable names:
464 if (mdd.PassWsvNames()) {
465 // Flag first parameter of this sort:
466 bool is_first_of_these = true;
467
468 for (Index j = 0; j < vgi.nelem(); ++j) {
469 // Add comma and line break, if not first element:
470 align(ofs, is_first_parameter, indent);
471
472 // Add comment if this is the first of this sort
473 if (is_first_of_these) {
474 ofs << "// WS Generic Input Names:\n";
475 ofs << indent;
476 is_first_of_these = false;
477 }
478
479 ofs << "const String& ";
480 if (mdd.GIn()[j].length())
481 ofs << mdd.GIn()[j] << "_wsvname";
482 else
483 ofs << "genericinput" << j + 1 << "_wsvname";
484 }
485 }
486
487 // Write agenda, if there is one:
488 if (mdd.AgendaMethod()) {
489 align(ofs, is_first_parameter, indent);
490 ofs << "// Agenda from controlfile:\n";
491 ofs << indent;
492 ofs << "const Agenda& input_agenda";
493 }
494
495 // Flag that is set to false if the WSM has verbosity as an input or
496 // output already. Otherwise it's passed as the last parameter.
497 bool pass_verbosity = true;
498
499 // Find out if the WSM has the verbosity as input.
500 for (Index j = 0; pass_verbosity && j < mdd.In().nelem(); j++) {
501 if (wsv_data[mdd.In()[j]].Name() == "verbosity") {
502 pass_verbosity = false;
503 }
504 }
505
506 // Find out if the WSM has the verbosity as output.
507 for (Index j = 0; pass_verbosity && j < mdd.Out().nelem(); j++) {
508 if (wsv_data[mdd.Out()[j]].Name() == "verbosity") {
509 pass_verbosity = false;
510 }
511 }
512
513 if (pass_verbosity) {
514 align(ofs, is_first_parameter, indent);
515 ofs << "// Verbosity object:\n";
516 ofs << indent;
517 ofs << "const Verbosity& verbosity";
518 }
519
520 ofs << ");\n\n";
521}
522
523bool md_sanity_checks(const Array<MdRecord>& md_data) {
524 ostringstream os;
525
526 bool is_sane = true;
527 for (auto i = md_data.begin(); i < md_data.end();
528 ++i) {
529 bool invalid_author = false;
530 for (auto j = i->Authors().begin();
531 !invalid_author && j < i->Authors().end();
532 ++j) {
533 if (*j == "" || *j == "unknown") invalid_author = true;
534 }
535
536 if (invalid_author) {
537 os << i->Name() << ": Missing or invalid author.\n";
538 is_sane = false;
539 }
540
541 switch (check_newline(i->Description())) {
542 case 1:
543 os << i->Name() << ": Empty description.\n";
544 is_sane = false;
545 break;
546 case 2:
547 os << i->Name() << ": Missing newline at the end of description.\n";
548 is_sane = false;
549 break;
550 case 3:
551 os << i->Name() << ": Extra newline at the end of description.\n";
552 is_sane = false;
553 break;
554 }
555 }
556
557 if (!is_sane) {
558 cerr
559 << "Error(s) found in workspace method documentation (check methods.cc):\n"
560 << os.str();
561 }
562
563 return is_sane;
564}
565
566int main() {
567 try {
568 // Make the global data visible:
571
572 // Initialize the wsv group name array:
574
575 // Initialize wsv data.
577
578 // Initialize WsvMap.
580
581 // Initialize method data.
583
584 // Expand supergeneric methods:
586
587 if (!md_sanity_checks(md_data)) return 1;
588
589 const Index n_md = md_data.nelem();
590
591 // Write auto_md.h:
592 // -----------
593 ofstream ofs;
594 open_output_file(ofs, "auto_md.h");
595
596 ofs << "// This file was generated automatically by make_auto_md_h.cc.\n";
597 ofs << "// DO NOT EDIT !\n";
598 ofs << "// Generated: " << __DATE__ << ", " << __TIME__ << "\n\n";
599
600 ofs << "#ifndef auto_md_h\n";
601 ofs << "#define auto_md_h\n\n";
602
603 ofs << "#include \"matpackI.h\"\n"
604 << "#include \"matpackII.h\"\n"
605 << "#include \"species_tags.h\"\n"
606 << "#include \"artstime.h\"\n"
607 << "#include \"gas_abs_lookup.h\"\n"
608 << "#include \"gridded_fields.h\"\n"
609 << "#include \"linemixing_hitran.h\"\n"
610 << "#include \"optproperties.h\"\n"
611 << "#include \"jacobian.h\"\n"
612 << "#include \"mc_antenna.h\"\n"
613 << "#include \"m_general.h\"\n"
614 << "#include \"parser.h\"\n"
615 << "#include \"workspace_ng.h\"\n"
616 << "#include \"cia.h\"\n"
617 << "#include \"covariance_matrix.h\"\n"
618 << "#include \"propagationmatrix.h\"\n"
619 << "#include <predefined/predef_data.h>\n"
620 << "#include \"transmissionmatrix.h\"\n"
621 << "#include \"star.h\"\n"
622 << "#include \"telsem.h\"\n"
623 << "#include \"tessem.h\"\n"
624 << "#include \"xsec_fit.h\"\n"
625 << "#include \"absorptionlines.h\"\n"
626 << "#include \"linemixing.h\"\n"
627 << "#include \"callback.h\"\n"
628 << "\n";
629
630 ofs << "// This is only used for a consistency check. You can get the\n"
631 << "// number of WSMs from md_data.nelem().\n"
632 << "#define N_MD " << n_md << "\n\n";
633
634 // Add all the method function declarations
635 ofs << "// Method function declarations:\n\n";
636 for (Index i = 0; i < n_md; ++i) {
637 const MdRecord& mdd = md_data[i];
638 if (!mdd.UsesTemplates()) {
640 write_method_header(ofs, mdd);
641 }
642 }
643
644 // Add all the method function declarations
645 ofs << "// Supergeneric template function declarations:\n\n";
646 for (Index i = 0; i < md_data_raw.nelem(); ++i) {
647 const MdRecord& mdd = md_data_raw[i];
648 if (mdd.Supergeneric() && mdd.UsesTemplates()) {
650 write_method_header(ofs, mdd);
651 }
652 }
653
654 // Add all the get-away function declarations:
655 ofs << "// Get-away function declarations:\n\n";
656 for (Index i = 0; i < n_md; ++i) {
657 const MdRecord& mdd = md_data[i];
658 if (mdd.Supergeneric()) {
659 ofs << "void " << mdd.Name() << "_sg_" << mdd.ActualGroups()
660 << "_g(Workspace& ws, const MRecord& mr);\n";
661 } else {
662 ofs << "void " << mdd.Name()
663 << "_g(Workspace& ws, const MRecord& mr);\n";
664 }
665 }
666
667 ofs << "\n";
668
669 // Create prototypes for the agenda wrappers
670
671 // Initialize agenda data.
674
676 const Array<WsvRecord>& wsv_data = global_data::wsv_data;
677 for (Index i = 0; i < agenda_data.nelem(); i++) {
678 auto wsv_ptr = global_data::WsvMap.find(agenda_data[i].Name());
679 ARTS_USER_ERROR_IF(wsv_ptr == global_data::WsvMap.end(), "The ",
680 agenda_data[i].Name(), " agenda fails");
681 bool is_agenda_array = wsv_data[wsv_ptr->second].Group() ==
682 get_wsv_group_id("ArrayOfAgenda");
683 write_agenda_wrapper_header(ofs, agenda_data[i], is_agenda_array);
684
685 ofs << ";\n\n";
686 }
687
688 ofs << "\n#endif // auto_md_h\n";
689
690 // Close auto_md.h.
691 ofs.close();
692
693 } catch (const std::runtime_error& x) {
694 cout << "Something went wrong. Message text:\n";
695 cout << x.what() << '\n';
696 return 1;
697 }
698
699 return 0;
700}
void write_agenda_wrapper_header(ofstream &ofs, const AgRecord &agr, bool is_agenda_array)
Write a agenda wrapper header.
Declarations for AgRecord, storing lookup information for one agenda.
void define_agenda_data()
Definition: agendas.cc:44
This file contains the definition of Array.
The global header file for ARTS.
void define_wsv_groups()
Define the array of workspace variable group names.
Definition: groups.cc:66
This can be used to make arrays out of anything.
Definition: array.h:48
Index nelem() const ARTS_NOEXCEPT
Definition: array.h:92
All information for one workspace method.
Definition: methods.h:38
const ArrayOfIndex & In() const
Definition: methods.h:93
const String & Name() const
Definition: methods.h:85
const ArrayOfIndex & InOnly() const
Definition: methods.h:99
bool PassWorkspace() const
Definition: methods.h:106
const ArrayOfIndex & GOutType() const
Definition: methods.h:90
const String & ActualGroups() const
Definition: methods.h:108
const Array< String > & GInDefault() const
Definition: methods.h:97
bool PassWsvNames() const
Definition: methods.h:107
const String & Description() const
Definition: methods.h:86
const ArrayOfString & GOut() const
Definition: methods.h:89
bool UsesTemplates() const
Definition: methods.h:105
bool AgendaMethod() const
Definition: methods.h:103
bool Supergeneric() const
Definition: methods.h:104
const ArrayOfString & Authors() const
Definition: methods.h:87
const ArrayOfIndex & Out() const
Definition: methods.h:88
const ArrayOfIndex & GInType() const
Definition: methods.h:95
const ArrayOfString & GIn() const
Definition: methods.h:94
void insert_substr(const my_basic_string< charT > &searchstr, const my_basic_string< charT > &insstr)
Definition: mystring.h:113
Index nelem() const
Definition: mystring.h:189
Helper macros for debugging.
#define ARTS_USER_ERROR_IF(condition,...)
Definition: debug.h:134
int check_newline(const std::string_view s)
Checks if there is exactly one newline character at the end of the string.
Definition: file.cc:250
void open_output_file(ofstream &file, const std::string_view name)
Open a file for writing.
Definition: file.cc:80
This file contains basic functions to handle ASCII files.
Index get_wsv_group_id(const String &name)
Returns the id of the given group.
Definition: groups.cc:360
bool is_agenda_group_id(const Index group)
Check if group is an agenda group.
Definition: groups.cc:399
void write_method_header_documentation(ofstream &ofs, const MdRecord &mdd)
Write method header documentation.
void write_method_header(ofstream &ofs, const MdRecord &mdd)
Write a method header.
void align(ofstream &ofs, bool &is_first_parameter, const String &indent)
int main()
bool md_sanity_checks(const Array< MdRecord > &md_data)
INDEX Index
The type to use for all integer numbers and indices.
Definition: matpack.h:39
void define_md_data_raw()
Definition: methods.cc:190
Declaration of the class MdRecord.
void expand_md_data_raw_to_md_data()
Expand supergeneric methods.
Definition: methods_aux.cc:412
#define NODEF
Definition: methods.h:35
const ArrayOfGroupRecord wsv_groups
The names associated with Wsv groups as Strings.
Definition: global_data.h:91
const Array< MdRecord > md_data_raw
Lookup information for workspace methods.
Definition: methods.cc:42
Array< WsvRecord > wsv_data
Definition: workspace.cc:41
const Array< MdRecord > md_data
Lookup information for workspace methods.
Definition: methods_aux.cc:50
std::map< String, Index > WsvMap
Definition: workspace.cc:43
const Array< AgRecord > agenda_data
The lookup information for the agendas.
Definition: agendas.cc:41
void define_wsv_data()
Definition: workspace.cc:48
void define_wsv_map()
Definition: workspace.cc:5711
This file contains the Workspace class.