ReFRACtor
lidort_interface_masters.h
Go to the documentation of this file.
1 #ifndef LIDORT_INTERFACE_MASTERS_H
2 #define LIDORT_INTERFACE_MASTERS_H
3 
4 #include <iostream>
5 #include <blitz/array.h>
6 
7 #include "fp_exception.h"
8 #include "lidort_interface_types.h"
9 
10 /* This file was auto-generated */
11 
12 namespace FullPhysics {
13 
14 //-----------------------------------------------------------------------
15 // Links to module: "brdf_linsup_masters_m" in file: "brdf_lin_sup_masters.f90"
16 //-----------------------------------------------------------------------
17 
18 extern "C" {
19  void brdf_linsup_masters_m_read_wrap(const char* filename, const int* filename_len, void** brdf_sup_in_in, void** brdf_linsup_in_in, void** brdf_sup_inputstatus_in, void** brdf_sup_out_in, void** brdf_linsup_out_in, void** brdf_sup_outputstatus_in);
20  void brdf_linsup_masters_m_write_wrap(const char* filename, const int* filename_len, void** brdf_sup_in_in, void** brdf_linsup_in_in, void** brdf_sup_inputstatus_in, void** brdf_sup_out_in, void** brdf_linsup_out_in, void** brdf_sup_outputstatus_in);
21  void brdf_linsup_masters_m_brdf_lin_inputmaster_wrap(const int* filnam_in_len, const char* filnam_in, void** brdf_sup_in_in, void** brdf_linsup_in_in, void** brdf_sup_inputstatus_in);
22  void brdf_linsup_masters_m_brdf_lin_mainmaster_wrap(const bool* do_debug_restoration_in, const int* nmoments_input_in, void** brdf_sup_in_in, void** brdf_linsup_in_in, void** brdf_sup_out_in, void** brdf_linsup_out_in, void** brdf_sup_outputstatus_in);
23 }
24 
25 class Brdf_Linsup_Masters {
26 
27 public:
28  Brdf_Linsup_Masters()
29  {
30 
31  // Initialize type pointers
32  brdf_sup_in_.reset( new Brdf_Sup_Inputs() );
33  brdf_linsup_in_.reset( new Brdf_Linsup_Inputs() );
34  brdf_sup_inputstatus_.reset( new Brdf_Input_Exception_Handling() );
35  brdf_sup_out_.reset( new Brdf_Sup_Outputs() );
36  brdf_linsup_out_.reset( new Brdf_Linsup_Outputs() );
37  brdf_sup_outputstatus_.reset( new Brdf_Output_Exception_Handling() );
38 
39  }
40 
41  Brdf_Sup_Inputs& brdf_sup_in() {
42  return *brdf_sup_in_;
43  }
44 
45  const Brdf_Sup_Inputs& brdf_sup_in() const {
46  return *brdf_sup_in_;
47  }
48 
49  boost::shared_ptr<Brdf_Sup_Inputs>& brdf_sup_in_ptr() {
50  return brdf_sup_in_;
51  }
52 
53 
54 
55  Brdf_Linsup_Inputs& brdf_linsup_in() {
56  return *brdf_linsup_in_;
57  }
58 
59  const Brdf_Linsup_Inputs& brdf_linsup_in() const {
60  return *brdf_linsup_in_;
61  }
62 
63  boost::shared_ptr<Brdf_Linsup_Inputs>& brdf_linsup_in_ptr() {
64  return brdf_linsup_in_;
65  }
66 
67 
68 
69  Brdf_Input_Exception_Handling& brdf_sup_inputstatus() {
70  return *brdf_sup_inputstatus_;
71  }
72 
73  const Brdf_Input_Exception_Handling& brdf_sup_inputstatus() const {
74  return *brdf_sup_inputstatus_;
75  }
76 
77  boost::shared_ptr<Brdf_Input_Exception_Handling>& brdf_sup_inputstatus_ptr() {
78  return brdf_sup_inputstatus_;
79  }
80 
81 
82 
83  Brdf_Sup_Outputs& brdf_sup_out() {
84  return *brdf_sup_out_;
85  }
86 
87  const Brdf_Sup_Outputs& brdf_sup_out() const {
88  return *brdf_sup_out_;
89  }
90 
91  boost::shared_ptr<Brdf_Sup_Outputs>& brdf_sup_out_ptr() {
92  return brdf_sup_out_;
93  }
94 
95 
96 
97  Brdf_Linsup_Outputs& brdf_linsup_out() {
98  return *brdf_linsup_out_;
99  }
100 
101  const Brdf_Linsup_Outputs& brdf_linsup_out() const {
102  return *brdf_linsup_out_;
103  }
104 
105  boost::shared_ptr<Brdf_Linsup_Outputs>& brdf_linsup_out_ptr() {
106  return brdf_linsup_out_;
107  }
108 
109 
110 
111  Brdf_Output_Exception_Handling& brdf_sup_outputstatus() {
112  return *brdf_sup_outputstatus_;
113  }
114 
115  const Brdf_Output_Exception_Handling& brdf_sup_outputstatus() const {
116  return *brdf_sup_outputstatus_;
117  }
118 
119  boost::shared_ptr<Brdf_Output_Exception_Handling>& brdf_sup_outputstatus_ptr() {
120  return brdf_sup_outputstatus_;
121  }
122 
123 
124 
125 
126  void read_config(const std::string& filnam_in) {
127  const char* filnam_lcl = filnam_in.c_str();
128  int filnam_in_len = (int) filnam_in.size();
129  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
130  void* brdf_linsup_in_lcl = brdf_linsup_in_->fortran_type_ptr();
131  void* brdf_sup_inputstatus_lcl = brdf_sup_inputstatus_->fortran_type_ptr();
132 
133  brdf_linsup_masters_m_brdf_lin_inputmaster_wrap(&filnam_in_len, filnam_lcl, &brdf_sup_in_lcl, &brdf_linsup_in_lcl, &brdf_sup_inputstatus_lcl);
134 
135 
136  }
137 void run(const bool& do_debug_restoration_in, const int& nmoments_input_in) {
138  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
139  void* brdf_linsup_in_lcl = brdf_linsup_in_->fortran_type_ptr();
140  void* brdf_sup_out_lcl = brdf_sup_out_->fortran_type_ptr();
141  void* brdf_linsup_out_lcl = brdf_linsup_out_->fortran_type_ptr();
142  void* brdf_sup_outputstatus_lcl = brdf_sup_outputstatus_->fortran_type_ptr();
143 
144  brdf_linsup_masters_m_brdf_lin_mainmaster_wrap(&do_debug_restoration_in, &nmoments_input_in, &brdf_sup_in_lcl, &brdf_linsup_in_lcl, &brdf_sup_out_lcl, &brdf_linsup_out_lcl, &brdf_sup_outputstatus_lcl);
145 
146 
147  }
148 
149  // This routine is meant only for testing purposes and interoperability
150  // with offline tests
151  void read_fortran_file(const std::string& filename_in) {
152  const char* filename_lcl = filename_in.c_str();
153  int filename_in_len = (int) filename_in.size();
154  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
155  void* brdf_linsup_in_lcl = brdf_linsup_in_->fortran_type_ptr();
156  void* brdf_sup_inputstatus_lcl = brdf_sup_inputstatus_->fortran_type_ptr();
157  void* brdf_sup_out_lcl = brdf_sup_out_->fortran_type_ptr();
158  void* brdf_linsup_out_lcl = brdf_linsup_out_->fortran_type_ptr();
159  void* brdf_sup_outputstatus_lcl = brdf_sup_outputstatus_->fortran_type_ptr();
160 
161  brdf_linsup_masters_m_read_wrap(filename_lcl, &filename_in_len, &brdf_sup_in_lcl, &brdf_linsup_in_lcl, &brdf_sup_inputstatus_lcl, &brdf_sup_out_lcl, &brdf_linsup_out_lcl, &brdf_sup_outputstatus_lcl);
162 
163  }
164 
165  // This routine is meant only for testing purposes and interoperability
166  // with offline tests
167  void write_fortran_file(const std::string& filename_in) {
168  const char* filename_lcl = filename_in.c_str();
169  int filename_in_len = (int) filename_in.size();
170  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
171  void* brdf_linsup_in_lcl = brdf_linsup_in_->fortran_type_ptr();
172  void* brdf_sup_inputstatus_lcl = brdf_sup_inputstatus_->fortran_type_ptr();
173  void* brdf_sup_out_lcl = brdf_sup_out_->fortran_type_ptr();
174  void* brdf_linsup_out_lcl = brdf_linsup_out_->fortran_type_ptr();
175  void* brdf_sup_outputstatus_lcl = brdf_sup_outputstatus_->fortran_type_ptr();
176 
177  brdf_linsup_masters_m_write_wrap(filename_lcl, &filename_in_len, &brdf_sup_in_lcl, &brdf_linsup_in_lcl, &brdf_sup_inputstatus_lcl, &brdf_sup_out_lcl, &brdf_linsup_out_lcl, &brdf_sup_outputstatus_lcl);
178 
179  }
180 
181  friend std::ostream& operator<<(std::ostream &output_stream, const Brdf_Linsup_Masters &obj) {
182  output_stream << "Brdf_Linsup_Masters:" << std::endl
183  << " brdf_sup_in: " << obj.brdf_sup_in() << std::endl
184  << " brdf_linsup_in: " << obj.brdf_linsup_in() << std::endl
185  << " brdf_sup_inputstatus: " << obj.brdf_sup_inputstatus() << std::endl
186  << " brdf_sup_out: " << obj.brdf_sup_out() << std::endl
187  << " brdf_linsup_out: " << obj.brdf_linsup_out() << std::endl
188  << "brdf_sup_outputstatus: " << obj.brdf_sup_outputstatus() << std::endl;
189  return output_stream;
190 
191  }
192 
193 private:
194  boost::shared_ptr<Brdf_Sup_Inputs> brdf_sup_in_;
195  boost::shared_ptr<Brdf_Linsup_Inputs> brdf_linsup_in_;
196  boost::shared_ptr<Brdf_Input_Exception_Handling> brdf_sup_inputstatus_;
197  boost::shared_ptr<Brdf_Sup_Outputs> brdf_sup_out_;
198  boost::shared_ptr<Brdf_Linsup_Outputs> brdf_linsup_out_;
199  boost::shared_ptr<Brdf_Output_Exception_Handling> brdf_sup_outputstatus_;
200 };
201 
202 //-----------------------------------------------------------------------
203 // Links to module: "brdf_sup_masters_m" in file: "brdf_sup_masters.f90"
204 //-----------------------------------------------------------------------
205 
206 extern "C" {
207  void brdf_sup_masters_m_read_wrap(const char* filename, const int* filename_len, void** brdf_sup_in_in, void** brdf_sup_inputstatus_in, void** brdf_sup_out_in, void** brdf_sup_outputstatus_in);
208  void brdf_sup_masters_m_write_wrap(const char* filename, const int* filename_len, void** brdf_sup_in_in, void** brdf_sup_inputstatus_in, void** brdf_sup_out_in, void** brdf_sup_outputstatus_in);
209  void brdf_sup_masters_m_brdf_inputmaster_wrap(const int* filnam_in_len, const char* filnam_in, void** brdf_sup_in_in, void** brdf_sup_inputstatus_in);
210  void brdf_sup_masters_m_brdf_mainmaster_wrap(const bool* do_debug_restoration_in, const int* nmoments_input_in, void** brdf_sup_in_in, void** brdf_sup_out_in, void** brdf_sup_outputstatus_in);
211 }
212 
213 class Brdf_Sup_Masters {
214 
215 public:
216  Brdf_Sup_Masters()
217  {
218 
219  // Initialize type pointers
220  brdf_sup_in_.reset( new Brdf_Sup_Inputs() );
221  brdf_sup_inputstatus_.reset( new Brdf_Input_Exception_Handling() );
222  brdf_sup_out_.reset( new Brdf_Sup_Outputs() );
223  brdf_sup_outputstatus_.reset( new Brdf_Output_Exception_Handling() );
224 
225  }
226 
227  Brdf_Sup_Inputs& brdf_sup_in() {
228  return *brdf_sup_in_;
229  }
230 
231  const Brdf_Sup_Inputs& brdf_sup_in() const {
232  return *brdf_sup_in_;
233  }
234 
235  boost::shared_ptr<Brdf_Sup_Inputs>& brdf_sup_in_ptr() {
236  return brdf_sup_in_;
237  }
238 
239 
240 
241  Brdf_Input_Exception_Handling& brdf_sup_inputstatus() {
242  return *brdf_sup_inputstatus_;
243  }
244 
245  const Brdf_Input_Exception_Handling& brdf_sup_inputstatus() const {
246  return *brdf_sup_inputstatus_;
247  }
248 
249  boost::shared_ptr<Brdf_Input_Exception_Handling>& brdf_sup_inputstatus_ptr() {
250  return brdf_sup_inputstatus_;
251  }
252 
253 
254 
255  Brdf_Sup_Outputs& brdf_sup_out() {
256  return *brdf_sup_out_;
257  }
258 
259  const Brdf_Sup_Outputs& brdf_sup_out() const {
260  return *brdf_sup_out_;
261  }
262 
263  boost::shared_ptr<Brdf_Sup_Outputs>& brdf_sup_out_ptr() {
264  return brdf_sup_out_;
265  }
266 
267 
268 
269  Brdf_Output_Exception_Handling& brdf_sup_outputstatus() {
270  return *brdf_sup_outputstatus_;
271  }
272 
273  const Brdf_Output_Exception_Handling& brdf_sup_outputstatus() const {
274  return *brdf_sup_outputstatus_;
275  }
276 
277  boost::shared_ptr<Brdf_Output_Exception_Handling>& brdf_sup_outputstatus_ptr() {
278  return brdf_sup_outputstatus_;
279  }
280 
281 
282 
283 
284  void read_config(const std::string& filnam_in) {
285  const char* filnam_lcl = filnam_in.c_str();
286  int filnam_in_len = (int) filnam_in.size();
287  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
288  void* brdf_sup_inputstatus_lcl = brdf_sup_inputstatus_->fortran_type_ptr();
289 
290  brdf_sup_masters_m_brdf_inputmaster_wrap(&filnam_in_len, filnam_lcl, &brdf_sup_in_lcl, &brdf_sup_inputstatus_lcl);
291 
292 
293  }
294 void run(const bool& do_debug_restoration_in, const int& nmoments_input_in) {
295  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
296  void* brdf_sup_out_lcl = brdf_sup_out_->fortran_type_ptr();
297  void* brdf_sup_outputstatus_lcl = brdf_sup_outputstatus_->fortran_type_ptr();
298 
299  brdf_sup_masters_m_brdf_mainmaster_wrap(&do_debug_restoration_in, &nmoments_input_in, &brdf_sup_in_lcl, &brdf_sup_out_lcl, &brdf_sup_outputstatus_lcl);
300 
301 
302  }
303 
304  // This routine is meant only for testing purposes and interoperability
305  // with offline tests
306  void read_fortran_file(const std::string& filename_in) {
307  const char* filename_lcl = filename_in.c_str();
308  int filename_in_len = (int) filename_in.size();
309  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
310  void* brdf_sup_inputstatus_lcl = brdf_sup_inputstatus_->fortran_type_ptr();
311  void* brdf_sup_out_lcl = brdf_sup_out_->fortran_type_ptr();
312  void* brdf_sup_outputstatus_lcl = brdf_sup_outputstatus_->fortran_type_ptr();
313 
314  brdf_sup_masters_m_read_wrap(filename_lcl, &filename_in_len, &brdf_sup_in_lcl, &brdf_sup_inputstatus_lcl, &brdf_sup_out_lcl, &brdf_sup_outputstatus_lcl);
315 
316  }
317 
318  // This routine is meant only for testing purposes and interoperability
319  // with offline tests
320  void write_fortran_file(const std::string& filename_in) {
321  const char* filename_lcl = filename_in.c_str();
322  int filename_in_len = (int) filename_in.size();
323  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
324  void* brdf_sup_inputstatus_lcl = brdf_sup_inputstatus_->fortran_type_ptr();
325  void* brdf_sup_out_lcl = brdf_sup_out_->fortran_type_ptr();
326  void* brdf_sup_outputstatus_lcl = brdf_sup_outputstatus_->fortran_type_ptr();
327 
328  brdf_sup_masters_m_write_wrap(filename_lcl, &filename_in_len, &brdf_sup_in_lcl, &brdf_sup_inputstatus_lcl, &brdf_sup_out_lcl, &brdf_sup_outputstatus_lcl);
329 
330  }
331 
332  friend std::ostream& operator<<(std::ostream &output_stream, const Brdf_Sup_Masters &obj) {
333  output_stream << "Brdf_Sup_Masters:" << std::endl
334  << " brdf_sup_in: " << obj.brdf_sup_in() << std::endl
335  << " brdf_sup_inputstatus: " << obj.brdf_sup_inputstatus() << std::endl
336  << " brdf_sup_out: " << obj.brdf_sup_out() << std::endl
337  << "brdf_sup_outputstatus: " << obj.brdf_sup_outputstatus() << std::endl;
338  return output_stream;
339 
340  }
341 
342 private:
343  boost::shared_ptr<Brdf_Sup_Inputs> brdf_sup_in_;
344  boost::shared_ptr<Brdf_Input_Exception_Handling> brdf_sup_inputstatus_;
345  boost::shared_ptr<Brdf_Sup_Outputs> brdf_sup_out_;
346  boost::shared_ptr<Brdf_Output_Exception_Handling> brdf_sup_outputstatus_;
347 };
348 
349 //-----------------------------------------------------------------------
350 // Links to module: "lidort_lcs_masters" in file: "lidort_lcs_masters.f90"
351 //-----------------------------------------------------------------------
352 
353 extern "C" {
354  void lcs_masters_read_wrap(const char* filename, const int* filename_len, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in, void** lidort_linfixin_in, void** lidort_linmodin_in, void** lidort_linsup_in, void** lidort_linout_in);
355  void lcs_masters_write_wrap(const char* filename, const int* filename_len, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in, void** lidort_linfixin_in, void** lidort_linmodin_in, void** lidort_linsup_in, void** lidort_linout_in);
356  void lcs_masters_lcs_master_wrap(void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in, void** lidort_linfixin_in, void** lidort_linmodin_in, void** lidort_linsup_in, void** lidort_linout_in);
357 }
358 
359 class Lidort_Lcs_Masters {
360 
361 public:
362  Lidort_Lcs_Masters()
363  {
364 
365  // Initialize type pointers
366  lidort_fixin_.reset( new Lidort_Fixed_Inputs() );
367  lidort_modin_.reset( new Lidort_Modified_Inputs() );
368  lidort_sup_.reset( new Lidort_Sup_Inout() );
369  lidort_out_.reset( new Lidort_Outputs() );
370  lidort_linfixin_.reset( new Lidort_Fixed_Lininputs() );
371  lidort_linmodin_.reset( new Lidort_Modified_Lininputs() );
372  lidort_linsup_.reset( new Lidort_Linsup_Inout() );
373  lidort_linout_.reset( new Lidort_Linoutputs() );
374 
375  }
376 
377  Lidort_Fixed_Inputs& lidort_fixin() {
378  return *lidort_fixin_;
379  }
380 
381  const Lidort_Fixed_Inputs& lidort_fixin() const {
382  return *lidort_fixin_;
383  }
384 
385  boost::shared_ptr<Lidort_Fixed_Inputs>& lidort_fixin_ptr() {
386  return lidort_fixin_;
387  }
388 
389  void lidort_fixin(Lidort_Fixed_Inputs& lidort_fixin_in) {
390  void* src_ptr = lidort_fixin_in.fortran_type_ptr();
391  void* dst_ptr = lidort_fixin_->fortran_type_ptr();
392  lidort_fixed_inputs_c_copy(&src_ptr, &dst_ptr);
393  }
394 
395 
396 
397  Lidort_Modified_Inputs& lidort_modin() {
398  return *lidort_modin_;
399  }
400 
401  const Lidort_Modified_Inputs& lidort_modin() const {
402  return *lidort_modin_;
403  }
404 
405  boost::shared_ptr<Lidort_Modified_Inputs>& lidort_modin_ptr() {
406  return lidort_modin_;
407  }
408 
409  void lidort_modin(Lidort_Modified_Inputs& lidort_modin_in) {
410  void* src_ptr = lidort_modin_in.fortran_type_ptr();
411  void* dst_ptr = lidort_modin_->fortran_type_ptr();
412  lidort_modified_inputs_c_copy(&src_ptr, &dst_ptr);
413  }
414 
415 
416 
417  Lidort_Sup_Inout& lidort_sup() {
418  return *lidort_sup_;
419  }
420 
421  const Lidort_Sup_Inout& lidort_sup() const {
422  return *lidort_sup_;
423  }
424 
425  boost::shared_ptr<Lidort_Sup_Inout>& lidort_sup_ptr() {
426  return lidort_sup_;
427  }
428 
429  void lidort_sup(Lidort_Sup_Inout& lidort_sup_in) {
430  void* src_ptr = lidort_sup_in.fortran_type_ptr();
431  void* dst_ptr = lidort_sup_->fortran_type_ptr();
432  lidort_sup_inout_c_copy(&src_ptr, &dst_ptr);
433  }
434 
435 
436 
437  Lidort_Outputs& lidort_out() {
438  return *lidort_out_;
439  }
440 
441  const Lidort_Outputs& lidort_out() const {
442  return *lidort_out_;
443  }
444 
445  boost::shared_ptr<Lidort_Outputs>& lidort_out_ptr() {
446  return lidort_out_;
447  }
448 
449 
450 
451  Lidort_Fixed_Lininputs& lidort_linfixin() {
452  return *lidort_linfixin_;
453  }
454 
455  const Lidort_Fixed_Lininputs& lidort_linfixin() const {
456  return *lidort_linfixin_;
457  }
458 
459  boost::shared_ptr<Lidort_Fixed_Lininputs>& lidort_linfixin_ptr() {
460  return lidort_linfixin_;
461  }
462 
463  void lidort_linfixin(Lidort_Fixed_Lininputs& lidort_linfixin_in) {
464  void* src_ptr = lidort_linfixin_in.fortran_type_ptr();
465  void* dst_ptr = lidort_linfixin_->fortran_type_ptr();
466  lidort_fixed_lininputs_c_copy(&src_ptr, &dst_ptr);
467  }
468 
469 
470 
471  Lidort_Modified_Lininputs& lidort_linmodin() {
472  return *lidort_linmodin_;
473  }
474 
475  const Lidort_Modified_Lininputs& lidort_linmodin() const {
476  return *lidort_linmodin_;
477  }
478 
479  boost::shared_ptr<Lidort_Modified_Lininputs>& lidort_linmodin_ptr() {
480  return lidort_linmodin_;
481  }
482 
483  void lidort_linmodin(Lidort_Modified_Lininputs& lidort_linmodin_in) {
484  void* src_ptr = lidort_linmodin_in.fortran_type_ptr();
485  void* dst_ptr = lidort_linmodin_->fortran_type_ptr();
486  lidort_modified_lininputs_c_copy(&src_ptr, &dst_ptr);
487  }
488 
489 
490 
491  Lidort_Linsup_Inout& lidort_linsup() {
492  return *lidort_linsup_;
493  }
494 
495  const Lidort_Linsup_Inout& lidort_linsup() const {
496  return *lidort_linsup_;
497  }
498 
499  boost::shared_ptr<Lidort_Linsup_Inout>& lidort_linsup_ptr() {
500  return lidort_linsup_;
501  }
502 
503  void lidort_linsup(Lidort_Linsup_Inout& lidort_linsup_in) {
504  void* src_ptr = lidort_linsup_in.fortran_type_ptr();
505  void* dst_ptr = lidort_linsup_->fortran_type_ptr();
506  lidort_linsup_inout_c_copy(&src_ptr, &dst_ptr);
507  }
508 
509 
510 
511  Lidort_Linoutputs& lidort_linout() {
512  return *lidort_linout_;
513  }
514 
515  const Lidort_Linoutputs& lidort_linout() const {
516  return *lidort_linout_;
517  }
518 
519  boost::shared_ptr<Lidort_Linoutputs>& lidort_linout_ptr() {
520  return lidort_linout_;
521  }
522 
523 
524 
525 
526  void run() {
527  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
528  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
529  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
530  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
531  void* lidort_linfixin_lcl = lidort_linfixin_->fortran_type_ptr();
532  void* lidort_linmodin_lcl = lidort_linmodin_->fortran_type_ptr();
533  void* lidort_linsup_lcl = lidort_linsup_->fortran_type_ptr();
534  void* lidort_linout_lcl = lidort_linout_->fortran_type_ptr();
535 
536  lcs_masters_lcs_master_wrap(&lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl, &lidort_linfixin_lcl, &lidort_linmodin_lcl, &lidort_linsup_lcl, &lidort_linout_lcl);
537 
538  Lidort_Pars lid_pars = Lidort_Pars::instance();
539  if( lidort_out().status().ts_status_inputcheck() != lid_pars.lidort_success ||
540  lidort_out().status().ts_status_calculation() != lid_pars.lidort_success ) {
541  std::stringstream err_msg;
542  err_msg << "LIDORT Error at " << __FILE__ << ":" << __LINE__ << std::endl;
543  // Output the full details of the error message to stderr since the exception
544  // class may truncate the message
545  std::cerr << err_msg.str();
546  std::cerr << lidort_out().status();
547  throw Exception(err_msg.str());
548  }
549 
550  }
551 
552  // This routine is meant only for testing purposes and interoperability
553  // with offline tests
554  void read_fortran_file(const std::string& filename_in) {
555  const char* filename_lcl = filename_in.c_str();
556  int filename_in_len = (int) filename_in.size();
557  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
558  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
559  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
560  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
561  void* lidort_linfixin_lcl = lidort_linfixin_->fortran_type_ptr();
562  void* lidort_linmodin_lcl = lidort_linmodin_->fortran_type_ptr();
563  void* lidort_linsup_lcl = lidort_linsup_->fortran_type_ptr();
564  void* lidort_linout_lcl = lidort_linout_->fortran_type_ptr();
565 
566  lcs_masters_read_wrap(filename_lcl, &filename_in_len, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl, &lidort_linfixin_lcl, &lidort_linmodin_lcl, &lidort_linsup_lcl, &lidort_linout_lcl);
567 
568  }
569 
570  // This routine is meant only for testing purposes and interoperability
571  // with offline tests
572  void write_fortran_file(const std::string& filename_in) {
573  const char* filename_lcl = filename_in.c_str();
574  int filename_in_len = (int) filename_in.size();
575  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
576  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
577  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
578  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
579  void* lidort_linfixin_lcl = lidort_linfixin_->fortran_type_ptr();
580  void* lidort_linmodin_lcl = lidort_linmodin_->fortran_type_ptr();
581  void* lidort_linsup_lcl = lidort_linsup_->fortran_type_ptr();
582  void* lidort_linout_lcl = lidort_linout_->fortran_type_ptr();
583 
584  lcs_masters_write_wrap(filename_lcl, &filename_in_len, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl, &lidort_linfixin_lcl, &lidort_linmodin_lcl, &lidort_linsup_lcl, &lidort_linout_lcl);
585 
586  }
587 
588  friend std::ostream& operator<<(std::ostream &output_stream, const Lidort_Lcs_Masters &obj) {
589  output_stream << "Lidort_Lcs_Masters:" << std::endl
590  << " lidort_fixin: " << obj.lidort_fixin() << std::endl
591  << " lidort_modin: " << obj.lidort_modin() << std::endl
592  << " lidort_sup: " << obj.lidort_sup() << std::endl
593  << " lidort_out: " << obj.lidort_out() << std::endl
594  << "lidort_linfixin: " << obj.lidort_linfixin() << std::endl
595  << "lidort_linmodin: " << obj.lidort_linmodin() << std::endl
596  << " lidort_linsup: " << obj.lidort_linsup() << std::endl
597  << " lidort_linout: " << obj.lidort_linout() << std::endl;
598  return output_stream;
599 
600  }
601 
602 private:
603  boost::shared_ptr<Lidort_Fixed_Inputs> lidort_fixin_;
604  boost::shared_ptr<Lidort_Modified_Inputs> lidort_modin_;
605  boost::shared_ptr<Lidort_Sup_Inout> lidort_sup_;
606  boost::shared_ptr<Lidort_Outputs> lidort_out_;
607  boost::shared_ptr<Lidort_Fixed_Lininputs> lidort_linfixin_;
608  boost::shared_ptr<Lidort_Modified_Lininputs> lidort_linmodin_;
609  boost::shared_ptr<Lidort_Linsup_Inout> lidort_linsup_;
610  boost::shared_ptr<Lidort_Linoutputs> lidort_linout_;
611 };
612 
613 //-----------------------------------------------------------------------
614 // Links to module: "lidort_lps_masters" in file: "lidort_lps_masters.f90"
615 //-----------------------------------------------------------------------
616 
617 extern "C" {
618  void lps_masters_read_wrap(const char* filename, const int* filename_len, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in, void** lidort_linfixin_in, void** lidort_linmodin_in, void** lidort_linsup_in, void** lidort_linout_in);
619  void lps_masters_write_wrap(const char* filename, const int* filename_len, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in, void** lidort_linfixin_in, void** lidort_linmodin_in, void** lidort_linsup_in, void** lidort_linout_in);
620  void lps_masters_lps_master_wrap(void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in, void** lidort_linfixin_in, void** lidort_linmodin_in, void** lidort_linsup_in, void** lidort_linout_in);
621 }
622 
623 class Lidort_Lps_Masters {
624 
625 public:
626  Lidort_Lps_Masters()
627  {
628 
629  // Initialize type pointers
630  lidort_fixin_.reset( new Lidort_Fixed_Inputs() );
631  lidort_modin_.reset( new Lidort_Modified_Inputs() );
632  lidort_sup_.reset( new Lidort_Sup_Inout() );
633  lidort_out_.reset( new Lidort_Outputs() );
634  lidort_linfixin_.reset( new Lidort_Fixed_Lininputs() );
635  lidort_linmodin_.reset( new Lidort_Modified_Lininputs() );
636  lidort_linsup_.reset( new Lidort_Linsup_Inout() );
637  lidort_linout_.reset( new Lidort_Linoutputs() );
638 
639  }
640 
641  Lidort_Fixed_Inputs& lidort_fixin() {
642  return *lidort_fixin_;
643  }
644 
645  const Lidort_Fixed_Inputs& lidort_fixin() const {
646  return *lidort_fixin_;
647  }
648 
649  boost::shared_ptr<Lidort_Fixed_Inputs>& lidort_fixin_ptr() {
650  return lidort_fixin_;
651  }
652 
653  void lidort_fixin(Lidort_Fixed_Inputs& lidort_fixin_in) {
654  void* src_ptr = lidort_fixin_in.fortran_type_ptr();
655  void* dst_ptr = lidort_fixin_->fortran_type_ptr();
656  lidort_fixed_inputs_c_copy(&src_ptr, &dst_ptr);
657  }
658 
659 
660 
661  Lidort_Modified_Inputs& lidort_modin() {
662  return *lidort_modin_;
663  }
664 
665  const Lidort_Modified_Inputs& lidort_modin() const {
666  return *lidort_modin_;
667  }
668 
669  boost::shared_ptr<Lidort_Modified_Inputs>& lidort_modin_ptr() {
670  return lidort_modin_;
671  }
672 
673  void lidort_modin(Lidort_Modified_Inputs& lidort_modin_in) {
674  void* src_ptr = lidort_modin_in.fortran_type_ptr();
675  void* dst_ptr = lidort_modin_->fortran_type_ptr();
676  lidort_modified_inputs_c_copy(&src_ptr, &dst_ptr);
677  }
678 
679 
680 
681  Lidort_Sup_Inout& lidort_sup() {
682  return *lidort_sup_;
683  }
684 
685  const Lidort_Sup_Inout& lidort_sup() const {
686  return *lidort_sup_;
687  }
688 
689  boost::shared_ptr<Lidort_Sup_Inout>& lidort_sup_ptr() {
690  return lidort_sup_;
691  }
692 
693  void lidort_sup(Lidort_Sup_Inout& lidort_sup_in) {
694  void* src_ptr = lidort_sup_in.fortran_type_ptr();
695  void* dst_ptr = lidort_sup_->fortran_type_ptr();
696  lidort_sup_inout_c_copy(&src_ptr, &dst_ptr);
697  }
698 
699 
700 
701  Lidort_Outputs& lidort_out() {
702  return *lidort_out_;
703  }
704 
705  const Lidort_Outputs& lidort_out() const {
706  return *lidort_out_;
707  }
708 
709  boost::shared_ptr<Lidort_Outputs>& lidort_out_ptr() {
710  return lidort_out_;
711  }
712 
713 
714 
715  Lidort_Fixed_Lininputs& lidort_linfixin() {
716  return *lidort_linfixin_;
717  }
718 
719  const Lidort_Fixed_Lininputs& lidort_linfixin() const {
720  return *lidort_linfixin_;
721  }
722 
723  boost::shared_ptr<Lidort_Fixed_Lininputs>& lidort_linfixin_ptr() {
724  return lidort_linfixin_;
725  }
726 
727  void lidort_linfixin(Lidort_Fixed_Lininputs& lidort_linfixin_in) {
728  void* src_ptr = lidort_linfixin_in.fortran_type_ptr();
729  void* dst_ptr = lidort_linfixin_->fortran_type_ptr();
730  lidort_fixed_lininputs_c_copy(&src_ptr, &dst_ptr);
731  }
732 
733 
734 
735  Lidort_Modified_Lininputs& lidort_linmodin() {
736  return *lidort_linmodin_;
737  }
738 
739  const Lidort_Modified_Lininputs& lidort_linmodin() const {
740  return *lidort_linmodin_;
741  }
742 
743  boost::shared_ptr<Lidort_Modified_Lininputs>& lidort_linmodin_ptr() {
744  return lidort_linmodin_;
745  }
746 
747  void lidort_linmodin(Lidort_Modified_Lininputs& lidort_linmodin_in) {
748  void* src_ptr = lidort_linmodin_in.fortran_type_ptr();
749  void* dst_ptr = lidort_linmodin_->fortran_type_ptr();
750  lidort_modified_lininputs_c_copy(&src_ptr, &dst_ptr);
751  }
752 
753 
754 
755  Lidort_Linsup_Inout& lidort_linsup() {
756  return *lidort_linsup_;
757  }
758 
759  const Lidort_Linsup_Inout& lidort_linsup() const {
760  return *lidort_linsup_;
761  }
762 
763  boost::shared_ptr<Lidort_Linsup_Inout>& lidort_linsup_ptr() {
764  return lidort_linsup_;
765  }
766 
767  void lidort_linsup(Lidort_Linsup_Inout& lidort_linsup_in) {
768  void* src_ptr = lidort_linsup_in.fortran_type_ptr();
769  void* dst_ptr = lidort_linsup_->fortran_type_ptr();
770  lidort_linsup_inout_c_copy(&src_ptr, &dst_ptr);
771  }
772 
773 
774 
775  Lidort_Linoutputs& lidort_linout() {
776  return *lidort_linout_;
777  }
778 
779  const Lidort_Linoutputs& lidort_linout() const {
780  return *lidort_linout_;
781  }
782 
783  boost::shared_ptr<Lidort_Linoutputs>& lidort_linout_ptr() {
784  return lidort_linout_;
785  }
786 
787 
788 
789 
790  void run() {
791  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
792  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
793  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
794  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
795  void* lidort_linfixin_lcl = lidort_linfixin_->fortran_type_ptr();
796  void* lidort_linmodin_lcl = lidort_linmodin_->fortran_type_ptr();
797  void* lidort_linsup_lcl = lidort_linsup_->fortran_type_ptr();
798  void* lidort_linout_lcl = lidort_linout_->fortran_type_ptr();
799 
800  lps_masters_lps_master_wrap(&lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl, &lidort_linfixin_lcl, &lidort_linmodin_lcl, &lidort_linsup_lcl, &lidort_linout_lcl);
801 
802  Lidort_Pars lid_pars = Lidort_Pars::instance();
803  if( lidort_out().status().ts_status_inputcheck() != lid_pars.lidort_success ||
804  lidort_out().status().ts_status_calculation() != lid_pars.lidort_success ) {
805  std::stringstream err_msg;
806  err_msg << "LIDORT Error at " << __FILE__ << ":" << __LINE__ << std::endl;
807  // Output the full details of the error message to stderr since the exception
808  // class may truncate the message
809  std::cerr << err_msg.str();
810  std::cerr << lidort_out().status();
811  throw Exception(err_msg.str());
812  }
813 
814  }
815 
816  // This routine is meant only for testing purposes and interoperability
817  // with offline tests
818  void read_fortran_file(const std::string& filename_in) {
819  const char* filename_lcl = filename_in.c_str();
820  int filename_in_len = (int) filename_in.size();
821  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
822  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
823  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
824  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
825  void* lidort_linfixin_lcl = lidort_linfixin_->fortran_type_ptr();
826  void* lidort_linmodin_lcl = lidort_linmodin_->fortran_type_ptr();
827  void* lidort_linsup_lcl = lidort_linsup_->fortran_type_ptr();
828  void* lidort_linout_lcl = lidort_linout_->fortran_type_ptr();
829 
830  lps_masters_read_wrap(filename_lcl, &filename_in_len, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl, &lidort_linfixin_lcl, &lidort_linmodin_lcl, &lidort_linsup_lcl, &lidort_linout_lcl);
831 
832  }
833 
834  // This routine is meant only for testing purposes and interoperability
835  // with offline tests
836  void write_fortran_file(const std::string& filename_in) {
837  const char* filename_lcl = filename_in.c_str();
838  int filename_in_len = (int) filename_in.size();
839  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
840  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
841  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
842  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
843  void* lidort_linfixin_lcl = lidort_linfixin_->fortran_type_ptr();
844  void* lidort_linmodin_lcl = lidort_linmodin_->fortran_type_ptr();
845  void* lidort_linsup_lcl = lidort_linsup_->fortran_type_ptr();
846  void* lidort_linout_lcl = lidort_linout_->fortran_type_ptr();
847 
848  lps_masters_write_wrap(filename_lcl, &filename_in_len, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl, &lidort_linfixin_lcl, &lidort_linmodin_lcl, &lidort_linsup_lcl, &lidort_linout_lcl);
849 
850  }
851 
852  friend std::ostream& operator<<(std::ostream &output_stream, const Lidort_Lps_Masters &obj) {
853  output_stream << "Lidort_Lps_Masters:" << std::endl
854  << " lidort_fixin: " << obj.lidort_fixin() << std::endl
855  << " lidort_modin: " << obj.lidort_modin() << std::endl
856  << " lidort_sup: " << obj.lidort_sup() << std::endl
857  << " lidort_out: " << obj.lidort_out() << std::endl
858  << "lidort_linfixin: " << obj.lidort_linfixin() << std::endl
859  << "lidort_linmodin: " << obj.lidort_linmodin() << std::endl
860  << " lidort_linsup: " << obj.lidort_linsup() << std::endl
861  << " lidort_linout: " << obj.lidort_linout() << std::endl;
862  return output_stream;
863 
864  }
865 
866 private:
867  boost::shared_ptr<Lidort_Fixed_Inputs> lidort_fixin_;
868  boost::shared_ptr<Lidort_Modified_Inputs> lidort_modin_;
869  boost::shared_ptr<Lidort_Sup_Inout> lidort_sup_;
870  boost::shared_ptr<Lidort_Outputs> lidort_out_;
871  boost::shared_ptr<Lidort_Fixed_Lininputs> lidort_linfixin_;
872  boost::shared_ptr<Lidort_Modified_Lininputs> lidort_linmodin_;
873  boost::shared_ptr<Lidort_Linsup_Inout> lidort_linsup_;
874  boost::shared_ptr<Lidort_Linoutputs> lidort_linout_;
875 };
876 
877 //-----------------------------------------------------------------------
878 // Links to module: "lidort_inputs" in file: "lidort_inputs.f90"
879 //-----------------------------------------------------------------------
880 
881 extern "C" {
882  void inputs_read_wrap(const char* filename, const int* filename_len, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_inputstatus_in);
883  void inputs_write_wrap(const char* filename, const int* filename_len, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_inputstatus_in);
884  void inputs_input_master_wrap(const int* filnam_in_len, const char* filnam_in, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_inputstatus_in);
885 }
886 
887 class Lidort_Inputs {
888 
889 public:
890  Lidort_Inputs()
891  {
892 
893  // Initialize type pointers
894  lidort_fixin_.reset( new Lidort_Fixed_Inputs() );
895  lidort_modin_.reset( new Lidort_Modified_Inputs() );
896  lidort_inputstatus_.reset( new Lidort_Input_Exception_Handling() );
897 
898  }
899 
900  Lidort_Fixed_Inputs& lidort_fixin() {
901  return *lidort_fixin_;
902  }
903 
904  const Lidort_Fixed_Inputs& lidort_fixin() const {
905  return *lidort_fixin_;
906  }
907 
908  boost::shared_ptr<Lidort_Fixed_Inputs>& lidort_fixin_ptr() {
909  return lidort_fixin_;
910  }
911 
912 
913 
914  Lidort_Modified_Inputs& lidort_modin() {
915  return *lidort_modin_;
916  }
917 
918  const Lidort_Modified_Inputs& lidort_modin() const {
919  return *lidort_modin_;
920  }
921 
922  boost::shared_ptr<Lidort_Modified_Inputs>& lidort_modin_ptr() {
923  return lidort_modin_;
924  }
925 
926 
927 
928  Lidort_Input_Exception_Handling& lidort_inputstatus() {
929  return *lidort_inputstatus_;
930  }
931 
932  const Lidort_Input_Exception_Handling& lidort_inputstatus() const {
933  return *lidort_inputstatus_;
934  }
935 
936  boost::shared_ptr<Lidort_Input_Exception_Handling>& lidort_inputstatus_ptr() {
937  return lidort_inputstatus_;
938  }
939 
940 
941 
942 
943  void read_config(const std::string& filnam_in) {
944  const char* filnam_lcl = filnam_in.c_str();
945  int filnam_in_len = (int) filnam_in.size();
946  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
947  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
948  void* lidort_inputstatus_lcl = lidort_inputstatus_->fortran_type_ptr();
949 
950  inputs_input_master_wrap(&filnam_in_len, filnam_lcl, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_inputstatus_lcl);
951 
952 
953  }
954 
955  // This routine is meant only for testing purposes and interoperability
956  // with offline tests
957  void read_fortran_file(const std::string& filename_in) {
958  const char* filename_lcl = filename_in.c_str();
959  int filename_in_len = (int) filename_in.size();
960  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
961  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
962  void* lidort_inputstatus_lcl = lidort_inputstatus_->fortran_type_ptr();
963 
964  inputs_read_wrap(filename_lcl, &filename_in_len, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_inputstatus_lcl);
965 
966  }
967 
968  // This routine is meant only for testing purposes and interoperability
969  // with offline tests
970  void write_fortran_file(const std::string& filename_in) {
971  const char* filename_lcl = filename_in.c_str();
972  int filename_in_len = (int) filename_in.size();
973  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
974  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
975  void* lidort_inputstatus_lcl = lidort_inputstatus_->fortran_type_ptr();
976 
977  inputs_write_wrap(filename_lcl, &filename_in_len, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_inputstatus_lcl);
978 
979  }
980 
981  friend std::ostream& operator<<(std::ostream &output_stream, const Lidort_Inputs &obj) {
982  output_stream << "Lidort_Inputs:" << std::endl
983  << " lidort_fixin: " << obj.lidort_fixin() << std::endl
984  << " lidort_modin: " << obj.lidort_modin() << std::endl
985  << "lidort_inputstatus: " << obj.lidort_inputstatus() << std::endl;
986  return output_stream;
987 
988  }
989 
990 private:
991  boost::shared_ptr<Lidort_Fixed_Inputs> lidort_fixin_;
992  boost::shared_ptr<Lidort_Modified_Inputs> lidort_modin_;
993  boost::shared_ptr<Lidort_Input_Exception_Handling> lidort_inputstatus_;
994 };
995 
996 //-----------------------------------------------------------------------
997 // Links to module: "lidort_masters" in file: "lidort_masters.f90"
998 //-----------------------------------------------------------------------
999 
1000 extern "C" {
1001  void masters_read_wrap(const char* filename, const int* filename_len, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in);
1002  void masters_write_wrap(const char* filename, const int* filename_len, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in);
1003  void masters_master_wrap(void** lidort_fixin_in, void** lidort_modin_in, void** lidort_sup_in, void** lidort_out_in);
1004 }
1005 
1006 class Lidort_Masters {
1007 
1008 public:
1009  Lidort_Masters()
1010  {
1011 
1012  // Initialize type pointers
1013  lidort_fixin_.reset( new Lidort_Fixed_Inputs() );
1014  lidort_modin_.reset( new Lidort_Modified_Inputs() );
1015  lidort_sup_.reset( new Lidort_Sup_Inout() );
1016  lidort_out_.reset( new Lidort_Outputs() );
1017 
1018  }
1019 
1020  Lidort_Fixed_Inputs& lidort_fixin() {
1021  return *lidort_fixin_;
1022  }
1023 
1024  const Lidort_Fixed_Inputs& lidort_fixin() const {
1025  return *lidort_fixin_;
1026  }
1027 
1028  boost::shared_ptr<Lidort_Fixed_Inputs>& lidort_fixin_ptr() {
1029  return lidort_fixin_;
1030  }
1031 
1032  void lidort_fixin(Lidort_Fixed_Inputs& lidort_fixin_in) {
1033  void* src_ptr = lidort_fixin_in.fortran_type_ptr();
1034  void* dst_ptr = lidort_fixin_->fortran_type_ptr();
1035  lidort_fixed_inputs_c_copy(&src_ptr, &dst_ptr);
1036  }
1037 
1038 
1039 
1040  Lidort_Modified_Inputs& lidort_modin() {
1041  return *lidort_modin_;
1042  }
1043 
1044  const Lidort_Modified_Inputs& lidort_modin() const {
1045  return *lidort_modin_;
1046  }
1047 
1048  boost::shared_ptr<Lidort_Modified_Inputs>& lidort_modin_ptr() {
1049  return lidort_modin_;
1050  }
1051 
1052  void lidort_modin(Lidort_Modified_Inputs& lidort_modin_in) {
1053  void* src_ptr = lidort_modin_in.fortran_type_ptr();
1054  void* dst_ptr = lidort_modin_->fortran_type_ptr();
1055  lidort_modified_inputs_c_copy(&src_ptr, &dst_ptr);
1056  }
1057 
1058 
1059 
1060  Lidort_Sup_Inout& lidort_sup() {
1061  return *lidort_sup_;
1062  }
1063 
1064  const Lidort_Sup_Inout& lidort_sup() const {
1065  return *lidort_sup_;
1066  }
1067 
1068  boost::shared_ptr<Lidort_Sup_Inout>& lidort_sup_ptr() {
1069  return lidort_sup_;
1070  }
1071 
1072  void lidort_sup(Lidort_Sup_Inout& lidort_sup_in) {
1073  void* src_ptr = lidort_sup_in.fortran_type_ptr();
1074  void* dst_ptr = lidort_sup_->fortran_type_ptr();
1075  lidort_sup_inout_c_copy(&src_ptr, &dst_ptr);
1076  }
1077 
1078 
1079 
1080  Lidort_Outputs& lidort_out() {
1081  return *lidort_out_;
1082  }
1083 
1084  const Lidort_Outputs& lidort_out() const {
1085  return *lidort_out_;
1086  }
1087 
1088  boost::shared_ptr<Lidort_Outputs>& lidort_out_ptr() {
1089  return lidort_out_;
1090  }
1091 
1092 
1093 
1094 
1095  void run() {
1096  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
1097  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
1098  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
1099  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
1100 
1101  masters_master_wrap(&lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl);
1102 
1103  Lidort_Pars lid_pars = Lidort_Pars::instance();
1104  if( lidort_out().status().ts_status_inputcheck() != lid_pars.lidort_success ||
1105  lidort_out().status().ts_status_calculation() != lid_pars.lidort_success ) {
1106  std::stringstream err_msg;
1107  err_msg << "LIDORT Error at " << __FILE__ << ":" << __LINE__ << std::endl;
1108  // Output the full details of the error message to stderr since the exception
1109  // class may truncate the message
1110  std::cerr << err_msg.str();
1111  std::cerr << lidort_out().status();
1112  throw Exception(err_msg.str());
1113  }
1114 
1115  }
1116 
1117  // This routine is meant only for testing purposes and interoperability
1118  // with offline tests
1119  void read_fortran_file(const std::string& filename_in) {
1120  const char* filename_lcl = filename_in.c_str();
1121  int filename_in_len = (int) filename_in.size();
1122  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
1123  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
1124  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
1125  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
1126 
1127  masters_read_wrap(filename_lcl, &filename_in_len, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl);
1128 
1129  }
1130 
1131  // This routine is meant only for testing purposes and interoperability
1132  // with offline tests
1133  void write_fortran_file(const std::string& filename_in) {
1134  const char* filename_lcl = filename_in.c_str();
1135  int filename_in_len = (int) filename_in.size();
1136  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
1137  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
1138  void* lidort_sup_lcl = lidort_sup_->fortran_type_ptr();
1139  void* lidort_out_lcl = lidort_out_->fortran_type_ptr();
1140 
1141  masters_write_wrap(filename_lcl, &filename_in_len, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_sup_lcl, &lidort_out_lcl);
1142 
1143  }
1144 
1145  friend std::ostream& operator<<(std::ostream &output_stream, const Lidort_Masters &obj) {
1146  output_stream << "Lidort_Masters:" << std::endl
1147  << "lidort_fixin: " << obj.lidort_fixin() << std::endl
1148  << "lidort_modin: " << obj.lidort_modin() << std::endl
1149  << " lidort_sup: " << obj.lidort_sup() << std::endl
1150  << " lidort_out: " << obj.lidort_out() << std::endl;
1151  return output_stream;
1152 
1153  }
1154 
1155 private:
1156  boost::shared_ptr<Lidort_Fixed_Inputs> lidort_fixin_;
1157  boost::shared_ptr<Lidort_Modified_Inputs> lidort_modin_;
1158  boost::shared_ptr<Lidort_Sup_Inout> lidort_sup_;
1159  boost::shared_ptr<Lidort_Outputs> lidort_out_;
1160 };
1161 
1162 //-----------------------------------------------------------------------
1163 // Links to module: "lidort_sup_accessories" in file: "lidort_sup_accessories.f90"
1164 //-----------------------------------------------------------------------
1165 
1166 extern "C" {
1167  void sup_accessories_read_wrap(const char* filename, const int* filename_len, void** sleave_sup_in_in, void** brdf_sup_in_in, void** brdf_sleavecheck_status_in, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_brdfcheck_status_in);
1168  void sup_accessories_write_wrap(const char* filename, const int* filename_len, void** sleave_sup_in_in, void** brdf_sup_in_in, void** brdf_sleavecheck_status_in, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_brdfcheck_status_in);
1169  void sup_accessories_brdf_sleave_input_checker_wrap(void** sleave_sup_in_in, void** brdf_sup_in_in, void** brdf_sleavecheck_status_in);
1170  void sup_accessories_brdf_input_checker_wrap(void** brdf_sup_in_in, void** lidort_fixin_in, void** lidort_modin_in, void** lidort_brdfcheck_status_in);
1171 }
1172 
1173 class Lidort_Sup_Accessories {
1174 
1175 public:
1176  Lidort_Sup_Accessories(boost::shared_ptr<Brdf_Sup_Inputs>& brdf_sup_in_in, boost::shared_ptr<Lidort_Fixed_Inputs>& lidort_fixin_in, boost::shared_ptr<Lidort_Modified_Inputs>& lidort_modin_in) : brdf_sup_in_(brdf_sup_in_in), lidort_fixin_(lidort_fixin_in), lidort_modin_(lidort_modin_in)
1177  {
1178 
1179  // Initialize type pointers
1180  sleave_sup_in_.reset( new Sleave_Sup_Inputs() );
1181  brdf_sleavecheck_status_.reset( new Lidort_Exception_Handling() );
1182  lidort_brdfcheck_status_.reset( new Lidort_Exception_Handling() );
1183 
1184  }
1185 
1186  Sleave_Sup_Inputs& sleave_sup_in() {
1187  return *sleave_sup_in_;
1188  }
1189 
1190  const Sleave_Sup_Inputs& sleave_sup_in() const {
1191  return *sleave_sup_in_;
1192  }
1193 
1194  boost::shared_ptr<Sleave_Sup_Inputs>& sleave_sup_in_ptr() {
1195  return sleave_sup_in_;
1196  }
1197 
1198  void sleave_sup_in(Sleave_Sup_Inputs& sleave_sup_in_in) {
1199  void* src_ptr = sleave_sup_in_in.fortran_type_ptr();
1200  void* dst_ptr = sleave_sup_in_->fortran_type_ptr();
1201  sleave_sup_inputs_c_copy(&src_ptr, &dst_ptr);
1202  }
1203 
1204 
1205 
1206  Brdf_Sup_Inputs& brdf_sup_in() {
1207  return *brdf_sup_in_;
1208  }
1209 
1210  const Brdf_Sup_Inputs& brdf_sup_in() const {
1211  return *brdf_sup_in_;
1212  }
1213 
1214  boost::shared_ptr<Brdf_Sup_Inputs>& brdf_sup_in_ptr() {
1215  return brdf_sup_in_;
1216  }
1217 
1218 
1219 
1220  Lidort_Exception_Handling& brdf_sleavecheck_status() {
1221  return *brdf_sleavecheck_status_;
1222  }
1223 
1224  const Lidort_Exception_Handling& brdf_sleavecheck_status() const {
1225  return *brdf_sleavecheck_status_;
1226  }
1227 
1228  boost::shared_ptr<Lidort_Exception_Handling>& brdf_sleavecheck_status_ptr() {
1229  return brdf_sleavecheck_status_;
1230  }
1231 
1232 
1233 
1234  Lidort_Fixed_Inputs& lidort_fixin() {
1235  return *lidort_fixin_;
1236  }
1237 
1238  const Lidort_Fixed_Inputs& lidort_fixin() const {
1239  return *lidort_fixin_;
1240  }
1241 
1242  boost::shared_ptr<Lidort_Fixed_Inputs>& lidort_fixin_ptr() {
1243  return lidort_fixin_;
1244  }
1245 
1246 
1247 
1248  Lidort_Modified_Inputs& lidort_modin() {
1249  return *lidort_modin_;
1250  }
1251 
1252  const Lidort_Modified_Inputs& lidort_modin() const {
1253  return *lidort_modin_;
1254  }
1255 
1256  boost::shared_ptr<Lidort_Modified_Inputs>& lidort_modin_ptr() {
1257  return lidort_modin_;
1258  }
1259 
1260 
1261 
1262  Lidort_Exception_Handling& lidort_brdfcheck_status() {
1263  return *lidort_brdfcheck_status_;
1264  }
1265 
1266  const Lidort_Exception_Handling& lidort_brdfcheck_status() const {
1267  return *lidort_brdfcheck_status_;
1268  }
1269 
1270  boost::shared_ptr<Lidort_Exception_Handling>& lidort_brdfcheck_status_ptr() {
1271  return lidort_brdfcheck_status_;
1272  }
1273 
1274 
1275 
1276 
1277  void brdf_sleave_input_checker() {
1278  void* sleave_sup_in_lcl = sleave_sup_in_->fortran_type_ptr();
1279  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
1280  void* brdf_sleavecheck_status_lcl = brdf_sleavecheck_status_->fortran_type_ptr();
1281 
1282  sup_accessories_brdf_sleave_input_checker_wrap(&sleave_sup_in_lcl, &brdf_sup_in_lcl, &brdf_sleavecheck_status_lcl);
1283 
1284 
1285  }
1286 void brdf_input_checker() {
1287  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
1288  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
1289  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
1290  void* lidort_brdfcheck_status_lcl = lidort_brdfcheck_status_->fortran_type_ptr();
1291 
1292  sup_accessories_brdf_input_checker_wrap(&brdf_sup_in_lcl, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_brdfcheck_status_lcl);
1293 
1294 
1295  }
1296 
1297  // This routine is meant only for testing purposes and interoperability
1298  // with offline tests
1299  void read_fortran_file(const std::string& filename_in) {
1300  const char* filename_lcl = filename_in.c_str();
1301  int filename_in_len = (int) filename_in.size();
1302  void* sleave_sup_in_lcl = sleave_sup_in_->fortran_type_ptr();
1303  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
1304  void* brdf_sleavecheck_status_lcl = brdf_sleavecheck_status_->fortran_type_ptr();
1305  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
1306  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
1307  void* lidort_brdfcheck_status_lcl = lidort_brdfcheck_status_->fortran_type_ptr();
1308 
1309  sup_accessories_read_wrap(filename_lcl, &filename_in_len, &sleave_sup_in_lcl, &brdf_sup_in_lcl, &brdf_sleavecheck_status_lcl, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_brdfcheck_status_lcl);
1310 
1311  }
1312 
1313  // This routine is meant only for testing purposes and interoperability
1314  // with offline tests
1315  void write_fortran_file(const std::string& filename_in) {
1316  const char* filename_lcl = filename_in.c_str();
1317  int filename_in_len = (int) filename_in.size();
1318  void* sleave_sup_in_lcl = sleave_sup_in_->fortran_type_ptr();
1319  void* brdf_sup_in_lcl = brdf_sup_in_->fortran_type_ptr();
1320  void* brdf_sleavecheck_status_lcl = brdf_sleavecheck_status_->fortran_type_ptr();
1321  void* lidort_fixin_lcl = lidort_fixin_->fortran_type_ptr();
1322  void* lidort_modin_lcl = lidort_modin_->fortran_type_ptr();
1323  void* lidort_brdfcheck_status_lcl = lidort_brdfcheck_status_->fortran_type_ptr();
1324 
1325  sup_accessories_write_wrap(filename_lcl, &filename_in_len, &sleave_sup_in_lcl, &brdf_sup_in_lcl, &brdf_sleavecheck_status_lcl, &lidort_fixin_lcl, &lidort_modin_lcl, &lidort_brdfcheck_status_lcl);
1326 
1327  }
1328 
1329  friend std::ostream& operator<<(std::ostream &output_stream, const Lidort_Sup_Accessories &obj) {
1330  output_stream << "Lidort_Sup_Accessories:" << std::endl
1331  << " sleave_sup_in: " << obj.sleave_sup_in() << std::endl
1332  << " brdf_sup_in: " << obj.brdf_sup_in() << std::endl
1333  << "brdf_sleavecheck_status: " << obj.brdf_sleavecheck_status() << std::endl
1334  << " lidort_fixin: " << obj.lidort_fixin() << std::endl
1335  << " lidort_modin: " << obj.lidort_modin() << std::endl
1336  << "lidort_brdfcheck_status: " << obj.lidort_brdfcheck_status() << std::endl;
1337  return output_stream;
1338 
1339  }
1340 
1341 private:
1342  boost::shared_ptr<Sleave_Sup_Inputs> sleave_sup_in_;
1343  boost::shared_ptr<Brdf_Sup_Inputs> brdf_sup_in_;
1344  boost::shared_ptr<Lidort_Exception_Handling> brdf_sleavecheck_status_;
1345  boost::shared_ptr<Lidort_Fixed_Inputs> lidort_fixin_;
1346  boost::shared_ptr<Lidort_Modified_Inputs> lidort_modin_;
1347  boost::shared_ptr<Lidort_Exception_Handling> lidort_brdfcheck_status_;
1348 };
1349 
1350 
1351 
1352 }
1353 #endif
FullPhysics::Brdf_Linsup_Masters::brdf_sup_inputstatus
const Brdf_Input_Exception_Handling & brdf_sup_inputstatus() const
Definition: lidort_interface_masters.h:73
FullPhysics::Lidort_Sup_Accessories::Lidort_Sup_Accessories
Lidort_Sup_Accessories(boost::shared_ptr< Brdf_Sup_Inputs > &brdf_sup_in_in, boost::shared_ptr< Lidort_Fixed_Inputs > &lidort_fixin_in, boost::shared_ptr< Lidort_Modified_Inputs > &lidort_modin_in)
Definition: lidort_interface_masters.h:1176
FullPhysics::masters_master_wrap
void masters_master_wrap(void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in)
FullPhysics::Lidort_Lps_Masters::lidort_sup
const Lidort_Sup_Inout & lidort_sup() const
Definition: lidort_interface_masters.h:685
FullPhysics::lcs_masters_read_wrap
void lcs_masters_read_wrap(const char *filename, const int *filename_len, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in, void **lidort_linfixin_in, void **lidort_linmodin_in, void **lidort_linsup_in, void **lidort_linout_in)
FullPhysics::Lidort_Lcs_Masters::lidort_linmodin
const Lidort_Modified_Lininputs & lidort_linmodin() const
Definition: lidort_interface_masters.h:475
FullPhysics::Lidort_Lcs_Masters::lidort_fixin_ptr
boost::shared_ptr< Lidort_Fixed_Inputs > & lidort_fixin_ptr()
Definition: lidort_interface_masters.h:385
FullPhysics::Lidort_Lps_Masters::operator<<
friend std::ostream & operator<<(std::ostream &output_stream, const Lidort_Lps_Masters &obj)
Definition: lidort_interface_masters.h:852
FullPhysics::Lidort_Pars::instance
static Lidort_Pars & instance()
Definition: lidort_interface_types.h:123
FullPhysics::Lidort_Lps_Masters::lidort_fixin
void lidort_fixin(Lidort_Fixed_Inputs &lidort_fixin_in)
Definition: lidort_interface_masters.h:653
FullPhysics::Brdf_Linsup_Masters::brdf_sup_in_ptr
boost::shared_ptr< Brdf_Sup_Inputs > & brdf_sup_in_ptr()
Definition: lidort_interface_masters.h:49
FullPhysics::Lidort_Lps_Masters::lidort_out_ptr
boost::shared_ptr< Lidort_Outputs > & lidort_out_ptr()
Definition: lidort_interface_masters.h:709
FullPhysics::Lidort_Masters::lidort_fixin_ptr
boost::shared_ptr< Lidort_Fixed_Inputs > & lidort_fixin_ptr()
Definition: lidort_interface_masters.h:1028
FullPhysics::Lidort_Sup_Accessories::brdf_sleavecheck_status_ptr
boost::shared_ptr< Lidort_Exception_Handling > & brdf_sleavecheck_status_ptr()
Definition: lidort_interface_masters.h:1228
FullPhysics::sup_accessories_write_wrap
void sup_accessories_write_wrap(const char *filename, const int *filename_len, void **sleave_sup_in_in, void **brdf_sup_in_in, void **brdf_sleavecheck_status_in, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_brdfcheck_status_in)
FullPhysics::Lidort_Masters::lidort_sup
const Lidort_Sup_Inout & lidort_sup() const
Definition: lidort_interface_masters.h:1064
FullPhysics::Brdf_Linsup_Masters::brdf_sup_outputstatus
const Brdf_Output_Exception_Handling & brdf_sup_outputstatus() const
Definition: lidort_interface_masters.h:115
FullPhysics::inputs_read_wrap
void inputs_read_wrap(const char *filename, const int *filename_len, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_inputstatus_in)
FullPhysics::Brdf_Sup_Masters::brdf_sup_inputstatus_ptr
boost::shared_ptr< Brdf_Input_Exception_Handling > & brdf_sup_inputstatus_ptr()
Definition: lidort_interface_masters.h:249
FullPhysics::Brdf_Sup_Masters::write_fortran_file
void write_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:320
FullPhysics::brdf_linsup_masters_m_write_wrap
void brdf_linsup_masters_m_write_wrap(const char *filename, const int *filename_len, void **brdf_sup_in_in, void **brdf_linsup_in_in, void **brdf_sup_inputstatus_in, void **brdf_sup_out_in, void **brdf_linsup_out_in, void **brdf_sup_outputstatus_in)
FullPhysics::Brdf_Sup_Masters::brdf_sup_inputstatus
Brdf_Input_Exception_Handling & brdf_sup_inputstatus()
Definition: lidort_interface_masters.h:241
FullPhysics::Lidort_Masters::lidort_fixin
const Lidort_Fixed_Inputs & lidort_fixin() const
Definition: lidort_interface_masters.h:1024
FullPhysics::Lidort_Lcs_Masters::operator<<
friend std::ostream & operator<<(std::ostream &output_stream, const Lidort_Lcs_Masters &obj)
Definition: lidort_interface_masters.h:588
FullPhysics::inputs_input_master_wrap
void inputs_input_master_wrap(const int *filnam_in_len, const char *filnam_in, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_inputstatus_in)
FullPhysics::Lidort_Masters::lidort_modin
void lidort_modin(Lidort_Modified_Inputs &lidort_modin_in)
Definition: lidort_interface_masters.h:1052
FullPhysics::Lidort_Masters::operator<<
friend std::ostream & operator<<(std::ostream &output_stream, const Lidort_Masters &obj)
Definition: lidort_interface_masters.h:1145
FullPhysics::Brdf_Linsup_Masters::operator<<
friend std::ostream & operator<<(std::ostream &output_stream, const Brdf_Linsup_Masters &obj)
Definition: lidort_interface_masters.h:181
FullPhysics::sup_accessories_brdf_sleave_input_checker_wrap
void sup_accessories_brdf_sleave_input_checker_wrap(void **sleave_sup_in_in, void **brdf_sup_in_in, void **brdf_sleavecheck_status_in)
FullPhysics::Lidort_Inputs::lidort_inputstatus
const Lidort_Input_Exception_Handling & lidort_inputstatus() const
Definition: lidort_interface_masters.h:932
FullPhysics::Lidort_Lcs_Masters::lidort_linout
const Lidort_Linoutputs & lidort_linout() const
Definition: lidort_interface_masters.h:515
FullPhysics::Brdf_Linsup_Masters::brdf_sup_out
const Brdf_Sup_Outputs & brdf_sup_out() const
Definition: lidort_interface_masters.h:87
FullPhysics::Lidort_Lcs_Masters::lidort_linsup_ptr
boost::shared_ptr< Lidort_Linsup_Inout > & lidort_linsup_ptr()
Definition: lidort_interface_masters.h:499
FullPhysics::Brdf_Sup_Masters::run
void run(const bool &do_debug_restoration_in, const int &nmoments_input_in)
Definition: lidort_interface_masters.h:294
FullPhysics::inputs_write_wrap
void inputs_write_wrap(const char *filename, const int *filename_len, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_inputstatus_in)
FullPhysics::Lidort_Lcs_Masters::lidort_fixin
void lidort_fixin(Lidort_Fixed_Inputs &lidort_fixin_in)
Definition: lidort_interface_masters.h:389
FullPhysics::Brdf_Linsup_Masters::read_fortran_file
void read_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:151
FullPhysics::Lidort_Masters::lidort_fixin
Lidort_Fixed_Inputs & lidort_fixin()
Definition: lidort_interface_masters.h:1020
FullPhysics::Lidort_Masters::lidort_modin_ptr
boost::shared_ptr< Lidort_Modified_Inputs > & lidort_modin_ptr()
Definition: lidort_interface_masters.h:1048
FullPhysics::Lidort_Lps_Masters::lidort_linfixin
Lidort_Fixed_Lininputs & lidort_linfixin()
Definition: lidort_interface_masters.h:715
FullPhysics::Lidort_Sup_Accessories::sleave_sup_in
const Sleave_Sup_Inputs & sleave_sup_in() const
Definition: lidort_interface_masters.h:1190
FullPhysics::Lidort_Lcs_Masters::lidort_linmodin
void lidort_linmodin(Lidort_Modified_Lininputs &lidort_linmodin_in)
Definition: lidort_interface_masters.h:483
FullPhysics::Lidort_Lcs_Masters::read_fortran_file
void read_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:554
FullPhysics::Lidort_Lcs_Masters::lidort_linfixin
Lidort_Fixed_Lininputs & lidort_linfixin()
Definition: lidort_interface_masters.h:451
FullPhysics::Lidort_Lps_Masters::lidort_modin
const Lidort_Modified_Inputs & lidort_modin() const
Definition: lidort_interface_masters.h:665
FullPhysics::Brdf_Sup_Masters::brdf_sup_outputstatus_ptr
boost::shared_ptr< Brdf_Output_Exception_Handling > & brdf_sup_outputstatus_ptr()
Definition: lidort_interface_masters.h:277
FullPhysics::Lidort_Sup_Accessories::lidort_brdfcheck_status_ptr
boost::shared_ptr< Lidort_Exception_Handling > & lidort_brdfcheck_status_ptr()
Definition: lidort_interface_masters.h:1270
FullPhysics::masters_write_wrap
void masters_write_wrap(const char *filename, const int *filename_len, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in)
FullPhysics::Lidort_Inputs::lidort_fixin
const Lidort_Fixed_Inputs & lidort_fixin() const
Definition: lidort_interface_masters.h:904
FullPhysics::Exception
This is the base of the exception hierarchy for Full Physics code.
Definition: fp_exception.h:16
FullPhysics::Lidort_Lps_Masters::lidort_modin
Lidort_Modified_Inputs & lidort_modin()
Definition: lidort_interface_masters.h:661
FullPhysics::brdf_linsup_masters_m_read_wrap
void brdf_linsup_masters_m_read_wrap(const char *filename, const int *filename_len, void **brdf_sup_in_in, void **brdf_linsup_in_in, void **brdf_sup_inputstatus_in, void **brdf_sup_out_in, void **brdf_linsup_out_in, void **brdf_sup_outputstatus_in)
FullPhysics::Brdf_Sup_Masters::brdf_sup_in_ptr
boost::shared_ptr< Brdf_Sup_Inputs > & brdf_sup_in_ptr()
Definition: lidort_interface_masters.h:235
FullPhysics::Lidort_Lps_Masters::lidort_out
const Lidort_Outputs & lidort_out() const
Definition: lidort_interface_masters.h:705
FullPhysics::Lidort_Lcs_Masters::lidort_linsup
void lidort_linsup(Lidort_Linsup_Inout &lidort_linsup_in)
Definition: lidort_interface_masters.h:503
FullPhysics::Lidort_Lcs_Masters::lidort_sup
const Lidort_Sup_Inout & lidort_sup() const
Definition: lidort_interface_masters.h:421
FullPhysics::Brdf_Linsup_Masters::brdf_linsup_in_ptr
boost::shared_ptr< Brdf_Linsup_Inputs > & brdf_linsup_in_ptr()
Definition: lidort_interface_masters.h:63
FullPhysics::Lidort_Lcs_Masters::lidort_linfixin
void lidort_linfixin(Lidort_Fixed_Lininputs &lidort_linfixin_in)
Definition: lidort_interface_masters.h:463
FullPhysics::Lidort_Lps_Masters::lidort_modin_ptr
boost::shared_ptr< Lidort_Modified_Inputs > & lidort_modin_ptr()
Definition: lidort_interface_masters.h:669
FullPhysics::Lidort_Inputs::lidort_modin
const Lidort_Modified_Inputs & lidort_modin() const
Definition: lidort_interface_masters.h:918
FullPhysics::brdf_sup_masters_m_brdf_inputmaster_wrap
void brdf_sup_masters_m_brdf_inputmaster_wrap(const int *filnam_in_len, const char *filnam_in, void **brdf_sup_in_in, void **brdf_sup_inputstatus_in)
FullPhysics::Lidort_Inputs::read_config
void read_config(const std::string &filnam_in)
Definition: lidort_interface_masters.h:943
FullPhysics::Lidort_Lcs_Masters::lidort_linmodin
Lidort_Modified_Lininputs & lidort_linmodin()
Definition: lidort_interface_masters.h:471
FullPhysics::Brdf_Linsup_Masters::run
void run(const bool &do_debug_restoration_in, const int &nmoments_input_in)
Definition: lidort_interface_masters.h:137
FullPhysics::Lidort_Lps_Masters::lidort_modin
void lidort_modin(Lidort_Modified_Inputs &lidort_modin_in)
Definition: lidort_interface_masters.h:673
FullPhysics::Lidort_Lcs_Masters::lidort_linmodin_ptr
boost::shared_ptr< Lidort_Modified_Lininputs > & lidort_linmodin_ptr()
Definition: lidort_interface_masters.h:479
FullPhysics::Brdf_Sup_Masters::read_fortran_file
void read_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:306
FullPhysics::Lidort_Lcs_Masters::lidort_linsup
const Lidort_Linsup_Inout & lidort_linsup() const
Definition: lidort_interface_masters.h:495
FullPhysics::Lidort_Sup_Accessories::lidort_brdfcheck_status
Lidort_Exception_Handling & lidort_brdfcheck_status()
Definition: lidort_interface_masters.h:1262
FullPhysics::Lidort_Sup_Accessories::lidort_fixin_ptr
boost::shared_ptr< Lidort_Fixed_Inputs > & lidort_fixin_ptr()
Definition: lidort_interface_masters.h:1242
FullPhysics::Lidort_Lps_Masters::lidort_fixin_ptr
boost::shared_ptr< Lidort_Fixed_Inputs > & lidort_fixin_ptr()
Definition: lidort_interface_masters.h:649
FullPhysics::Lidort_Masters::lidort_sup
void lidort_sup(Lidort_Sup_Inout &lidort_sup_in)
Definition: lidort_interface_masters.h:1072
FullPhysics::sleave_sup_inputs_c_copy
void sleave_sup_inputs_c_copy(void **fortran_type_c_from, void **fortran_type_c_to)
FullPhysics::Brdf_Sup_Masters::brdf_sup_out_ptr
boost::shared_ptr< Brdf_Sup_Outputs > & brdf_sup_out_ptr()
Definition: lidort_interface_masters.h:263
FullPhysics::Brdf_Sup_Masters::brdf_sup_outputstatus
const Brdf_Output_Exception_Handling & brdf_sup_outputstatus() const
Definition: lidort_interface_masters.h:273
FullPhysics::lidort_linsup_inout_c_copy
void lidort_linsup_inout_c_copy(void **fortran_type_c_from, void **fortran_type_c_to)
FullPhysics::Brdf_Sup_Masters::brdf_sup_inputstatus
const Brdf_Input_Exception_Handling & brdf_sup_inputstatus() const
Definition: lidort_interface_masters.h:245
FullPhysics::Brdf_Sup_Masters::operator<<
friend std::ostream & operator<<(std::ostream &output_stream, const Brdf_Sup_Masters &obj)
Definition: lidort_interface_masters.h:332
FullPhysics::Lidort_Lps_Masters::lidort_fixin
const Lidort_Fixed_Inputs & lidort_fixin() const
Definition: lidort_interface_masters.h:645
FullPhysics::lcs_masters_lcs_master_wrap
void lcs_masters_lcs_master_wrap(void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in, void **lidort_linfixin_in, void **lidort_linmodin_in, void **lidort_linsup_in, void **lidort_linout_in)
FullPhysics::Lidort_Lcs_Masters::lidort_fixin
const Lidort_Fixed_Inputs & lidort_fixin() const
Definition: lidort_interface_masters.h:381
FullPhysics::Lidort_Inputs::lidort_modin_ptr
boost::shared_ptr< Lidort_Modified_Inputs > & lidort_modin_ptr()
Definition: lidort_interface_masters.h:922
FullPhysics::Lidort_Sup_Accessories::sleave_sup_in_ptr
boost::shared_ptr< Sleave_Sup_Inputs > & sleave_sup_in_ptr()
Definition: lidort_interface_masters.h:1194
FullPhysics::Lidort_Masters::write_fortran_file
void write_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:1133
FullPhysics::Lidort_Inputs::lidort_fixin
Lidort_Fixed_Inputs & lidort_fixin()
Definition: lidort_interface_masters.h:900
FullPhysics::Lidort_Inputs::lidort_inputstatus
Lidort_Input_Exception_Handling & lidort_inputstatus()
Definition: lidort_interface_masters.h:928
FullPhysics::Lidort_Inputs::write_fortran_file
void write_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:970
FullPhysics::Lidort_Sup_Accessories::brdf_sleavecheck_status
const Lidort_Exception_Handling & brdf_sleavecheck_status() const
Definition: lidort_interface_masters.h:1224
FullPhysics::masters_read_wrap
void masters_read_wrap(const char *filename, const int *filename_len, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in)
FullPhysics::Lidort_Masters::lidort_modin
const Lidort_Modified_Inputs & lidort_modin() const
Definition: lidort_interface_masters.h:1044
FullPhysics::Lidort_Sup_Accessories::write_fortran_file
void write_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:1315
FullPhysics::Lidort_Lcs_Masters::lidort_modin
Lidort_Modified_Inputs & lidort_modin()
Definition: lidort_interface_masters.h:397
FullPhysics::Lidort_Lcs_Masters::lidort_modin_ptr
boost::shared_ptr< Lidort_Modified_Inputs > & lidort_modin_ptr()
Definition: lidort_interface_masters.h:405
FullPhysics::Lidort_Lps_Masters::lidort_linfixin
void lidort_linfixin(Lidort_Fixed_Lininputs &lidort_linfixin_in)
Definition: lidort_interface_masters.h:727
FullPhysics::Lidort_Lps_Masters::lidort_linmodin
const Lidort_Modified_Lininputs & lidort_linmodin() const
Definition: lidort_interface_masters.h:739
FullPhysics::lidort_sup_inout_c_copy
void lidort_sup_inout_c_copy(void **fortran_type_c_from, void **fortran_type_c_to)
FullPhysics::Lidort_Inputs::read_fortran_file
void read_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:957
FullPhysics::Lidort_Sup_Accessories::lidort_modin
const Lidort_Modified_Inputs & lidort_modin() const
Definition: lidort_interface_masters.h:1252
FullPhysics::Lidort_Lps_Masters::lidort_linsup
const Lidort_Linsup_Inout & lidort_linsup() const
Definition: lidort_interface_masters.h:759
FullPhysics::Lidort_Sup_Accessories::sleave_sup_in
void sleave_sup_in(Sleave_Sup_Inputs &sleave_sup_in_in)
Definition: lidort_interface_masters.h:1198
FullPhysics::Lidort_Lps_Masters::lidort_linout_ptr
boost::shared_ptr< Lidort_Linoutputs > & lidort_linout_ptr()
Definition: lidort_interface_masters.h:783
FullPhysics::Lidort_Lcs_Masters::lidort_linfixin_ptr
boost::shared_ptr< Lidort_Fixed_Lininputs > & lidort_linfixin_ptr()
Definition: lidort_interface_masters.h:459
FullPhysics::Lidort_Lcs_Masters::lidort_linfixin
const Lidort_Fixed_Lininputs & lidort_linfixin() const
Definition: lidort_interface_masters.h:455
FullPhysics::Lidort_Sup_Accessories::lidort_modin_ptr
boost::shared_ptr< Lidort_Modified_Inputs > & lidort_modin_ptr()
Definition: lidort_interface_masters.h:1256
FullPhysics::Lidort_Lcs_Masters::lidort_out_ptr
boost::shared_ptr< Lidort_Outputs > & lidort_out_ptr()
Definition: lidort_interface_masters.h:445
FullPhysics::brdf_sup_masters_m_write_wrap
void brdf_sup_masters_m_write_wrap(const char *filename, const int *filename_len, void **brdf_sup_in_in, void **brdf_sup_inputstatus_in, void **brdf_sup_out_in, void **brdf_sup_outputstatus_in)
FullPhysics::Brdf_Linsup_Masters::brdf_sup_outputstatus_ptr
boost::shared_ptr< Brdf_Output_Exception_Handling > & brdf_sup_outputstatus_ptr()
Definition: lidort_interface_masters.h:119
FullPhysics::Lidort_Lps_Masters::lidort_sup_ptr
boost::shared_ptr< Lidort_Sup_Inout > & lidort_sup_ptr()
Definition: lidort_interface_masters.h:689
FullPhysics::Lidort_Lps_Masters::lidort_linfixin_ptr
boost::shared_ptr< Lidort_Fixed_Lininputs > & lidort_linfixin_ptr()
Definition: lidort_interface_masters.h:723
FullPhysics::Lidort_Lps_Masters::read_fortran_file
void read_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:818
FullPhysics::Brdf_Sup_Masters::brdf_sup_out
const Brdf_Sup_Outputs & brdf_sup_out() const
Definition: lidort_interface_masters.h:259
FullPhysics::Lidort_Lps_Masters::lidort_linmodin_ptr
boost::shared_ptr< Lidort_Modified_Lininputs > & lidort_linmodin_ptr()
Definition: lidort_interface_masters.h:743
FullPhysics::lidort_fixed_lininputs_c_copy
void lidort_fixed_lininputs_c_copy(void **fortran_type_c_from, void **fortran_type_c_to)
FullPhysics::lcs_masters_write_wrap
void lcs_masters_write_wrap(const char *filename, const int *filename_len, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in, void **lidort_linfixin_in, void **lidort_linmodin_in, void **lidort_linsup_in, void **lidort_linout_in)
FullPhysics::Lidort_Lps_Masters::lidort_linfixin
const Lidort_Fixed_Lininputs & lidort_linfixin() const
Definition: lidort_interface_masters.h:719
FullPhysics::Brdf_Linsup_Masters::brdf_sup_in
const Brdf_Sup_Inputs & brdf_sup_in() const
Definition: lidort_interface_masters.h:45
FullPhysics::Lidort_Masters::lidort_fixin
void lidort_fixin(Lidort_Fixed_Inputs &lidort_fixin_in)
Definition: lidort_interface_masters.h:1032
FullPhysics::Lidort_Lcs_Masters::lidort_modin
const Lidort_Modified_Inputs & lidort_modin() const
Definition: lidort_interface_masters.h:401
FullPhysics::lps_masters_read_wrap
void lps_masters_read_wrap(const char *filename, const int *filename_len, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in, void **lidort_linfixin_in, void **lidort_linmodin_in, void **lidort_linsup_in, void **lidort_linout_in)
FullPhysics::Lidort_Masters::lidort_out
const Lidort_Outputs & lidort_out() const
Definition: lidort_interface_masters.h:1084
FullPhysics::Brdf_Sup_Masters::brdf_sup_outputstatus
Brdf_Output_Exception_Handling & brdf_sup_outputstatus()
Definition: lidort_interface_masters.h:269
FullPhysics::Brdf_Linsup_Masters::brdf_sup_outputstatus
Brdf_Output_Exception_Handling & brdf_sup_outputstatus()
Definition: lidort_interface_masters.h:111
FullPhysics
Contains classes to abstract away details in various Spurr Radiative Transfer software.
Definition: doxygen_python.h:1
FullPhysics::Lidort_Lcs_Masters::lidort_sup
void lidort_sup(Lidort_Sup_Inout &lidort_sup_in)
Definition: lidort_interface_masters.h:429
FullPhysics::Lidort_Lcs_Masters::lidort_modin
void lidort_modin(Lidort_Modified_Inputs &lidort_modin_in)
Definition: lidort_interface_masters.h:409
FullPhysics::sup_accessories_brdf_input_checker_wrap
void sup_accessories_brdf_input_checker_wrap(void **brdf_sup_in_in, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_brdfcheck_status_in)
FullPhysics::Lidort_Sup_Accessories::operator<<
friend std::ostream & operator<<(std::ostream &output_stream, const Lidort_Sup_Accessories &obj)
Definition: lidort_interface_masters.h:1329
FullPhysics::Lidort_Lcs_Masters::write_fortran_file
void write_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:572
FullPhysics::Lidort_Lps_Masters::lidort_linsup
void lidort_linsup(Lidort_Linsup_Inout &lidort_linsup_in)
Definition: lidort_interface_masters.h:767
FullPhysics::Lidort_Sup_Accessories::brdf_sup_in_ptr
boost::shared_ptr< Brdf_Sup_Inputs > & brdf_sup_in_ptr()
Definition: lidort_interface_masters.h:1214
FullPhysics::Lidort_Lcs_Masters::lidort_linout_ptr
boost::shared_ptr< Lidort_Linoutputs > & lidort_linout_ptr()
Definition: lidort_interface_masters.h:519
FullPhysics::Lidort_Masters::read_fortran_file
void read_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:1119
FullPhysics::Lidort_Sup_Accessories::lidort_fixin
const Lidort_Fixed_Inputs & lidort_fixin() const
Definition: lidort_interface_masters.h:1238
FullPhysics::Brdf_Linsup_Masters::brdf_sup_out_ptr
boost::shared_ptr< Brdf_Sup_Outputs > & brdf_sup_out_ptr()
Definition: lidort_interface_masters.h:91
FullPhysics::Lidort_Inputs::lidort_inputstatus_ptr
boost::shared_ptr< Lidort_Input_Exception_Handling > & lidort_inputstatus_ptr()
Definition: lidort_interface_masters.h:936
FullPhysics::Lidort_Lcs_Masters::lidort_sup_ptr
boost::shared_ptr< Lidort_Sup_Inout > & lidort_sup_ptr()
Definition: lidort_interface_masters.h:425
FullPhysics::sup_accessories_read_wrap
void sup_accessories_read_wrap(const char *filename, const int *filename_len, void **sleave_sup_in_in, void **brdf_sup_in_in, void **brdf_sleavecheck_status_in, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_brdfcheck_status_in)
FullPhysics::Lidort_Masters::lidort_modin
Lidort_Modified_Inputs & lidort_modin()
Definition: lidort_interface_masters.h:1040
FullPhysics::lidort_fixed_inputs_c_copy
void lidort_fixed_inputs_c_copy(void **fortran_type_c_from, void **fortran_type_c_to)
FullPhysics::Lidort_Inputs::lidort_fixin_ptr
boost::shared_ptr< Lidort_Fixed_Inputs > & lidort_fixin_ptr()
Definition: lidort_interface_masters.h:908
FullPhysics::Brdf_Linsup_Masters::brdf_linsup_out
const Brdf_Linsup_Outputs & brdf_linsup_out() const
Definition: lidort_interface_masters.h:101
FullPhysics::Brdf_Linsup_Masters::brdf_sup_inputstatus
Brdf_Input_Exception_Handling & brdf_sup_inputstatus()
Definition: lidort_interface_masters.h:69
FullPhysics::Lidort_Lps_Masters::lidort_sup
void lidort_sup(Lidort_Sup_Inout &lidort_sup_in)
Definition: lidort_interface_masters.h:693
FullPhysics::brdf_sup_masters_m_brdf_mainmaster_wrap
void brdf_sup_masters_m_brdf_mainmaster_wrap(const bool *do_debug_restoration_in, const int *nmoments_input_in, void **brdf_sup_in_in, void **brdf_sup_out_in, void **brdf_sup_outputstatus_in)
FullPhysics::Lidort_Lps_Masters::lidort_linmodin
void lidort_linmodin(Lidort_Modified_Lininputs &lidort_linmodin_in)
Definition: lidort_interface_masters.h:747
FullPhysics::lps_masters_lps_master_wrap
void lps_masters_lps_master_wrap(void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in, void **lidort_linfixin_in, void **lidort_linmodin_in, void **lidort_linsup_in, void **lidort_linout_in)
FullPhysics::Brdf_Sup_Masters::brdf_sup_in
const Brdf_Sup_Inputs & brdf_sup_in() const
Definition: lidort_interface_masters.h:231
FullPhysics::Lidort_Inputs::lidort_modin
Lidort_Modified_Inputs & lidort_modin()
Definition: lidort_interface_masters.h:914
FullPhysics::Lidort_Masters::lidort_sup_ptr
boost::shared_ptr< Lidort_Sup_Inout > & lidort_sup_ptr()
Definition: lidort_interface_masters.h:1068
FullPhysics::Brdf_Linsup_Masters::read_config
void read_config(const std::string &filnam_in)
Definition: lidort_interface_masters.h:126
FullPhysics::Brdf_Sup_Masters::read_config
void read_config(const std::string &filnam_in)
Definition: lidort_interface_masters.h:284
FullPhysics::Lidort_Lps_Masters::write_fortran_file
void write_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:836
FullPhysics::brdf_linsup_masters_m_brdf_lin_inputmaster_wrap
void brdf_linsup_masters_m_brdf_lin_inputmaster_wrap(const int *filnam_in_len, const char *filnam_in, void **brdf_sup_in_in, void **brdf_linsup_in_in, void **brdf_sup_inputstatus_in)
FullPhysics::Lidort_Masters::lidort_out_ptr
boost::shared_ptr< Lidort_Outputs > & lidort_out_ptr()
Definition: lidort_interface_masters.h:1088
FullPhysics::Lidort_Sup_Accessories::lidort_brdfcheck_status
const Lidort_Exception_Handling & lidort_brdfcheck_status() const
Definition: lidort_interface_masters.h:1266
FullPhysics::Lidort_Lps_Masters::lidort_linmodin
Lidort_Modified_Lininputs & lidort_linmodin()
Definition: lidort_interface_masters.h:735
FullPhysics::Brdf_Linsup_Masters::write_fortran_file
void write_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:167
FullPhysics::Lidort_Lcs_Masters::lidort_out
const Lidort_Outputs & lidort_out() const
Definition: lidort_interface_masters.h:441
FullPhysics::Lidort_Sup_Accessories::brdf_sup_in
const Brdf_Sup_Inputs & brdf_sup_in() const
Definition: lidort_interface_masters.h:1210
FullPhysics::Lidort_Sup_Accessories::read_fortran_file
void read_fortran_file(const std::string &filename_in)
Definition: lidort_interface_masters.h:1299
FullPhysics::brdf_linsup_masters_m_brdf_lin_mainmaster_wrap
void brdf_linsup_masters_m_brdf_lin_mainmaster_wrap(const bool *do_debug_restoration_in, const int *nmoments_input_in, void **brdf_sup_in_in, void **brdf_linsup_in_in, void **brdf_sup_out_in, void **brdf_linsup_out_in, void **brdf_sup_outputstatus_in)
FullPhysics::Brdf_Linsup_Masters::brdf_linsup_out_ptr
boost::shared_ptr< Brdf_Linsup_Outputs > & brdf_linsup_out_ptr()
Definition: lidort_interface_masters.h:105
FullPhysics::Brdf_Linsup_Masters::brdf_linsup_in
const Brdf_Linsup_Inputs & brdf_linsup_in() const
Definition: lidort_interface_masters.h:59
FullPhysics::lidort_modified_inputs_c_copy
void lidort_modified_inputs_c_copy(void **fortran_type_c_from, void **fortran_type_c_to)
FullPhysics::brdf_sup_masters_m_read_wrap
void brdf_sup_masters_m_read_wrap(const char *filename, const int *filename_len, void **brdf_sup_in_in, void **brdf_sup_inputstatus_in, void **brdf_sup_out_in, void **brdf_sup_outputstatus_in)
FullPhysics::Lidort_Lps_Masters::lidort_linsup_ptr
boost::shared_ptr< Lidort_Linsup_Inout > & lidort_linsup_ptr()
Definition: lidort_interface_masters.h:763
FullPhysics::Lidort_Sup_Accessories::brdf_sleavecheck_status
Lidort_Exception_Handling & brdf_sleavecheck_status()
Definition: lidort_interface_masters.h:1220
FullPhysics::Brdf_Linsup_Masters::brdf_sup_inputstatus_ptr
boost::shared_ptr< Brdf_Input_Exception_Handling > & brdf_sup_inputstatus_ptr()
Definition: lidort_interface_masters.h:77
FullPhysics::Lidort_Inputs::operator<<
friend std::ostream & operator<<(std::ostream &output_stream, const Lidort_Inputs &obj)
Definition: lidort_interface_masters.h:981
FullPhysics::lps_masters_write_wrap
void lps_masters_write_wrap(const char *filename, const int *filename_len, void **lidort_fixin_in, void **lidort_modin_in, void **lidort_sup_in, void **lidort_out_in, void **lidort_linfixin_in, void **lidort_linmodin_in, void **lidort_linsup_in, void **lidort_linout_in)
FullPhysics::lidort_modified_lininputs_c_copy
void lidort_modified_lininputs_c_copy(void **fortran_type_c_from, void **fortran_type_c_to)
FullPhysics::Lidort_Lps_Masters::lidort_linout
const Lidort_Linoutputs & lidort_linout() const
Definition: lidort_interface_masters.h:779
Copyright © 2017, California Institute of Technology.
ALL RIGHTS RESERVED.
U.S. Government Sponsorship acknowledged.
Generated Fri Aug 24 2018 15:44:09