00001
00002
00003
00004
00005 #include "arts.h"
00006 #include "make_array.h"
00007 #include "auto_md.h"
00008 #include "auto_wsv_groups.h"
00009 #include "wsv_aux.h"
00010
00011
00012 extern const Array<WsvP*> wsv_pointers;
00013
00014
00015 extern const Array<WsvRecord> wsv_data;
00016
00017 void Echo_g(WorkSpace&, const MRecord& mr)
00018 {
00019 Echo(mr.Values()[0],
00020 mr.Values()[1]);
00021 }
00022
00023 void Exit_g(WorkSpace&, const MRecord&)
00024 {
00025 Exit();
00026 }
00027
00028 void Test_g(WorkSpace&, const MRecord&)
00029 {
00030 Test();
00031 }
00032
00033 void IndexSet_g(WorkSpace&, const MRecord& mr)
00034 {
00035 Index *GO0 = *wsv_pointers[mr.Output()[0]];
00036 IndexSet(*GO0,
00037 wsv_data[mr.Output()[0]].Name(),
00038 mr.Values()[0]);
00039 }
00040
00041 void IndexWriteAscii_g(WorkSpace&, const MRecord& mr)
00042 {
00043 Index *GI0 = *wsv_pointers[mr.Input()[0]];
00044 IndexWriteAscii(*GI0,
00045 wsv_data[mr.Input()[0]].Name(),
00046 mr.Values()[0]);
00047 }
00048
00049 void IndexReadAscii_g(WorkSpace&, const MRecord& mr)
00050 {
00051 Index *GO0 = *wsv_pointers[mr.Output()[0]];
00052 IndexReadAscii(*GO0,
00053 wsv_data[mr.Output()[0]].Name(),
00054 mr.Values()[0]);
00055 }
00056
00057 void IndexWriteBinary_g(WorkSpace&, const MRecord& mr)
00058 {
00059 Index *GI0 = *wsv_pointers[mr.Input()[0]];
00060 IndexWriteBinary(*GI0,
00061 wsv_data[mr.Input()[0]].Name(),
00062 mr.Values()[0]);
00063 }
00064
00065 void IndexReadBinary_g(WorkSpace&, const MRecord& mr)
00066 {
00067 Index *GO0 = *wsv_pointers[mr.Output()[0]];
00068 IndexReadBinary(*GO0,
00069 wsv_data[mr.Output()[0]].Name(),
00070 mr.Values()[0]);
00071 }
00072
00073 void NumericSet_g(WorkSpace&, const MRecord& mr)
00074 {
00075 Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
00076 NumericSet(*GO0,
00077 wsv_data[mr.Output()[0]].Name(),
00078 mr.Values()[0]);
00079 }
00080
00081 void NumericCopyFirstOfVector_g(WorkSpace&, const MRecord& mr)
00082 {
00083 Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
00084 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00085 NumericCopyFirstOfVector(*GO0,
00086 wsv_data[mr.Output()[0]].Name(),
00087 *GI0,
00088 wsv_data[mr.Input()[0]].Name());
00089 }
00090
00091 void NumericCopyLastOfVector_g(WorkSpace&, const MRecord& mr)
00092 {
00093 Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
00094 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00095 NumericCopyLastOfVector(*GO0,
00096 wsv_data[mr.Output()[0]].Name(),
00097 *GI0,
00098 wsv_data[mr.Input()[0]].Name());
00099 }
00100
00101 void NumericWriteAscii_g(WorkSpace&, const MRecord& mr)
00102 {
00103 Numeric *GI0 = *wsv_pointers[mr.Input()[0]];
00104 NumericWriteAscii(*GI0,
00105 wsv_data[mr.Input()[0]].Name(),
00106 mr.Values()[0]);
00107 }
00108
00109 void NumericReadAscii_g(WorkSpace&, const MRecord& mr)
00110 {
00111 Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
00112 NumericReadAscii(*GO0,
00113 wsv_data[mr.Output()[0]].Name(),
00114 mr.Values()[0]);
00115 }
00116
00117 void NumericWriteBinary_g(WorkSpace&, const MRecord& mr)
00118 {
00119 Numeric *GI0 = *wsv_pointers[mr.Input()[0]];
00120 NumericWriteBinary(*GI0,
00121 wsv_data[mr.Input()[0]].Name(),
00122 mr.Values()[0]);
00123 }
00124
00125 void NumericReadBinary_g(WorkSpace&, const MRecord& mr)
00126 {
00127 Numeric *GO0 = *wsv_pointers[mr.Output()[0]];
00128 NumericReadBinary(*GO0,
00129 wsv_data[mr.Output()[0]].Name(),
00130 mr.Values()[0]);
00131 }
00132
00133 void VectorCopy_g(WorkSpace&, const MRecord& mr)
00134 {
00135 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00136 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00137 VectorCopy(*GO0,
00138 wsv_data[mr.Output()[0]].Name(),
00139 *GI0,
00140 wsv_data[mr.Input()[0]].Name());
00141 }
00142
00143 void VectorCopyFromMatrix_g(WorkSpace&, const MRecord& mr)
00144 {
00145 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00146 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00147 VectorCopyFromMatrix(*GO0,
00148 wsv_data[mr.Output()[0]].Name(),
00149 *GI0,
00150 wsv_data[mr.Input()[0]].Name(),
00151 mr.Values()[0],
00152 mr.Values()[1]);
00153 }
00154
00155 void VectorSet_g(WorkSpace&, const MRecord& mr)
00156 {
00157 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00158 VectorSet(*GO0,
00159 wsv_data[mr.Output()[0]].Name(),
00160 mr.Values()[0],
00161 mr.Values()[1]);
00162 }
00163
00164 void VectorSetLengthFromVector_g(WorkSpace&, const MRecord& mr)
00165 {
00166 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00167 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00168 VectorSetLengthFromVector(*GO0,
00169 wsv_data[mr.Output()[0]].Name(),
00170 *GI0,
00171 wsv_data[mr.Input()[0]].Name(),
00172 mr.Values()[0]);
00173 }
00174
00175 void VectorLinSpace_g(WorkSpace&, const MRecord& mr)
00176 {
00177 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00178 VectorLinSpace(*GO0,
00179 wsv_data[mr.Output()[0]].Name(),
00180 mr.Values()[0],
00181 mr.Values()[1],
00182 mr.Values()[2]);
00183 }
00184
00185 void VectorNLinSpace_g(WorkSpace&, const MRecord& mr)
00186 {
00187 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00188 VectorNLinSpace(*GO0,
00189 wsv_data[mr.Output()[0]].Name(),
00190 mr.Values()[0],
00191 mr.Values()[1],
00192 mr.Values()[2]);
00193 }
00194
00195 void VectorNLogSpace_g(WorkSpace&, const MRecord& mr)
00196 {
00197 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00198 VectorNLogSpace(*GO0,
00199 wsv_data[mr.Output()[0]].Name(),
00200 mr.Values()[0],
00201 mr.Values()[1],
00202 mr.Values()[2]);
00203 }
00204
00205 void VectorPressuresForLinAltitudes_g(WorkSpace& ws, const MRecord& mr)
00206 {
00207 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00208 VectorPressuresForLinAltitudes(*GO0,
00209 wsv_data[mr.Output()[0]].Name(),
00210 ws.p_abs,
00211 ws.z_abs,
00212 mr.Values()[0],
00213 mr.Values()[1],
00214 mr.Values()[2]);
00215 }
00216
00217 void VectorFlip_g(WorkSpace&, const MRecord& mr)
00218 {
00219 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00220 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00221 VectorFlip(*GO0,
00222 wsv_data[mr.Output()[0]].Name(),
00223 *GI0,
00224 wsv_data[mr.Input()[0]].Name());
00225 }
00226
00227 void VectorMatrixMultiply_g(WorkSpace&, const MRecord& mr)
00228 {
00229 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00230 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00231 Vector *GI1 = *wsv_pointers[mr.Input()[1]];
00232 VectorMatrixMultiply(*GO0,
00233 wsv_data[mr.Output()[0]].Name(),
00234 *GI0,
00235 *GI1,
00236 wsv_data[mr.Input()[0]].Name(),
00237 wsv_data[mr.Input()[1]].Name());
00238 }
00239
00240 void VectorWriteAscii_g(WorkSpace&, const MRecord& mr)
00241 {
00242 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00243 VectorWriteAscii(*GI0,
00244 wsv_data[mr.Input()[0]].Name(),
00245 mr.Values()[0]);
00246 }
00247
00248 void VectorReadAscii_g(WorkSpace&, const MRecord& mr)
00249 {
00250 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00251 VectorReadAscii(*GO0,
00252 wsv_data[mr.Output()[0]].Name(),
00253 mr.Values()[0]);
00254 }
00255
00256 void VectorWriteBinary_g(WorkSpace&, const MRecord& mr)
00257 {
00258 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00259 VectorWriteBinary(*GI0,
00260 wsv_data[mr.Input()[0]].Name(),
00261 mr.Values()[0]);
00262 }
00263
00264 void VectorReadBinary_g(WorkSpace&, const MRecord& mr)
00265 {
00266 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00267 VectorReadBinary(*GO0,
00268 wsv_data[mr.Output()[0]].Name(),
00269 mr.Values()[0]);
00270 }
00271
00272 void VectorPlanck_g(WorkSpace&, const MRecord& mr)
00273 {
00274 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00275 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00276 VectorPlanck(*GO0,
00277 wsv_data[mr.Output()[0]].Name(),
00278 *GI0,
00279 wsv_data[mr.Input()[0]].Name(),
00280 mr.Values()[0]);
00281 }
00282
00283 void VectorCalcLog10_g(WorkSpace&, const MRecord& mr)
00284 {
00285 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00286 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00287 VectorCalcLog10(*GO0,
00288 wsv_data[mr.Output()[0]].Name(),
00289 *GI0,
00290 wsv_data[mr.Input()[0]].Name());
00291 }
00292
00293 void VectorAdd_g(WorkSpace&, const MRecord& mr)
00294 {
00295 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00296 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00297 VectorAdd(*GO0,
00298 wsv_data[mr.Output()[0]].Name(),
00299 *GI0,
00300 wsv_data[mr.Input()[0]].Name(),
00301 mr.Values()[0]);
00302 }
00303
00304 void VectorScale_g(WorkSpace&, const MRecord& mr)
00305 {
00306 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
00307 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00308 VectorScale(*GO0,
00309 wsv_data[mr.Output()[0]].Name(),
00310 *GI0,
00311 wsv_data[mr.Input()[0]].Name(),
00312 mr.Values()[0]);
00313 }
00314
00315 void MatrixSet_g(WorkSpace&, const MRecord& mr)
00316 {
00317 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00318 MatrixSet(*GO0,
00319 wsv_data[mr.Output()[0]].Name(),
00320 mr.Values()[0],
00321 mr.Values()[1],
00322 mr.Values()[2]);
00323 }
00324
00325 void MatrixCopy_g(WorkSpace&, const MRecord& mr)
00326 {
00327 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00328 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00329 MatrixCopy(*GO0,
00330 wsv_data[mr.Output()[0]].Name(),
00331 *GI0,
00332 wsv_data[mr.Input()[0]].Name());
00333 }
00334
00335 void MatrixFillWithVector_g(WorkSpace&, const MRecord& mr)
00336 {
00337 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00338 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
00339 MatrixFillWithVector(*GO0,
00340 wsv_data[mr.Output()[0]].Name(),
00341 *GI0,
00342 wsv_data[mr.Input()[0]].Name(),
00343 mr.Values()[0]);
00344 }
00345
00346 void MatrixMatrixMultiply_g(WorkSpace&, const MRecord& mr)
00347 {
00348 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00349 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00350 Matrix *GI1 = *wsv_pointers[mr.Input()[1]];
00351 MatrixMatrixMultiply(*GO0,
00352 wsv_data[mr.Output()[0]].Name(),
00353 *GI0,
00354 *GI1,
00355 wsv_data[mr.Input()[0]].Name(),
00356 wsv_data[mr.Input()[1]].Name());
00357 }
00358
00359 void ArrayOfMatrixMatrixMultiply_g(WorkSpace&, const MRecord& mr)
00360 {
00361 ArrayOfMatrix *GO0 = *wsv_pointers[mr.Output()[0]];
00362 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00363 ArrayOfMatrix *GI1 = *wsv_pointers[mr.Input()[1]];
00364 ArrayOfMatrixMatrixMultiply(*GO0,
00365 wsv_data[mr.Output()[0]].Name(),
00366 *GI0,
00367 *GI1,
00368 wsv_data[mr.Input()[0]].Name(),
00369 wsv_data[mr.Input()[1]].Name());
00370 }
00371
00372 void MatrixMatrixAdd_g(WorkSpace&, const MRecord& mr)
00373 {
00374 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00375 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00376 Matrix *GI1 = *wsv_pointers[mr.Input()[1]];
00377 MatrixMatrixAdd(*GO0,
00378 wsv_data[mr.Output()[0]].Name(),
00379 *GI0,
00380 *GI1,
00381 wsv_data[mr.Input()[0]].Name(),
00382 wsv_data[mr.Input()[1]].Name());
00383 }
00384
00385 void MatrixWriteAscii_g(WorkSpace&, const MRecord& mr)
00386 {
00387 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00388 MatrixWriteAscii(*GI0,
00389 wsv_data[mr.Input()[0]].Name(),
00390 mr.Values()[0]);
00391 }
00392
00393 void MatrixReadAscii_g(WorkSpace&, const MRecord& mr)
00394 {
00395 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00396 MatrixReadAscii(*GO0,
00397 wsv_data[mr.Output()[0]].Name(),
00398 mr.Values()[0]);
00399 }
00400
00401 void MatrixWriteBinary_g(WorkSpace&, const MRecord& mr)
00402 {
00403 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00404 MatrixWriteBinary(*GI0,
00405 wsv_data[mr.Input()[0]].Name(),
00406 mr.Values()[0]);
00407 }
00408
00409 void MatrixReadBinary_g(WorkSpace&, const MRecord& mr)
00410 {
00411 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00412 MatrixReadBinary(*GO0,
00413 wsv_data[mr.Output()[0]].Name(),
00414 mr.Values()[0]);
00415 }
00416
00417 void MatrixScale_g(WorkSpace&, const MRecord& mr)
00418 {
00419 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00420 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
00421 MatrixScale(*GO0,
00422 wsv_data[mr.Output()[0]].Name(),
00423 *GI0,
00424 wsv_data[mr.Input()[0]].Name(),
00425 mr.Values()[0]);
00426 }
00427
00428 void MatrixDiagonal_g(WorkSpace&, const MRecord& mr)
00429 {
00430 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
00431 MatrixDiagonal(*GO0,
00432 wsv_data[mr.Output()[0]].Name(),
00433 mr.Values()[0],
00434 mr.Values()[1]);
00435 }
00436
00437 void ArrayOfIndexWriteAscii_g(WorkSpace&, const MRecord& mr)
00438 {
00439 ArrayOfIndex *GI0 = *wsv_pointers[mr.Input()[0]];
00440 ArrayOfIndexWriteAscii(*GI0,
00441 wsv_data[mr.Input()[0]].Name(),
00442 mr.Values()[0]);
00443 }
00444
00445 void ArrayOfIndexReadAscii_g(WorkSpace&, const MRecord& mr)
00446 {
00447 ArrayOfIndex *GO0 = *wsv_pointers[mr.Output()[0]];
00448 ArrayOfIndexReadAscii(*GO0,
00449 wsv_data[mr.Output()[0]].Name(),
00450 mr.Values()[0]);
00451 }
00452
00453 void ArrayOfIndexWriteBinary_g(WorkSpace&, const MRecord& mr)
00454 {
00455 ArrayOfIndex *GI0 = *wsv_pointers[mr.Input()[0]];
00456 ArrayOfIndexWriteBinary(*GI0,
00457 wsv_data[mr.Input()[0]].Name(),
00458 mr.Values()[0]);
00459 }
00460
00461 void ArrayOfIndexReadBinary_g(WorkSpace&, const MRecord& mr)
00462 {
00463 ArrayOfIndex *GO0 = *wsv_pointers[mr.Output()[0]];
00464 ArrayOfIndexReadBinary(*GO0,
00465 wsv_data[mr.Output()[0]].Name(),
00466 mr.Values()[0]);
00467 }
00468
00469 void ArrayOfVectorWriteAscii_g(WorkSpace&, const MRecord& mr)
00470 {
00471 ArrayOfVector *GI0 = *wsv_pointers[mr.Input()[0]];
00472 ArrayOfVectorWriteAscii(*GI0,
00473 wsv_data[mr.Input()[0]].Name(),
00474 mr.Values()[0]);
00475 }
00476
00477 void ArrayOfVectorReadAscii_g(WorkSpace&, const MRecord& mr)
00478 {
00479 ArrayOfVector *GO0 = *wsv_pointers[mr.Output()[0]];
00480 ArrayOfVectorReadAscii(*GO0,
00481 wsv_data[mr.Output()[0]].Name(),
00482 mr.Values()[0]);
00483 }
00484
00485 void ArrayOfVectorWriteBinary_g(WorkSpace&, const MRecord& mr)
00486 {
00487 ArrayOfVector *GI0 = *wsv_pointers[mr.Input()[0]];
00488 ArrayOfVectorWriteBinary(*GI0,
00489 wsv_data[mr.Input()[0]].Name(),
00490 mr.Values()[0]);
00491 }
00492
00493 void ArrayOfVectorReadBinary_g(WorkSpace&, const MRecord& mr)
00494 {
00495 ArrayOfVector *GO0 = *wsv_pointers[mr.Output()[0]];
00496 ArrayOfVectorReadBinary(*GO0,
00497 wsv_data[mr.Output()[0]].Name(),
00498 mr.Values()[0]);
00499 }
00500
00501 void ArrayOfMatrixWriteAscii_g(WorkSpace&, const MRecord& mr)
00502 {
00503 ArrayOfMatrix *GI0 = *wsv_pointers[mr.Input()[0]];
00504 ArrayOfMatrixWriteAscii(*GI0,
00505 wsv_data[mr.Input()[0]].Name(),
00506 mr.Values()[0]);
00507 }
00508
00509 void ArrayOfMatrixReadAscii_g(WorkSpace&, const MRecord& mr)
00510 {
00511 ArrayOfMatrix *GO0 = *wsv_pointers[mr.Output()[0]];
00512 ArrayOfMatrixReadAscii(*GO0,
00513 wsv_data[mr.Output()[0]].Name(),
00514 mr.Values()[0]);
00515 }
00516
00517 void ArrayOfMatrixWriteBinary_g(WorkSpace&, const MRecord& mr)
00518 {
00519 ArrayOfMatrix *GI0 = *wsv_pointers[mr.Input()[0]];
00520 ArrayOfMatrixWriteBinary(*GI0,
00521 wsv_data[mr.Input()[0]].Name(),
00522 mr.Values()[0]);
00523 }
00524
00525 void ArrayOfMatrixReadBinary_g(WorkSpace&, const MRecord& mr)
00526 {
00527 ArrayOfMatrix *GO0 = *wsv_pointers[mr.Output()[0]];
00528 ArrayOfMatrixReadBinary(*GO0,
00529 wsv_data[mr.Output()[0]].Name(),
00530 mr.Values()[0]);
00531 }
00532
00533 void StringSet_g(WorkSpace&, const MRecord& mr)
00534 {
00535 String *GO0 = *wsv_pointers[mr.Output()[0]];
00536 StringSet(*GO0,
00537 wsv_data[mr.Output()[0]].Name(),
00538 mr.Values()[0]);
00539 }
00540
00541 void StringWriteAscii_g(WorkSpace&, const MRecord& mr)
00542 {
00543 String *GI0 = *wsv_pointers[mr.Input()[0]];
00544 StringWriteAscii(*GI0,
00545 wsv_data[mr.Input()[0]].Name(),
00546 mr.Values()[0]);
00547 }
00548
00549 void StringReadAscii_g(WorkSpace&, const MRecord& mr)
00550 {
00551 String *GO0 = *wsv_pointers[mr.Output()[0]];
00552 StringReadAscii(*GO0,
00553 wsv_data[mr.Output()[0]].Name(),
00554 mr.Values()[0]);
00555 }
00556
00557 void StringWriteBinary_g(WorkSpace&, const MRecord& mr)
00558 {
00559 String *GI0 = *wsv_pointers[mr.Input()[0]];
00560 StringWriteBinary(*GI0,
00561 wsv_data[mr.Input()[0]].Name(),
00562 mr.Values()[0]);
00563 }
00564
00565 void StringReadBinary_g(WorkSpace&, const MRecord& mr)
00566 {
00567 String *GO0 = *wsv_pointers[mr.Output()[0]];
00568 StringReadBinary(*GO0,
00569 wsv_data[mr.Output()[0]].Name(),
00570 mr.Values()[0]);
00571 }
00572
00573 void ArrayOfStringSet_g(WorkSpace&, const MRecord& mr)
00574 {
00575 ArrayOfString *GO0 = *wsv_pointers[mr.Output()[0]];
00576 ArrayOfStringSet(*GO0,
00577 wsv_data[mr.Output()[0]].Name(),
00578 mr.Values()[0]);
00579 }
00580
00581 void ArrayOfStringWriteAscii_g(WorkSpace&, const MRecord& mr)
00582 {
00583 ArrayOfString *GI0 = *wsv_pointers[mr.Input()[0]];
00584 ArrayOfStringWriteAscii(*GI0,
00585 wsv_data[mr.Input()[0]].Name(),
00586 mr.Values()[0]);
00587 }
00588
00589 void ArrayOfStringReadAscii_g(WorkSpace&, const MRecord& mr)
00590 {
00591 ArrayOfString *GO0 = *wsv_pointers[mr.Output()[0]];
00592 ArrayOfStringReadAscii(*GO0,
00593 wsv_data[mr.Output()[0]].Name(),
00594 mr.Values()[0]);
00595 }
00596
00597 void ArrayOfStringWriteBinary_g(WorkSpace&, const MRecord& mr)
00598 {
00599 ArrayOfString *GI0 = *wsv_pointers[mr.Input()[0]];
00600 ArrayOfStringWriteBinary(*GI0,
00601 wsv_data[mr.Input()[0]].Name(),
00602 mr.Values()[0]);
00603 }
00604
00605 void ArrayOfStringReadBinary_g(WorkSpace&, const MRecord& mr)
00606 {
00607 ArrayOfString *GO0 = *wsv_pointers[mr.Output()[0]];
00608 ArrayOfStringReadBinary(*GO0,
00609 wsv_data[mr.Output()[0]].Name(),
00610 mr.Values()[0]);
00611 }
00612
00613 void TagGroupsSpeciesWriteAscii_g(WorkSpace&, const MRecord& mr)
00614 {
00615 TagGroups *GI0 = *wsv_pointers[mr.Input()[0]];
00616 TagGroupsSpeciesWriteAscii(*GI0,
00617 wsv_data[mr.Input()[0]].Name(),
00618 mr.Values()[0]);
00619 }
00620
00621 void LosWriteBinary_g(WorkSpace&, const MRecord& mr)
00622 {
00623 Los *GI0 = *wsv_pointers[mr.Input()[0]];
00624 LosWriteBinary(*GI0,
00625 wsv_data[mr.Input()[0]].Name(),
00626 mr.Values()[0]);
00627 }
00628
00629 void LosReadBinary_g(WorkSpace&, const MRecord& mr)
00630 {
00631 Los *GO0 = *wsv_pointers[mr.Output()[0]];
00632 LosReadBinary(*GO0,
00633 wsv_data[mr.Output()[0]].Name(),
00634 mr.Values()[0]);
00635 }
00636
00637 void lines_per_tgSetEmpty_g(WorkSpace& ws, const MRecord&)
00638 {
00639 lines_per_tgSetEmpty(ws.lines_per_tg,
00640 ws.tgs);
00641 }
00642
00643 void lines_per_tgReadFromCatalogues_g(WorkSpace& ws, const MRecord& mr)
00644 {
00645 lines_per_tgReadFromCatalogues(ws.lines_per_tg,
00646 ws.tgs,
00647 mr.Values()[0],
00648 mr.Values()[1],
00649 mr.Values()[2],
00650 mr.Values()[3]);
00651 }
00652
00653 void linesReadFromHitran_g(WorkSpace& ws, const MRecord& mr)
00654 {
00655 linesReadFromHitran(ws.lines,
00656 mr.Values()[0],
00657 mr.Values()[1],
00658 mr.Values()[2]);
00659 }
00660
00661 void linesReadFromHitran2004_g(WorkSpace& ws, const MRecord& mr)
00662 {
00663 linesReadFromHitran2004(ws.lines,
00664 mr.Values()[0],
00665 mr.Values()[1],
00666 mr.Values()[2]);
00667 }
00668
00669 void linesReadFromMytran2_g(WorkSpace& ws, const MRecord& mr)
00670 {
00671 linesReadFromMytran2(ws.lines,
00672 mr.Values()[0],
00673 mr.Values()[1],
00674 mr.Values()[2]);
00675 }
00676
00677 void linesReadFromJpl_g(WorkSpace& ws, const MRecord& mr)
00678 {
00679 linesReadFromJpl(ws.lines,
00680 mr.Values()[0],
00681 mr.Values()[1],
00682 mr.Values()[2]);
00683 }
00684
00685 void linesReadFromArts_g(WorkSpace& ws, const MRecord& mr)
00686 {
00687 linesReadFromArts(ws.lines,
00688 mr.Values()[0],
00689 mr.Values()[1],
00690 mr.Values()[2]);
00691 }
00692
00693 void linesElowToJoule_g(WorkSpace& ws, const MRecord&)
00694 {
00695 linesElowToJoule(ws.lines);
00696 }
00697
00698 void lines_per_tgCreateFromLines_g(WorkSpace& ws, const MRecord&)
00699 {
00700 lines_per_tgCreateFromLines(ws.lines_per_tg,
00701 ws.lines,
00702 ws.tgs);
00703 }
00704
00705 void lines_per_tgAddMirrorLines_g(WorkSpace& ws, const MRecord&)
00706 {
00707 lines_per_tgAddMirrorLines(ws.lines_per_tg);
00708 }
00709
00710 void lines_per_tgCompact_g(WorkSpace& ws, const MRecord&)
00711 {
00712 lines_per_tgCompact(ws.lines_per_tg,
00713 ws.lineshape,
00714 ws.f_mono);
00715 }
00716
00717 void linesWriteAscii_g(WorkSpace& ws, const MRecord& mr)
00718 {
00719 linesWriteAscii(ws.lines,
00720 mr.Values()[0]);
00721 }
00722
00723 void lines_per_tgWriteAscii_g(WorkSpace& ws, const MRecord& mr)
00724 {
00725 lines_per_tgWriteAscii(ws.lines_per_tg,
00726 mr.Values()[0]);
00727 }
00728
00729 void tgsDefine_g(WorkSpace& ws, const MRecord& mr)
00730 {
00731 tgsDefine(ws.tgs,
00732 mr.Values()[0]);
00733 }
00734
00735 void tgsDefineAllInScenario_g(WorkSpace& ws, const MRecord& mr)
00736 {
00737 tgsDefineAllInScenario(ws.tgs,
00738 mr.Values()[0]);
00739 }
00740
00741 void lineshapeDefine_g(WorkSpace& ws, const MRecord& mr)
00742 {
00743 lineshapeDefine(ws.lineshape,
00744 ws.tgs,
00745 mr.Values()[0],
00746 mr.Values()[1],
00747 mr.Values()[2]);
00748 }
00749
00750 void lineshape_per_tgDefine_g(WorkSpace& ws, const MRecord& mr)
00751 {
00752 lineshape_per_tgDefine(ws.lineshape,
00753 ws.tgs,
00754 mr.Values()[0],
00755 mr.Values()[1],
00756 mr.Values()[2]);
00757 }
00758
00759 void cont_descriptionInit_g(WorkSpace& ws, const MRecord&)
00760 {
00761 cont_descriptionInit(ws.cont_description_names,
00762 ws.cont_description_models,
00763 ws.cont_description_parameters);
00764 }
00765
00766 void cont_descriptionAppend_g(WorkSpace& ws, const MRecord& mr)
00767 {
00768 cont_descriptionAppend(ws.cont_description_names,
00769 ws.cont_description_models,
00770 ws.cont_description_parameters,
00771 mr.Values()[0],
00772 mr.Values()[1],
00773 mr.Values()[2]);
00774 }
00775
00776 void raw_vmrsReadFromFiles_g(WorkSpace& ws, const MRecord& mr)
00777 {
00778 raw_vmrsReadFromFiles(ws.raw_vmrs,
00779 ws.tgs,
00780 mr.Values()[0],
00781 mr.Values()[1],
00782 mr.Values()[2]);
00783 }
00784
00785 void raw_vmrsReadFromScenario_g(WorkSpace& ws, const MRecord& mr)
00786 {
00787 raw_vmrsReadFromScenario(ws.raw_vmrs,
00788 ws.tgs,
00789 mr.Values()[0]);
00790 }
00791
00792 void AtmFromRaw_g(WorkSpace& ws, const MRecord&)
00793 {
00794 AtmFromRaw(ws.t_abs,
00795 ws.z_abs,
00796 ws.vmrs,
00797 ws.tgs,
00798 ws.p_abs,
00799 ws.raw_ptz,
00800 ws.raw_vmrs);
00801 }
00802
00803 void WaterVaporSaturationInClouds_g(WorkSpace& ws, const MRecord&)
00804 {
00805 WaterVaporSaturationInClouds(ws.vmrs,
00806 ws.p_abs,
00807 ws.t_abs,
00808 ws.tgs);
00809 }
00810
00811 void vmrsScale_g(WorkSpace& ws, const MRecord& mr)
00812 {
00813 vmrsScale(ws.vmrs,
00814 ws.tgs,
00815 mr.Values()[0],
00816 mr.Values()[1]);
00817 }
00818
00819 void h2o_absSet_g(WorkSpace& ws, const MRecord&)
00820 {
00821 h2o_absSet(ws.h2o_abs,
00822 ws.tgs,
00823 ws.vmrs);
00824 }
00825
00826 void n2_absSet_g(WorkSpace& ws, const MRecord&)
00827 {
00828 n2_absSet(ws.n2_abs,
00829 ws.tgs,
00830 ws.vmrs);
00831 }
00832
00833 void hseSet_g(WorkSpace& ws, const MRecord& mr)
00834 {
00835 hseSet(ws.hse,
00836 mr.Values()[0],
00837 mr.Values()[1],
00838 mr.Values()[2],
00839 mr.Values()[3]);
00840 }
00841
00842 void hseSetFromLatitude_g(WorkSpace& ws, const MRecord& mr)
00843 {
00844 hseSetFromLatitude(ws.hse,
00845 mr.Values()[0],
00846 mr.Values()[1],
00847 mr.Values()[2],
00848 mr.Values()[3]);
00849 }
00850
00851 void hseSetFromLatitudeIndex_g(WorkSpace& ws, const MRecord& mr)
00852 {
00853 hseSetFromLatitudeIndex(ws.hse,
00854 ws.p_abs,
00855 ws.z_abs,
00856 mr.Values()[0],
00857 mr.Values()[1],
00858 mr.Values()[2]);
00859 }
00860
00861 void hseFromBottom_g(WorkSpace& ws, const MRecord& mr)
00862 {
00863 hseFromBottom(ws.hse,
00864 ws.p_abs,
00865 ws.z_abs,
00866 mr.Values()[0],
00867 mr.Values()[1]);
00868 }
00869
00870 void hseOff_g(WorkSpace& ws, const MRecord&)
00871 {
00872 hseOff(ws.hse);
00873 }
00874
00875 void hseCalc_g(WorkSpace& ws, const MRecord&)
00876 {
00877 hseCalc(ws.z_abs,
00878 ws.p_abs,
00879 ws.t_abs,
00880 ws.h2o_abs,
00881 ws.r_geoid,
00882 ws.hse);
00883 }
00884
00885 void absCalc_g(WorkSpace& ws, const MRecord&)
00886 {
00887 absCalc(ws.abs,
00888 ws.abs_per_tg,
00889 ws.tgs,
00890 ws.f_mono,
00891 ws.p_abs,
00892 ws.t_abs,
00893 ws.n2_abs,
00894 ws.h2o_abs,
00895 ws.vmrs,
00896 ws.lines_per_tg,
00897 ws.lineshape,
00898 ws.cont_description_names,
00899 ws.cont_description_models,
00900 ws.cont_description_parameters);
00901 }
00902
00903 void absCalcSaveMemory_g(WorkSpace& ws, const MRecord&)
00904 {
00905 absCalcSaveMemory(ws.abs,
00906 ws.tgs,
00907 ws.f_mono,
00908 ws.p_abs,
00909 ws.t_abs,
00910 ws.n2_abs,
00911 ws.h2o_abs,
00912 ws.vmrs,
00913 ws.lines_per_tg,
00914 ws.lineshape,
00915 ws.cont_description_names,
00916 ws.cont_description_models,
00917 ws.cont_description_parameters);
00918 }
00919
00920 void absCalcFromXsec_g(WorkSpace& ws, const MRecord&)
00921 {
00922 absCalcFromXsec(ws.abs,
00923 ws.abs_per_tg,
00924 ws.xsec_per_tg,
00925 ws.vmrs);
00926 }
00927
00928 void xsec_per_tgInit_g(WorkSpace& ws, const MRecord&)
00929 {
00930 xsec_per_tgInit(ws.xsec_per_tg,
00931 ws.tgs,
00932 ws.f_mono,
00933 ws.p_abs);
00934 }
00935
00936 void xsec_per_tgAddLines_g(WorkSpace& ws, const MRecord&)
00937 {
00938 xsec_per_tgAddLines(ws.xsec_per_tg,
00939 ws.tgs,
00940 ws.f_mono,
00941 ws.p_abs,
00942 ws.t_abs,
00943 ws.h2o_abs,
00944 ws.vmrs,
00945 ws.lines_per_tg,
00946 ws.lineshape);
00947 }
00948
00949 void xsec_per_tgAddConts_g(WorkSpace& ws, const MRecord&)
00950 {
00951 xsec_per_tgAddConts(ws.xsec_per_tg,
00952 ws.tgs,
00953 ws.f_mono,
00954 ws.p_abs,
00955 ws.t_abs,
00956 ws.n2_abs,
00957 ws.h2o_abs,
00958 ws.vmrs,
00959 ws.cont_description_names,
00960 ws.cont_description_parameters,
00961 ws.cont_description_models);
00962 }
00963
00964 void abs_per_tgReduce_g(WorkSpace& ws, const MRecord&)
00965 {
00966 abs_per_tgReduce(ws.abs_per_tg,
00967 ws.tgs,
00968 ws.wfs_tgs);
00969 }
00970
00971 void refrSet_g(WorkSpace& ws, const MRecord& mr)
00972 {
00973 refrSet(ws.refr,
00974 ws.refr_lfac,
00975 ws.refr_model,
00976 mr.Values()[0],
00977 mr.Values()[1],
00978 mr.Values()[2]);
00979 }
00980
00981 void refrOff_g(WorkSpace& ws, const MRecord&)
00982 {
00983 refrOff(ws.refr,
00984 ws.refr_lfac,
00985 ws.refr_model);
00986 }
00987
00988 void refrCalc_g(WorkSpace& ws, const MRecord&)
00989 {
00990 refrCalc(ws.refr_index,
00991 ws.p_abs,
00992 ws.t_abs,
00993 ws.h2o_abs,
00994 ws.refr,
00995 ws.refr_model);
00996 }
00997
00998 void zaFromZtan_g(WorkSpace& ws, const MRecord& mr)
00999 {
01000 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
01001 zaFromZtan(*GO0,
01002 wsv_data[mr.Output()[0]].Name(),
01003 ws.z_tan,
01004 ws.z_plat,
01005 ws.p_abs,
01006 ws.z_abs,
01007 ws.refr,
01008 ws.refr_index,
01009 ws.r_geoid,
01010 ws.z_ground);
01011 }
01012
01013 void zaFromDeltat_g(WorkSpace& ws, const MRecord& mr)
01014 {
01015 Vector *GO0 = *wsv_pointers[mr.Output()[0]];
01016 zaFromDeltat(*GO0,
01017 wsv_data[mr.Output()[0]].Name(),
01018 ws.z_plat,
01019 ws.p_abs,
01020 ws.z_abs,
01021 ws.l_step,
01022 ws.refr,
01023 ws.refr_lfac,
01024 ws.refr_index,
01025 ws.r_geoid,
01026 ws.z_ground,
01027 mr.Values()[0],
01028 mr.Values()[1]);
01029 }
01030
01031 void r_geoidStd_g(WorkSpace& ws, const MRecord&)
01032 {
01033 r_geoidStd(ws.r_geoid);
01034 }
01035
01036 void r_geoidWGS84_g(WorkSpace& ws, const MRecord& mr)
01037 {
01038 r_geoidWGS84(ws.r_geoid,
01039 mr.Values()[0],
01040 mr.Values()[1]);
01041 }
01042
01043 void groundOff_g(WorkSpace& ws, const MRecord&)
01044 {
01045 groundOff(ws.z_ground,
01046 ws.t_ground,
01047 ws.e_ground,
01048 ws.z_abs);
01049 }
01050
01051 void groundSet_g(WorkSpace& ws, const MRecord& mr)
01052 {
01053 groundSet(ws.z_ground,
01054 ws.t_ground,
01055 ws.e_ground,
01056 ws.p_abs,
01057 ws.t_abs,
01058 ws.z_abs,
01059 ws.f_mono,
01060 mr.Values()[0],
01061 mr.Values()[1]);
01062 }
01063
01064 void groundAtBottom_g(WorkSpace& ws, const MRecord& mr)
01065 {
01066 groundAtBottom(ws.z_ground,
01067 ws.t_ground,
01068 ws.e_ground,
01069 ws.t_abs,
01070 ws.z_abs,
01071 ws.f_mono,
01072 mr.Values()[0]);
01073 }
01074
01075 void groundFlatSea_g(WorkSpace& ws, const MRecord& mr)
01076 {
01077 groundFlatSea(ws.z_ground,
01078 ws.t_ground,
01079 ws.e_ground,
01080 ws.p_abs,
01081 ws.t_abs,
01082 ws.z_abs,
01083 ws.f_mono,
01084 ws.za_pencil,
01085 ws.z_plat,
01086 ws.r_geoid,
01087 ws.refr,
01088 ws.refr_index,
01089 mr.Values()[0],
01090 mr.Values()[1]);
01091 }
01092
01093 void emissionOn_g(WorkSpace& ws, const MRecord&)
01094 {
01095 emissionOn(ws.emission);
01096 }
01097
01098 void emissionOff_g(WorkSpace& ws, const MRecord&)
01099 {
01100 emissionOff(ws.emission);
01101 }
01102
01103 void losCalc_g(WorkSpace& ws, const MRecord&)
01104 {
01105 losCalc(ws.los,
01106 ws.z_tan,
01107 ws.z_plat,
01108 ws.za_pencil,
01109 ws.l_step,
01110 ws.p_abs,
01111 ws.z_abs,
01112 ws.refr,
01113 ws.refr_lfac,
01114 ws.refr_index,
01115 ws.z_ground,
01116 ws.r_geoid);
01117 }
01118
01119 void sourceCalc_g(WorkSpace& ws, const MRecord&)
01120 {
01121 sourceCalc(ws.source,
01122 ws.emission,
01123 ws.los,
01124 ws.p_abs,
01125 ws.t_abs,
01126 ws.f_mono);
01127 }
01128
01129 void transCalc_g(WorkSpace& ws, const MRecord&)
01130 {
01131 transCalc(ws.trans,
01132 ws.los,
01133 ws.p_abs,
01134 ws.abs);
01135 }
01136
01137 void y_spaceStd_g(WorkSpace& ws, const MRecord& mr)
01138 {
01139 y_spaceStd(ws.y_space,
01140 ws.f_mono,
01141 mr.Values()[0]);
01142 }
01143
01144 void yCalc_g(WorkSpace& ws, const MRecord&)
01145 {
01146 yCalc(ws.y,
01147 ws.emission,
01148 ws.los,
01149 ws.f_mono,
01150 ws.y_space,
01151 ws.source,
01152 ws.trans,
01153 ws.e_ground,
01154 ws.t_ground);
01155 }
01156
01157 void sourcetransyCalcSaveMemory_g(WorkSpace& ws, const MRecord& mr)
01158 {
01159 sourcetransyCalcSaveMemory(ws.y,
01160 ws.emission,
01161 ws.los,
01162 ws.p_abs,
01163 ws.t_abs,
01164 ws.f_mono,
01165 ws.abs,
01166 ws.y_space,
01167 ws.e_ground,
01168 ws.t_ground,
01169 mr.Values()[0]);
01170 }
01171
01172 void CoolingRates_g(WorkSpace& ws, const MRecord& mr)
01173 {
01174 CoolingRates(ws.coolrate,
01175 ws.l_step,
01176 ws.p_abs,
01177 ws.z_abs,
01178 ws.t_abs,
01179 ws.f_mono,
01180 ws.abs,
01181 ws.za_pencil,
01182 ws.refr,
01183 ws.refr_lfac,
01184 ws.refr_index,
01185 ws.r_geoid,
01186 ws.z_ground,
01187 ws.e_ground,
01188 ws.t_ground,
01189 ws.p_coolrate,
01190 mr.Values()[0]);
01191 }
01192
01193 void yTB_g(WorkSpace& ws, const MRecord&)
01194 {
01195 yTB(ws.y,
01196 ws.f_mono,
01197 ws.za_pencil);
01198 }
01199
01200 void MatrixTB_g(WorkSpace& ws, const MRecord& mr)
01201 {
01202 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
01203 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
01204 MatrixTB(*GO0,
01205 wsv_data[mr.Output()[0]].Name(),
01206 ws.f_mono,
01207 ws.za_pencil,
01208 *GI0,
01209 wsv_data[mr.Input()[0]].Name());
01210 }
01211
01212 void yTRJ_g(WorkSpace& ws, const MRecord&)
01213 {
01214 yTRJ(ws.y,
01215 ws.f_mono,
01216 ws.za_pencil);
01217 }
01218
01219 void MatrixTRJ_g(WorkSpace& ws, const MRecord& mr)
01220 {
01221 Matrix *GO0 = *wsv_pointers[mr.Output()[0]];
01222 Matrix *GI0 = *wsv_pointers[mr.Input()[0]];
01223 MatrixTRJ(*GO0,
01224 wsv_data[mr.Output()[0]].Name(),
01225 ws.f_mono,
01226 ws.za_pencil,
01227 *GI0,
01228 wsv_data[mr.Input()[0]].Name());
01229 }
01230
01231 void wfs_tgsDefine_g(WorkSpace& ws, const MRecord& mr)
01232 {
01233 wfs_tgsDefine(ws.wfs_tgs,
01234 mr.Values()[0]);
01235 }
01236
01237 void wfss_tgsDefine_g(WorkSpace& ws, const MRecord& mr)
01238 {
01239 wfss_tgsDefine(ws.wfss_tgs,
01240 mr.Values()[0]);
01241 }
01242
01243 void absloswfsCalc_g(WorkSpace& ws, const MRecord&)
01244 {
01245 absloswfsCalc(ws.absloswfs,
01246 ws.emission,
01247 ws.los,
01248 ws.source,
01249 ws.trans,
01250 ws.y,
01251 ws.y_space,
01252 ws.f_mono,
01253 ws.e_ground,
01254 ws.t_ground);
01255 }
01256
01257 void kSpecies_g(WorkSpace& ws, const MRecord& mr)
01258 {
01259 kSpecies(ws.k,
01260 ws.k_names,
01261 ws.k_aux,
01262 ws.los,
01263 ws.absloswfs,
01264 ws.p_abs,
01265 ws.t_abs,
01266 ws.wfs_tgs,
01267 ws.abs_per_tg,
01268 ws.vmrs,
01269 ws.k_grid,
01270 mr.Values()[0]);
01271 }
01272
01273 void kSpeciesSingle_g(WorkSpace& ws, const MRecord& mr)
01274 {
01275 kSpeciesSingle(ws.k,
01276 ws.k_names,
01277 ws.k_aux,
01278 ws.los,
01279 ws.absloswfs,
01280 ws.p_abs,
01281 ws.t_abs,
01282 ws.wfs_tgs,
01283 ws.abs_per_tg,
01284 ws.vmrs,
01285 ws.k_grid,
01286 mr.Values()[0],
01287 mr.Values()[1]);
01288 }
01289
01290 void kContAbs_g(WorkSpace& ws, const MRecord& mr)
01291 {
01292 kContAbs(ws.k,
01293 ws.k_names,
01294 ws.k_aux,
01295 ws.los,
01296 ws.absloswfs,
01297 ws.f_mono,
01298 ws.k_grid,
01299 mr.Values()[0],
01300 mr.Values()[1],
01301 mr.Values()[2],
01302 mr.Values()[3]);
01303 }
01304
01305 void kTemp_g(WorkSpace& ws, const MRecord& mr)
01306 {
01307 kTemp(ws.k,
01308 ws.k_names,
01309 ws.k_aux,
01310 ws.tgs,
01311 ws.f_mono,
01312 ws.p_abs,
01313 ws.t_abs,
01314 ws.n2_abs,
01315 ws.h2o_abs,
01316 ws.vmrs,
01317 ws.abs,
01318 ws.lines_per_tg,
01319 ws.lineshape,
01320 ws.e_ground,
01321 ws.emission,
01322 ws.k_grid,
01323 ws.cont_description_names,
01324 ws.cont_description_parameters,
01325 ws.cont_description_models,
01326 ws.los,
01327 ws.absloswfs,
01328 ws.trans,
01329 ws.z_plat,
01330 ws.za_pencil,
01331 ws.l_step,
01332 ws.z_abs,
01333 ws.refr,
01334 ws.refr_lfac,
01335 ws.refr_index,
01336 ws.refr_model,
01337 ws.z_ground,
01338 ws.t_ground,
01339 ws.y_space,
01340 ws.r_geoid,
01341 ws.hse,
01342 mr.Values()[0],
01343 mr.Values()[1]);
01344 }
01345
01346 void kSpectro_g(WorkSpace& ws, const MRecord& mr)
01347 {
01348 kSpectro(ws.k,
01349 ws.k_names,
01350 ws.k_aux,
01351 ws.S_S,
01352 ws.wfss_tgs,
01353 ws.tgs,
01354 ws.f_mono,
01355 ws.p_abs,
01356 ws.t_abs,
01357 ws.z_abs,
01358 ws.h2o_abs,
01359 ws.vmrs,
01360 ws.lines_per_tg,
01361 ws.lineshape,
01362 ws.los,
01363 ws.absloswfs,
01364 mr.Values()[0],
01365 mr.Values()[1],
01366 mr.Values()[2],
01367 mr.Values()[3],
01368 mr.Values()[4],
01369 mr.Values()[5],
01370 mr.Values()[6]);
01371 }
01372
01373 void kFrequencyOffSet_g(WorkSpace& ws, const MRecord& mr)
01374 {
01375 kFrequencyOffSet(ws.k,
01376 ws.k_names,
01377 ws.k_aux,
01378 ws.tgs,
01379 ws.f_mono,
01380 ws.p_abs,
01381 ws.t_abs,
01382 ws.n2_abs,
01383 ws.h2o_abs,
01384 ws.vmrs,
01385 ws.lines_per_tg,
01386 ws.lineshape,
01387 ws.e_ground,
01388 ws.emission,
01389 ws.cont_description_names,
01390 ws.cont_description_parameters,
01391 ws.cont_description_models,
01392 ws.los,
01393 ws.t_ground,
01394 ws.y_space,
01395 ws.y,
01396 mr.Values()[0],
01397 mr.Values()[1]);
01398 }
01399
01400 void kPointingOffSet_g(WorkSpace& ws, const MRecord& mr)
01401 {
01402 kPointingOffSet(ws.k,
01403 ws.k_names,
01404 ws.k_aux,
01405 ws.z_plat,
01406 ws.za_pencil,
01407 ws.l_step,
01408 ws.p_abs,
01409 ws.z_abs,
01410 ws.t_abs,
01411 ws.f_mono,
01412 ws.refr,
01413 ws.refr_lfac,
01414 ws.refr_index,
01415 ws.z_ground,
01416 ws.r_geoid,
01417 ws.abs,
01418 ws.emission,
01419 ws.y_space,
01420 ws.e_ground,
01421 ws.t_ground,
01422 ws.y,
01423 mr.Values()[0]);
01424 }
01425
01426 void kEground_g(WorkSpace& ws, const MRecord& mr)
01427 {
01428 kEground(ws.k,
01429 ws.k_names,
01430 ws.k_aux,
01431 ws.za_pencil,
01432 ws.f_mono,
01433 ws.emission,
01434 ws.y_space,
01435 ws.e_ground,
01436 ws.t_ground,
01437 ws.los,
01438 ws.source,
01439 ws.trans,
01440 mr.Values()[0]);
01441 }
01442
01443 void kCalibration_g(WorkSpace& ws, const MRecord& mr)
01444 {
01445 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
01446 kCalibration(ws.k,
01447 ws.k_names,
01448 ws.k_aux,
01449 ws.y,
01450 ws.f_mono,
01451 *GI0,
01452 wsv_data[mr.Input()[0]].Name());
01453 }
01454
01455 void kManual_g(WorkSpace& ws, const MRecord& mr)
01456 {
01457 kManual(ws.k,
01458 ws.k_names,
01459 ws.k_aux,
01460 ws.y0,
01461 ws.y,
01462 mr.Values()[0],
01463 mr.Values()[1],
01464 mr.Values()[2],
01465 mr.Values()[3]);
01466 }
01467
01468 void kxInit_g(WorkSpace& ws, const MRecord&)
01469 {
01470 kxInit(ws.kx,
01471 ws.kx_names,
01472 ws.kx_lengths,
01473 ws.kx_aux);
01474 }
01475
01476 void kbInit_g(WorkSpace& ws, const MRecord&)
01477 {
01478 kbInit(ws.kb,
01479 ws.kb_names,
01480 ws.kb_lengths,
01481 ws.kb_aux);
01482 }
01483
01484 void kxAppend_g(WorkSpace& ws, const MRecord&)
01485 {
01486 kxAppend(ws.kx,
01487 ws.kx_names,
01488 ws.kx_lengths,
01489 ws.kx_aux,
01490 ws.k,
01491 ws.k_names,
01492 ws.k_aux);
01493 }
01494
01495 void kbAppend_g(WorkSpace& ws, const MRecord&)
01496 {
01497 kbAppend(ws.kb,
01498 ws.kb_names,
01499 ws.kb_lengths,
01500 ws.kb_aux,
01501 ws.k,
01502 ws.k_names,
01503 ws.k_aux);
01504 }
01505
01506 void kxAllocate_g(WorkSpace& ws, const MRecord& mr)
01507 {
01508 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
01509 kxAllocate(ws.kx,
01510 ws.kx_names,
01511 ws.kx_lengths,
01512 ws.kx_aux,
01513 *GI0,
01514 wsv_data[mr.Input()[0]].Name(),
01515 mr.Values()[0],
01516 mr.Values()[1]);
01517 }
01518
01519 void kbAllocate_g(WorkSpace& ws, const MRecord& mr)
01520 {
01521 Vector *GI0 = *wsv_pointers[mr.Input()[0]];
01522 kbAllocate(ws.kb,
01523 ws.kb_names,
01524 ws.kb_lengths,
01525 ws.kb_aux,
01526 *GI0,
01527 wsv_data[mr.Input()[0]].Name(),
01528 mr.Values()[0],
01529 mr.Values()[1]);
01530 }
01531
01532 void kxPutInK_g(WorkSpace& ws, const MRecord&)
01533 {
01534 kxPutInK(ws.kx,
01535 ws.kx_names,
01536 ws.kx_lengths,
01537 ws.kx_aux,
01538 ws.k,
01539 ws.k_names,
01540 ws.k_aux);
01541 }
01542
01543 void kbPutInK_g(WorkSpace& ws, const MRecord&)
01544 {
01545 kbPutInK(ws.kb,
01546 ws.kb_names,
01547 ws.kb_lengths,
01548 ws.kb_aux,
01549 ws.k,
01550 ws.k_names,
01551 ws.k_aux);
01552 }
01553
01554 void ybatchCalc_g(WorkSpace& ws, const MRecord& mr)
01555 {
01556 ybatchCalc(ws.ybatch,
01557 ws.f_mono,
01558 ws.p_abs,
01559 ws.t_abs,
01560 ws.n2_abs,
01561 ws.h2o_abs,
01562 ws.vmrs,
01563 ws.lines_per_tg,
01564 ws.lineshape,
01565 ws.z_abs,
01566 ws.z_plat,
01567 ws.za_pencil,
01568 ws.l_step,
01569 ws.refr,
01570 ws.refr_lfac,
01571 ws.refr_index,
01572 ws.z_ground,
01573 ws.r_geoid,
01574 ws.emission,
01575 ws.y_space,
01576 ws.e_ground,
01577 ws.t_ground,
01578 ws.batchname,
01579 ws.tgs,
01580 ws.cont_description_names,
01581 ws.cont_description_parameters,
01582 ws.cont_description_models,
01583 mr.Values()[0],
01584 mr.Values()[1],
01585 mr.Values()[2],
01586 mr.Values()[3],
01587 mr.Values()[4],
01588 mr.Values()[5],
01589 mr.Values()[6],
01590 mr.Values()[7],
01591 mr.Values()[8],
01592 mr.Values()[9],
01593 mr.Values()[10]);
01594 }
01595
01596 void ybatchFromRadiosonde_g(WorkSpace& ws, const MRecord& mr)
01597 {
01598 ybatchFromRadiosonde(ws.ybatch,
01599 ws.absbatch,
01600 ws.jacbatch,
01601 ws.radiosonde_data,
01602 ws.f_mono,
01603 ws.lines_per_tg,
01604 ws.lineshape,
01605 ws.z_plat,
01606 ws.za_pencil,
01607 ws.l_step,
01608 ws.refr,
01609 ws.refr_model,
01610 ws.refr_lfac,
01611 ws.r_geoid,
01612 ws.emission,
01613 ws.y_space,
01614 ws.e_ground,
01615 ws.tgs,
01616 ws.cont_description_names,
01617 ws.cont_description_models,
01618 ws.cont_description_parameters,
01619 mr.Values()[0],
01620 mr.Values()[1],
01621 mr.Values()[2],
01622 mr.Values()[3],
01623 mr.Values()[4],
01624 mr.Values()[5]);
01625 }
01626
01627 void ybatchFromRadiosondeGlobal_g(WorkSpace& ws, const MRecord&)
01628 {
01629 ybatchFromRadiosondeGlobal(ws.ybatch,
01630 ws.radiosonde_data,
01631 ws.f_mono,
01632 ws.lines_per_tg,
01633 ws.lineshape,
01634 ws.z_plat,
01635 ws.za_pencil,
01636 ws.l_step,
01637 ws.refr,
01638 ws.refr_model,
01639 ws.refr_lfac,
01640 ws.r_geoid,
01641 ws.emission,
01642 ws.y_space,
01643 ws.e_ground,
01644 ws.tgs,
01645 ws.cont_description_names,
01646 ws.cont_description_models,
01647 ws.cont_description_parameters);
01648 }
01649
01650 void MethodListDefine_g(WorkSpace&, const MRecord& mr)
01651 {
01652 ArrayOfIndex *GO0 = *wsv_pointers[mr.Output()[0]];
01653 MethodListDefine(*GO0,
01654 wsv_data[mr.Output()[0]].Name(),
01655 mr.Values()[0]);
01656 }
01657
01658
01659 void (*getaways[])(WorkSpace&, const MRecord&)
01660 = {Echo_g,
01661 Exit_g,
01662 Test_g,
01663 IndexSet_g,
01664 IndexWriteAscii_g,
01665 IndexReadAscii_g,
01666 IndexWriteBinary_g,
01667 IndexReadBinary_g,
01668 NumericSet_g,
01669 NumericCopyFirstOfVector_g,
01670 NumericCopyLastOfVector_g,
01671 NumericWriteAscii_g,
01672 NumericReadAscii_g,
01673 NumericWriteBinary_g,
01674 NumericReadBinary_g,
01675 VectorCopy_g,
01676 VectorCopyFromMatrix_g,
01677 VectorSet_g,
01678 VectorSetLengthFromVector_g,
01679 VectorLinSpace_g,
01680 VectorNLinSpace_g,
01681 VectorNLogSpace_g,
01682 VectorPressuresForLinAltitudes_g,
01683 VectorFlip_g,
01684 VectorMatrixMultiply_g,
01685 VectorWriteAscii_g,
01686 VectorReadAscii_g,
01687 VectorWriteBinary_g,
01688 VectorReadBinary_g,
01689 VectorPlanck_g,
01690 VectorCalcLog10_g,
01691 VectorAdd_g,
01692 VectorScale_g,
01693 MatrixSet_g,
01694 MatrixCopy_g,
01695 MatrixFillWithVector_g,
01696 MatrixMatrixMultiply_g,
01697 ArrayOfMatrixMatrixMultiply_g,
01698 MatrixMatrixAdd_g,
01699 MatrixWriteAscii_g,
01700 MatrixReadAscii_g,
01701 MatrixWriteBinary_g,
01702 MatrixReadBinary_g,
01703 MatrixScale_g,
01704 MatrixDiagonal_g,
01705 ArrayOfIndexWriteAscii_g,
01706 ArrayOfIndexReadAscii_g,
01707 ArrayOfIndexWriteBinary_g,
01708 ArrayOfIndexReadBinary_g,
01709 ArrayOfVectorWriteAscii_g,
01710 ArrayOfVectorReadAscii_g,
01711 ArrayOfVectorWriteBinary_g,
01712 ArrayOfVectorReadBinary_g,
01713 ArrayOfMatrixWriteAscii_g,
01714 ArrayOfMatrixReadAscii_g,
01715 ArrayOfMatrixWriteBinary_g,
01716 ArrayOfMatrixReadBinary_g,
01717 StringSet_g,
01718 StringWriteAscii_g,
01719 StringReadAscii_g,
01720 StringWriteBinary_g,
01721 StringReadBinary_g,
01722 ArrayOfStringSet_g,
01723 ArrayOfStringWriteAscii_g,
01724 ArrayOfStringReadAscii_g,
01725 ArrayOfStringWriteBinary_g,
01726 ArrayOfStringReadBinary_g,
01727 TagGroupsSpeciesWriteAscii_g,
01728 LosWriteBinary_g,
01729 LosReadBinary_g,
01730 lines_per_tgSetEmpty_g,
01731 lines_per_tgReadFromCatalogues_g,
01732 linesReadFromHitran_g,
01733 linesReadFromHitran2004_g,
01734 linesReadFromMytran2_g,
01735 linesReadFromJpl_g,
01736 linesReadFromArts_g,
01737 linesElowToJoule_g,
01738 lines_per_tgCreateFromLines_g,
01739 lines_per_tgAddMirrorLines_g,
01740 lines_per_tgCompact_g,
01741 linesWriteAscii_g,
01742 lines_per_tgWriteAscii_g,
01743 tgsDefine_g,
01744 tgsDefineAllInScenario_g,
01745 lineshapeDefine_g,
01746 lineshape_per_tgDefine_g,
01747 cont_descriptionInit_g,
01748 cont_descriptionAppend_g,
01749 raw_vmrsReadFromFiles_g,
01750 raw_vmrsReadFromScenario_g,
01751 AtmFromRaw_g,
01752 WaterVaporSaturationInClouds_g,
01753 vmrsScale_g,
01754 h2o_absSet_g,
01755 n2_absSet_g,
01756 hseSet_g,
01757 hseSetFromLatitude_g,
01758 hseSetFromLatitudeIndex_g,
01759 hseFromBottom_g,
01760 hseOff_g,
01761 hseCalc_g,
01762 absCalc_g,
01763 absCalcSaveMemory_g,
01764 absCalcFromXsec_g,
01765 xsec_per_tgInit_g,
01766 xsec_per_tgAddLines_g,
01767 xsec_per_tgAddConts_g,
01768 abs_per_tgReduce_g,
01769 refrSet_g,
01770 refrOff_g,
01771 refrCalc_g,
01772 zaFromZtan_g,
01773 zaFromDeltat_g,
01774 r_geoidStd_g,
01775 r_geoidWGS84_g,
01776 groundOff_g,
01777 groundSet_g,
01778 groundAtBottom_g,
01779 groundFlatSea_g,
01780 emissionOn_g,
01781 emissionOff_g,
01782 losCalc_g,
01783 sourceCalc_g,
01784 transCalc_g,
01785 y_spaceStd_g,
01786 yCalc_g,
01787 sourcetransyCalcSaveMemory_g,
01788 CoolingRates_g,
01789 yTB_g,
01790 MatrixTB_g,
01791 yTRJ_g,
01792 MatrixTRJ_g,
01793 wfs_tgsDefine_g,
01794 wfss_tgsDefine_g,
01795 absloswfsCalc_g,
01796 kSpecies_g,
01797 kSpeciesSingle_g,
01798 kContAbs_g,
01799 kTemp_g,
01800 kSpectro_g,
01801 kFrequencyOffSet_g,
01802 kPointingOffSet_g,
01803 kEground_g,
01804 kCalibration_g,
01805 kManual_g,
01806 kxInit_g,
01807 kbInit_g,
01808 kxAppend_g,
01809 kbAppend_g,
01810 kxAllocate_g,
01811 kbAllocate_g,
01812 kxPutInK_g,
01813 kbPutInK_g,
01814 ybatchCalc_g,
01815 ybatchFromRadiosonde_g,
01816 ybatchFromRadiosondeGlobal_g,
01817 MethodListDefine_g};
01818
